Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // This file contains utility functions and classes that help the
      6 // implementation, and management of the Callback objects.
      7 
      8 #ifndef BASE_CALLBACK_INTERNAL_H_
      9 #define BASE_CALLBACK_INTERNAL_H_
     10 
     11 #include "base/base_export.h"
     12 #include "base/callback_forward.h"
     13 #include "base/macros.h"
     14 #include "base/memory/ref_counted.h"
     15 
     16 namespace base {
     17 
     18 struct FakeBindState;
     19 
     20 namespace internal {
     21 
     22 template <CopyMode copy_mode>
     23 class CallbackBase;
     24 
     25 class BindStateBase;
     26 
     27 template <typename Functor, typename... BoundArgs>
     28 struct BindState;
     29 
     30 struct BindStateBaseRefCountTraits {
     31   static void Destruct(const BindStateBase*);
     32 };
     33 
     34 // BindStateBase is used to provide an opaque handle that the Callback
     35 // class can use to represent a function object with bound arguments.  It
     36 // behaves as an existential type that is used by a corresponding
     37 // DoInvoke function to perform the function execution.  This allows
     38 // us to shield the Callback class from the types of the bound argument via
     39 // "type erasure."
     40 // At the base level, the only task is to add reference counting data. Don't use
     41 // RefCountedThreadSafe since it requires the destructor to be a virtual method.
     42 // Creating a vtable for every BindState template instantiation results in a lot
     43 // of bloat. Its only task is to call the destructor which can be done with a
     44 // function pointer.
     45 class BASE_EXPORT BindStateBase
     46     : public RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits> {
     47  public:
     48   REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
     49 
     50   using InvokeFuncStorage = void(*)();
     51 
     52  private:
     53   BindStateBase(InvokeFuncStorage polymorphic_invoke,
     54                 void (*destructor)(const BindStateBase*));
     55   BindStateBase(InvokeFuncStorage polymorphic_invoke,
     56                 void (*destructor)(const BindStateBase*),
     57                 bool (*is_cancelled)(const BindStateBase*));
     58 
     59   ~BindStateBase() = default;
     60 
     61   friend struct BindStateBaseRefCountTraits;
     62   friend class RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits>;
     63 
     64   template <CopyMode copy_mode>
     65   friend class CallbackBase;
     66 
     67   // Whitelist subclasses that access the destructor of BindStateBase.
     68   template <typename Functor, typename... BoundArgs>
     69   friend struct BindState;
     70   friend struct ::base::FakeBindState;
     71 
     72   bool IsCancelled() const {
     73     return is_cancelled_(this);
     74   }
     75 
     76   // In C++, it is safe to cast function pointers to function pointers of
     77   // another type. It is not okay to use void*. We create a InvokeFuncStorage
     78   // that that can store our function pointer, and then cast it back to
     79   // the original type on usage.
     80   InvokeFuncStorage polymorphic_invoke_;
     81 
     82   // Pointer to a function that will properly destroy |this|.
     83   void (*destructor_)(const BindStateBase*);
     84   bool (*is_cancelled_)(const BindStateBase*);
     85 
     86   DISALLOW_COPY_AND_ASSIGN(BindStateBase);
     87 };
     88 
     89 // Holds the Callback methods that don't require specialization to reduce
     90 // template bloat.
     91 // CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and
     92 // CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation.
     93 template <>
     94 class BASE_EXPORT CallbackBase<CopyMode::MoveOnly> {
     95  public:
     96   CallbackBase(CallbackBase&& c);
     97   CallbackBase& operator=(CallbackBase&& c);
     98 
     99   explicit CallbackBase(const CallbackBase<CopyMode::Copyable>& c);
    100   CallbackBase& operator=(const CallbackBase<CopyMode::Copyable>& c);
    101 
    102   explicit CallbackBase(CallbackBase<CopyMode::Copyable>&& c);
    103   CallbackBase& operator=(CallbackBase<CopyMode::Copyable>&& c);
    104 
    105   // Returns true if Callback is null (doesn't refer to anything).
    106   bool is_null() const { return !bind_state_; }
    107   explicit operator bool() const { return !is_null(); }
    108 
    109   // Returns true if the callback invocation will be nop due to an cancellation.
    110   // It's invalid to call this on uninitialized callback.
    111   bool IsCancelled() const;
    112 
    113   // Returns the Callback into an uninitialized state.
    114   void Reset();
    115 
    116  protected:
    117   using InvokeFuncStorage = BindStateBase::InvokeFuncStorage;
    118 
    119   // Returns true if this callback equals |other|. |other| may be null.
    120   bool EqualsInternal(const CallbackBase& other) const;
    121 
    122   // Allow initializing of |bind_state_| via the constructor to avoid default
    123   // initialization of the scoped_refptr.
    124   explicit CallbackBase(BindStateBase* bind_state);
    125 
    126   InvokeFuncStorage polymorphic_invoke() const {
    127     return bind_state_->polymorphic_invoke_;
    128   }
    129 
    130   // Force the destructor to be instantiated inside this translation unit so
    131   // that our subclasses will not get inlined versions.  Avoids more template
    132   // bloat.
    133   ~CallbackBase();
    134 
    135   scoped_refptr<BindStateBase> bind_state_;
    136 };
    137 
    138 // CallbackBase<Copyable> is a direct base class of Copyable Callbacks.
    139 template <>
    140 class BASE_EXPORT CallbackBase<CopyMode::Copyable>
    141     : public CallbackBase<CopyMode::MoveOnly> {
    142  public:
    143   CallbackBase(const CallbackBase& c);
    144   CallbackBase(CallbackBase&& c);
    145   CallbackBase& operator=(const CallbackBase& c);
    146   CallbackBase& operator=(CallbackBase&& c);
    147  protected:
    148   explicit CallbackBase(BindStateBase* bind_state)
    149       : CallbackBase<CopyMode::MoveOnly>(bind_state) {}
    150   ~CallbackBase() {}
    151 };
    152 
    153 extern template class CallbackBase<CopyMode::MoveOnly>;
    154 extern template class CallbackBase<CopyMode::Copyable>;
    155 
    156 }  // namespace internal
    157 }  // namespace base
    158 
    159 #endif  // BASE_CALLBACK_INTERNAL_H_
    160