| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // This file contains utility functions and classes that help the |
| // implementation, and management of the Callback objects. |
| |
| #ifndef BASE_CALLBACK_INTERNAL_H_ |
| #define BASE_CALLBACK_INTERNAL_H_ |
| |
| #include <atomic> |
| |
| #include "base/base_export.h" |
| #include "base/callback_forward.h" |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| |
| namespace base { |
| namespace internal { |
| template <CopyMode copy_mode> |
| class CallbackBase; |
| |
| // BindStateBase is used to provide an opaque handle that the Callback |
| // class can use to represent a function object with bound arguments. It |
| // behaves as an existential type that is used by a corresponding |
| // DoInvoke function to perform the function execution. This allows |
| // us to shield the Callback class from the types of the bound argument via |
| // "type erasure." |
| // At the base level, the only task is to add reference counting data. Don't use |
| // RefCountedThreadSafe since it requires the destructor to be a virtual method. |
| // Creating a vtable for every BindState template instantiation results in a lot |
| // of bloat. Its only task is to call the destructor which can be done with a |
| // function pointer. |
| class BindStateBase { |
| protected: |
| explicit BindStateBase(void (*destructor)(BindStateBase*)) |
| : ref_count_(0), destructor_(destructor) {} |
| ~BindStateBase() = default; |
| |
| private: |
| friend class scoped_refptr<BindStateBase>; |
| template <CopyMode copy_mode> |
| friend class CallbackBase; |
| |
| void AddRef(); |
| void Release(); |
| |
| std::atomic<int32_t> ref_count_; |
| |
| // Pointer to a function that will properly destroy |this|. |
| void (*destructor_)(BindStateBase*); |
| |
| DISALLOW_COPY_AND_ASSIGN(BindStateBase); |
| }; |
| |
| // Holds the Callback methods that don't require specialization to reduce |
| // template bloat. |
| // CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and |
| // CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation. |
| template <> |
| class BASE_EXPORT CallbackBase<CopyMode::MoveOnly> { |
| public: |
| CallbackBase(CallbackBase&& c); |
| CallbackBase& operator=(CallbackBase&& c); |
| |
| // Returns true if Callback is null (doesn't refer to anything). |
| bool is_null() const { return bind_state_.get() == NULL; } |
| explicit operator bool() const { return !is_null(); } |
| |
| // Returns the Callback into an uninitialized state. |
| void Reset(); |
| |
| protected: |
| // In C++, it is safe to cast function pointers to function pointers of |
| // another type. It is not okay to use void*. We create a InvokeFuncStorage |
| // that that can store our function pointer, and then cast it back to |
| // the original type on usage. |
| using InvokeFuncStorage = void(*)(); |
| |
| // Returns true if this callback equals |other|. |other| may be null. |
| bool EqualsInternal(const CallbackBase& other) const; |
| |
| // Allow initializing of |bind_state_| via the constructor to avoid default |
| // initialization of the scoped_refptr. We do not also initialize |
| // |polymorphic_invoke_| here because doing a normal assignment in the |
| // derived Callback templates makes for much nicer compiler errors. |
| explicit CallbackBase(BindStateBase* bind_state); |
| |
| // Force the destructor to be instantiated inside this translation unit so |
| // that our subclasses will not get inlined versions. Avoids more template |
| // bloat. |
| ~CallbackBase(); |
| |
| scoped_refptr<BindStateBase> bind_state_; |
| InvokeFuncStorage polymorphic_invoke_ = nullptr; |
| }; |
| |
| // CallbackBase<Copyable> is a direct base class of Copyable Callbacks. |
| template <> |
| class BASE_EXPORT CallbackBase<CopyMode::Copyable> |
| : public CallbackBase<CopyMode::MoveOnly> { |
| public: |
| CallbackBase(const CallbackBase& c); |
| CallbackBase(CallbackBase&& c); |
| CallbackBase& operator=(const CallbackBase& c); |
| CallbackBase& operator=(CallbackBase&& c); |
| protected: |
| explicit CallbackBase(BindStateBase* bind_state) |
| : CallbackBase<CopyMode::MoveOnly>(bind_state) {} |
| ~CallbackBase() {} |
| }; |
| |
| extern template class CallbackBase<CopyMode::MoveOnly>; |
| extern template class CallbackBase<CopyMode::Copyable>; |
| |
| } // namespace internal |
| } // namespace base |
| |
| #endif // BASE_CALLBACK_INTERNAL_H_ |