Support move-only type on base::Callback::Run

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 368 matching lines @@
     PolymorphicInvoke invoke_func =
         &internal::BindState<Runnable, BindRunType, BoundArgsType...>
             ::InvokerType::Run;
     polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
   }
 
   bool Equals(const Callback& other) const {
     return CallbackBase::Equals(other);
   }
 
-  R Run(typename internal::CallbackParamTraits<Args>::ForwardType... args)
-      const {
+  // Run() makes an extra copy of an argument comparing to the direct call
+  // if an item of |args| is passed-by-value and a copyable-but-not-movable.

[dcheng, 2016/03/02 23:00:57]

Nit: 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:

[tzik, 2016/03/03 18:53:19]

Done.

+  // I.e. below copies CopyableNonMovableType twice.

[dcheng, 2016/03/02 23:00:57]

Nit: i.e.

[tzik, 2016/03/03 18:53:19]

Done.

+  //   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 the
+  // information how the caller passed the argument, but we have to fix the type
+  // of |f| before we know how the arguments of Callback::Run() are passed.

[dcheng, 2016/03/02 23:00:57]

Nit: Perfect Forwarding requires knowing how the caller will pass the arguments.
However, the signature of Run() needs to be fixed in the callback constructor,
so Run() cannot template its arguments based on how it's called.

[tzik, 2016/03/03 18:53:19]

Done, but slightly modified.
We can template Callback::Run() to use Universal References with some caller
side change (e.g. NULL to nullptr rewrite and to avoid to take a function
pointer to Callback::Run), though it makes Run() impl very complicated and
doesn't reduce any copy.

+  R Run(Args... args) const {
     PolymorphicInvoke f =
         reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-
-    return f(bind_state_.get(), internal::CallbackForward(args)...);
+    return f(bind_state_.get(), std::forward<Args>(args)...);
   }
 
  private:
-  using PolymorphicInvoke =
-      R(*)(internal::BindStateBase*,
-           typename internal::CallbackParamTraits<Args>::ForwardType...);
+  using PolymorphicInvoke = R (*)(internal::BindStateBase*, Args&&...);
 };
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H_