WIP: base::Bind for rvalue references.

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 <type_traits>
 
 #include "base/bind_helpers.h"
@@ skipping 90 matching lines @@
 
 // BindsArrayToFirstArg selects true_type when |is_method| is true and the first
 // item of |Args| is an array type.
 // Implementation note: This non-specialized case handles !is_method case and
 // zero-arity case only.  Other cases should be handled by the specialization
 // below.
 template <bool is_method, typename... Args>
 struct BindsArrayToFirstArg : false_type {};
 
 template <typename T, typename... Args>
-struct BindsArrayToFirstArg<true, T, Args...> : is_array<T> {};
+struct BindsArrayToFirstArg<true, T, Args...>
+    : is_array<typename std::remove_reference<T>::type> {};
 
 // HasRefCountedParamAsRawPtr is the same to HasRefCountedTypeAsRawPtr except
 // when |is_method| is true HasRefCountedParamAsRawPtr skips the first argument.
 // Implementation note: This non-specialized case handles !is_method case and
 // zero-arity case only.  Other cases should be handled by the specialization
 // below.
 template <bool is_method, typename... Args>
 struct HasRefCountedParamAsRawPtr : HasRefCountedTypeAsRawPtr<Args...> {};
 
 template <typename T, typename... Args>
@@ skipping 26 matching lines @@
 // Function.
 template <typename R, typename... Args>
 class RunnableAdapter<R(*)(Args...)> {
  public:
   typedef R (RunType)(Args...);
 
   explicit RunnableAdapter(R(*function)(Args...))
       : function_(function) {
   }
 
-  R Run(typename CallbackParamTraits<Args>::ForwardType... args) {
-    return function_(CallbackForward(args)...);
+  template <typename... RunArgs>
+  R Run(RunArgs&&... args) {
+    return function_(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (*function_)(Args...);
 };
 
 // Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...)> {
  public:
   typedef R (RunType)(T*, Args...);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(Args...))
       : method_(method) {
   }
 
-  R Run(T* object, typename CallbackParamTraits<Args>::ForwardType... args) {
-    return (object->*method_)(CallbackForward(args)...);
+  template <typename... RunArgs>
+  R Run(T* object, RunArgs&&... args) {
+    return (object->*method_)(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (T::*method_)(Args...);
 };
 
 // Const Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...) const> {
  public:
   typedef R (RunType)(const T*, Args...);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(Args...) const)
       : method_(method) {
   }
 
+  template <typename... RunArgs>
   R Run(const T* object,
-        typename CallbackParamTraits<Args>::ForwardType... args) {
-    return (object->*method_)(CallbackForward(args)...);
+        RunArgs&&... args) {
+    return (object->*method_)(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (T::*method_)(Args...) const;
 };
 
 
 // ForceVoidReturn<>
 //
 // Set of templates that support forcing the function return type to void.
@@ skipping 68 matching lines @@
 // from the invocation call.
 //
 // WeakCalls similarly need special syntax that is applied to the first
 // argument to check if they should no-op themselves.
 template <bool IsWeakCall, typename ReturnType, typename Runnable,
           typename ArgsType>
 struct InvokeHelper;
 
 template <typename ReturnType, typename Runnable, typename... Args>
 struct InvokeHelper<false, ReturnType, Runnable, TypeList<Args...>> {
-  static ReturnType MakeItSo(Runnable runnable, Args... args) {
-    return runnable.Run(CallbackForward(args)...);
+  template <typename... RunArgs>
+  static ReturnType MakeItSo(Runnable runnable, RunArgs&&... args) {
+    return runnable.Run(std::forward<RunArgs>(args)...);
   }
 };
 
 template <typename Runnable, typename... Args>
 struct InvokeHelper<false, void, Runnable, TypeList<Args...>> {
-  static void MakeItSo(Runnable runnable, Args... args) {
-    runnable.Run(CallbackForward(args)...);
+  template <typename... RunArgs>
+  static void MakeItSo(Runnable runnable, RunArgs&&... args) {
+    runnable.Run(std::forward<RunArgs>(args)...);
   }
 };
 
 template <typename Runnable, typename BoundWeakPtr, typename... Args>
 struct InvokeHelper<true, void, Runnable, TypeList<BoundWeakPtr, Args...>> {
-  static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, Args... args) {
+  template <typename... RunArgs>
+  static void MakeItSo(Runnable runnable,
+                       BoundWeakPtr weak_ptr,
+                       RunArgs&&... args) {
     if (!weak_ptr.get()) {
       return;
     }
-    runnable.Run(weak_ptr.get(), CallbackForward(args)...);
+    runnable.Run(weak_ptr.get(), std::forward<RunArgs>(args)...);
   }
 };
 
 #if !defined(_MSC_VER)
 
 template <typename ReturnType, typename Runnable, typename ArgsType>
 struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
   // WeakCalls are only supported for functions with a void return type.
   // Otherwise, the function result would be undefined if the the WeakPtr<>
   // is invalidated.
@@ skipping 14 matching lines @@
 template <size_t... bound_indices,
           typename StorageType,
           typename... Unwrappers,
           typename InvokeHelperType,
           typename R,
           typename... UnboundForwardArgs>
 struct Invoker<IndexSequence<bound_indices...>,
                StorageType, TypeList<Unwrappers...>,
                InvokeHelperType, R(UnboundForwardArgs...)> {
   static R Run(BindStateBase* base,
-               UnboundForwardArgs... unbound_args) {
+               typename CallbackParamTraits<
+                   UnboundForwardArgs>::ForwardType... unbound_args) {
     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_,
         Unwrappers::Unwrap(get<bound_indices>(storage->bound_args_))...,
-        CallbackForward(unbound_args)...);
+        CallbackForward2(unbound_args)...);
   }
 };
 
-
 // BindState<>
 //
 // This stores all the state passed into Bind() and is also where most
 // of the template resolution magic occurs.
 //
 // Runnable is the functor we are binding arguments to.
 // RunType is type of the Run() function that the Invoker<> should use.
 // Normally, this is the same as the RunType of the Runnable, but it can
 // be different if an adapter like IgnoreResult() has been used.
 //
@@ skipping 12 matching lines @@
   using StorageType = BindState<Runnable, R(Args...), TypeList<BoundArgs...>>;
   using RunnableType = Runnable;
 
   // true_type if Runnable is a method invocation and the first bound argument
   // is a WeakPtr.
   using IsWeakCall =
       IsWeakMethod<HasIsMethodTag<Runnable>::value, BoundArgs...>;
 
   using BoundIndices = MakeIndexSequence<sizeof...(BoundArgs)>;
   using Unwrappers = TypeList<UnwrapTraits<BoundArgs>...>;
-  using UnboundForwardArgs = DropTypeListItem<
-      sizeof...(BoundArgs),
-      TypeList<typename CallbackParamTraits<Args>::ForwardType...>>;
+  using UnboundForwardArgs =
+      DropTypeListItem<sizeof...(BoundArgs), TypeList<Args...>>;
   using UnboundForwardRunType = MakeFunctionType<R, UnboundForwardArgs>;
 
   using InvokeHelperArgs = ConcatTypeLists<
       TypeList<typename UnwrapTraits<BoundArgs>::ForwardType...>,
       UnboundForwardArgs>;
   using InvokeHelperType =
       InvokeHelper<IsWeakCall::value, R, Runnable, InvokeHelperArgs>;
 
   using UnboundArgs = DropTypeListItem<sizeof...(BoundArgs), TypeList<Args...>>;
 
  public:
   using InvokerType = Invoker<BoundIndices, StorageType, Unwrappers,
                               InvokeHelperType, UnboundForwardRunType>;
   using UnboundRunType = MakeFunctionType<R, UnboundArgs>;
 
-  BindState(const Runnable& runnable, const BoundArgs&... bound_args)
+  template <typename... PassedBoundArgs>
+  BindState(const Runnable& runnable, PassedBoundArgs&&... bound_args)
       : BindStateBase(&Destroy),
         runnable_(runnable),
         ref_(bound_args...),
-        bound_args_(bound_args...) {}
+        bound_args_(std::forward<PassedBoundArgs>(bound_args)...) {}
 
   RunnableType runnable_;
   MaybeScopedRefPtr<HasIsMethodTag<Runnable>::value, BoundArgs...> ref_;
-  Tuple<BoundArgs...> bound_args_;
+  std::tuple<BoundArgs...> bound_args_;
 
  private:
   ~BindState() {}
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_