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

base/bind_internal.h

 // Copyright (c) 2011 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_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include <stddef.h>
 
 #include <type_traits>
@@ skipping 321 matching lines @@
 //
 // See description at the top of the file.
 template <typename BoundIndices, typename StorageType,
           typename InvokeHelperType, typename UnboundForwardRunType>
 struct Invoker;
 
 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)...);
   }
 };
 
 // Used to implement MakeArgsStorage.
 template <bool is_method, typename... BoundArgs>
 struct MakeArgsStorageImpl {
   using Type = std::tuple<BoundArgs...>;
 };
 
 template <typename Obj, typename... BoundArgs>
@@ skipping 34 matching lines @@
   using RunnableType = Runnable;
 
   enum { is_method = HasIsMethodTag<Runnable>::value };
 
   // true_type if Runnable is a method invocation and the first bound argument
   // is a WeakPtr.
   using IsWeakCall =
       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)
       : BindStateBase(&Destroy),
         runnable_(runnable),
         bound_args_(std::forward<ForwardArgs>(bound_args)...) {}
 
   RunnableType runnable_;
   MakeArgsStorage<is_method, BoundArgs...> bound_args_;
 
  private:
   ~BindState() {}
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_