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

base/bind_internal.h

Index: base/bind_internal.h
diff --git a/base/bind_internal.h b/base/bind_internal.h
index f296bbcc353f10e48a18f1113857aff8b0221a1d..38a5756e79a7d948d0b8afd32768a4c3a74425b3 100644
--- a/base/bind_internal.h
+++ b/base/bind_internal.h
@@ -339,19 +339,19 @@ template <size_t... bound_indices,
           typename StorageType,
           typename InvokeHelperType,
           typename R,
-          typename... UnboundForwardArgs>
-struct Invoker<IndexSequence<bound_indices...>, StorageType,
-               InvokeHelperType, R(UnboundForwardArgs...)> {
-  static R Run(BindStateBase* base,
-               UnboundForwardArgs... unbound_args) {
+          typename... UnboundArgs>
+struct Invoker<IndexSequence<bound_indices...>,
+               StorageType,
+               InvokeHelperType,
+               R(UnboundArgs...)> {
+  static R Run(BindStateBase* base, UnboundArgs&&... unbound_args) {

[dcheng, 2016/03/02 00:25:45]

Just thinking out loud: what happens if we have:

  template<typename... RunArgs>
  static R Run(BindStateBase* base, RunArgs&& run_args) {
    return InvokeHelperType::MakeItSo(..., std::forward<RunArgs>(run_args)...);
  }

I guess maybe that doesn't get us anything, since we already have UnboundArgs&&,
and it's more complicated… ok so I think this is fine.

[tzik, 2016/03/02 01:04:21]

Hmm, since we need to take a function pointer to Invoker<>::Run in Callback, we
need to instantiate it earlier than Callback::Run is called like:
PolymorphicInvoke invoke_func =
  &internal::BindState<>::InvokerType::Run<Args...>;
in Callback::Callback().

This will make Invoker simpler a bit, and will work on gcc and cl.exe. Not sure
it works on clang.
Anyway, let me try it on a separate CL.

     StorageType* storage = static_cast<StorageType*>(base);
     // Local references to make debugger stepping easier. If in a debugger,
     // you really want to warp ahead and step through the
     // InvokeHelper<>::MakeItSo() call below.
     return InvokeHelperType::MakeItSo(
-        storage->runnable_,
-        Unwrap(get<bound_indices>(storage->bound_args_))...,
-        CallbackForward(unbound_args)...);
+        storage->runnable_, Unwrap(get<bound_indices>(storage->bound_args_))...,
+        std::forward<UnboundArgs>(unbound_args)...);
   }
 };
 
@@ -406,18 +406,14 @@ struct BindState<Runnable, R(Args...), BoundArgs...> final
       IsWeakMethod<is_method, typename std::decay<BoundArgs>::type...>;
 
   using BoundIndices = MakeIndexSequence<sizeof...(BoundArgs)>;
-  using UnboundForwardArgs = DropTypeListItem<
-      sizeof...(BoundArgs),
-      TypeList<typename CallbackParamTraits<Args>::ForwardType...>>;
-  using UnboundForwardRunType = MakeFunctionType<R, UnboundForwardArgs>;
   using InvokeHelperType = InvokeHelper<IsWeakCall::value, R, Runnable>;
 
   using UnboundArgs = DropTypeListItem<sizeof...(BoundArgs), TypeList<Args...>>;
 
  public:
-  using InvokerType = Invoker<BoundIndices, StorageType,
-                              InvokeHelperType, UnboundForwardRunType>;
   using UnboundRunType = MakeFunctionType<R, UnboundArgs>;
+  using InvokerType =
+      Invoker<BoundIndices, StorageType, InvokeHelperType, UnboundRunType>;
 
   template <typename... ForwardArgs>
   BindState(const Runnable& runnable, ForwardArgs&&... bound_args)