Extend base::Callback to have a move-only variant

base/callback.h

 // 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.
 
 #ifndef BASE_CALLBACK_H_
 #define BASE_CALLBACK_H_
 
 #include "base/callback_forward.h"
 #include "base/callback_internal.h"
 #include "base/template_util.h"
@@ skipping 323 matching lines @@
 //
 //
 // MISSING FUNCTIONALITY
 //  - Invoking the return of Bind.  Bind(&foo).Run() does not work;
 //  - Binding arrays to functions that take a non-const pointer.
 //    Example:
 //      void Foo(const char* ptr);
 //      void Bar(char* ptr);
 //      Bind(&Foo, "test");
 //      Bind(&Bar, "test");  // This fails because ptr is not const.
-
-namespace base {
-
-// First, we forward declare the Callback class template. This informs the
-// compiler that the template only has 1 type parameter which is the function
-// signature that the Callback is representing.
-//
-// After this, create template specializations for 0-7 parameters. Note that
-// even though the template typelist grows, the specialization still
-// only has one type: the function signature.
 //
 // If you are thinking of forward declaring Callback in your own header file,
 // please include "base/callback_forward.h" instead.
 
+namespace base {
 namespace internal {
 template <typename Runnable, typename RunType, typename... BoundArgsType>
 struct BindState;
 }  // namespace internal
 
-template <typename R, typename... Args>
-class Callback<R(Args...)> : public internal::CallbackBase {
+template <typename R, typename... Args, internal::CopyMode copy_mode>
+class Callback<R(Args...), copy_mode>
+    : public internal::CallbackBase<copy_mode> {
  public:
   // MSVC 2013 doesn't support Type Alias of function types.
   // Revisit this after we update it to newer version.
   typedef R RunType(Args...);
 
-  Callback() : CallbackBase(nullptr) { }
+  Callback() : internal::CallbackBase<copy_mode>(nullptr) {}
 
-  template <typename Runnable, typename BindRunType, typename... BoundArgsType>
+  template <typename Runnable, typename BindRunType, typename... BoundArgs>
   explicit Callback(
-      internal::BindState<Runnable, BindRunType, BoundArgsType...>* bind_state)
-      : CallbackBase(bind_state) {
+      internal::BindState<Runnable, BindRunType, BoundArgs...>* bind_state)
+      : internal::CallbackBase<copy_mode>(bind_state) {
     // Force the assignment to a local variable of PolymorphicInvoke
     // so the compiler will typecheck that the passed in Run() method has
     // the correct type.
     PolymorphicInvoke invoke_func =
-        &internal::BindState<Runnable, BindRunType, BoundArgsType...>
+        &internal::BindState<Runnable, BindRunType, BoundArgs...>
             ::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+    using InvokeFuncStorage =
+        typename internal::CallbackBase<copy_mode>::InvokeFuncStorage;
+    this->polymorphic_invoke_ =
+        reinterpret_cast<InvokeFuncStorage>(invoke_func);
   }
 
   bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
+    return this->EqualsInternal(other);
   }
 
   // Run() makes an extra copy compared to directly calling the bound function
   // if an argument is passed-by-value and is copyable-but-not-movable:
   // i.e. below copies CopyableNonMovableType twice.
   //   void F(CopyableNonMovableType) {}
   //   Bind(&F).Run(CopyableNonMovableType());
   //
   // We can not fully apply Perfect Forwarding idiom to the callchain from
   // Callback::Run() to the target function. Perfect Forwarding requires
   // knowing how the caller will pass the arguments. However, the signature of
   // InvokerType::Run() needs to be fixed in the callback constructor, so Run()
   // cannot template its arguments based on how it's called.
   R Run(Args... args) const {
     PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-    return f(bind_state_.get(), std::forward<Args>(args)...);
+        reinterpret_cast<PolymorphicInvoke>(this->polymorphic_invoke_);
+    return f(this->bind_state_.get(), std::forward<Args>(args)...);
   }
 
  private:
   using PolymorphicInvoke = R (*)(internal::BindStateBase*, Args&&...);
 };
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H_