Redo r113722 - Add Pass(), which implements move semantics, to scoped_ptr, scoped_array....

base/bind_internal.h

 // This file was GENERATED by command:
 //     pump.py bind_internal.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 // 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_
@@ skipping 58 matching lines @@
 //                    and for ignoring return values.  This is separate from
 //                    Invoker to avoid creating multiple version of Invoker<>
 //                    which grows at O(n^2) with the arity.
 //                    There are |k*ARITY| InvokeHelper types.
 //  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
 //               There are |(ARITY^2 + ARITY)/2| Invoketypes.
 //  BindState<> -- Stores the curried parameters, and is the main entry point
 //                 into the Bind() system, doing most of the type resolution.
 //                 There are ARITY BindState types.
 
-
 // RunnableAdapter<>
 //
 // The RunnableAdapter<> templates provide a uniform interface for invoking
 // a function pointer, method pointer, or const method pointer. The adapter
 // exposes a Run() method with an appropriate signature. Using this wrapper
 // allows for writing code that supports all three pointer types without
 // undue repetition.  Without it, a lot of code would need to be repeated 3
 // times.
 //
 // For method pointers and const method pointers the first argument to Run()
@@ skipping 70 matching lines @@
 template <typename R, typename A1>
 class RunnableAdapter<R(*)(A1)> {
  public:
   typedef R (RunType)(A1);
 
   explicit RunnableAdapter(R(*function)(A1))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
-    return function_(a1);
+    return function_(CallbackForward(a1));
   }
 
  private:
   R (*function_)(A1);
 };
 
 // Method: Arity 1.
 template <typename R, typename T, typename A1>
 class RunnableAdapter<R(T::*)(A1)> {
  public:
   typedef R (RunType)(T*, A1);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
-    return (object->*method_)(a1);
+    return (object->*method_)(CallbackForward(a1));
   }
 
  private:
   R (T::*method_)(A1);
 };
 
 // Const Method: Arity 1.
 template <typename R, typename T, typename A1>
 class RunnableAdapter<R(T::*)(A1) const> {
  public:
   typedef R (RunType)(const T*, A1);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1) {
-    return (object->*method_)(a1);
+    return (object->*method_)(CallbackForward(a1));
   }
 
  private:
   R (T::*method_)(A1) const;
 };
 
 // Function: Arity 2.
 template <typename R, typename A1, typename A2>
 class RunnableAdapter<R(*)(A1, A2)> {
  public:
   typedef R (RunType)(A1, A2);
 
   explicit RunnableAdapter(R(*function)(A1, A2))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2) {
-    return function_(a1, a2);
+    return function_(CallbackForward(a1), CallbackForward(a2));
   }
 
  private:
   R (*function_)(A1, A2);
 };
 
 // Method: Arity 2.
 template <typename R, typename T, typename A1, typename A2>
 class RunnableAdapter<R(T::*)(A1, A2)> {
  public:
   typedef R (RunType)(T*, A1, A2);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2) {
-    return (object->*method_)(a1, a2);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
   }
 
  private:
   R (T::*method_)(A1, A2);
 };
 
 // Const Method: Arity 2.
 template <typename R, typename T, typename A1, typename A2>
 class RunnableAdapter<R(T::*)(A1, A2) const> {
  public:
   typedef R (RunType)(const T*, A1, A2);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2) {
-    return (object->*method_)(a1, a2);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2));
   }
 
  private:
   R (T::*method_)(A1, A2) const;
 };
 
 // Function: Arity 3.
 template <typename R, typename A1, typename A2, typename A3>
 class RunnableAdapter<R(*)(A1, A2, A3)> {
  public:
   typedef R (RunType)(A1, A2, A3);
 
   explicit RunnableAdapter(R(*function)(A1, A2, A3))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3) {
-    return function_(a1, a2, a3);
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
   }
 
  private:
   R (*function_)(A1, A2, A3);
 };
 
 // Method: Arity 3.
 template <typename R, typename T, typename A1, typename A2, typename A3>
 class RunnableAdapter<R(T::*)(A1, A2, A3)> {
  public:
   typedef R (RunType)(T*, A1, A2, A3);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3) {
-    return (object->*method_)(a1, a2, a3);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
   }
 
  private:
   R (T::*method_)(A1, A2, A3);
 };
 
 // Const Method: Arity 3.
 template <typename R, typename T, typename A1, typename A2, typename A3>
 class RunnableAdapter<R(T::*)(A1, A2, A3) const> {
  public:
   typedef R (RunType)(const T*, A1, A2, A3);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3) {
-    return (object->*method_)(a1, a2, a3);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
   }
 
  private:
   R (T::*method_)(A1, A2, A3) const;
 };
 
 // Function: Arity 4.
 template <typename R, typename A1, typename A2, typename A3, typename A4>
 class RunnableAdapter<R(*)(A1, A2, A3, A4)> {
  public:
   typedef R (RunType)(A1, A2, A3, A4);
 
   explicit RunnableAdapter(R(*function)(A1, A2, A3, A4))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4) {
-    return function_(a1, a2, a3, a4);
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
   }
 
  private:
   R (*function_)(A1, A2, A3, A4);
 };
 
 // Method: Arity 4.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4)> {
  public:
   typedef R (RunType)(T*, A1, A2, A3, A4);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4) {
-    return (object->*method_)(a1, a2, a3, a4);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4);
 };
 
 // Const Method: Arity 4.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4) const> {
  public:
   typedef R (RunType)(const T*, A1, A2, A3, A4);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4) {
-    return (object->*method_)(a1, a2, a3, a4);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4) const;
 };
 
 // Function: Arity 5.
 template <typename R, typename A1, typename A2, typename A3, typename A4,
     typename A5>
 class RunnableAdapter<R(*)(A1, A2, A3, A4, A5)> {
  public:
   typedef R (RunType)(A1, A2, A3, A4, A5);
 
   explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5) {
-    return function_(a1, a2, a3, a4, a5);
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
   }
 
  private:
   R (*function_)(A1, A2, A3, A4, A5);
 };
 
 // Method: Arity 5.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4, typename A5>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5)> {
  public:
   typedef R (RunType)(T*, A1, A2, A3, A4, A5);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5) {
-    return (object->*method_)(a1, a2, a3, a4, a5);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4, A5);
 };
 
 // Const Method: Arity 5.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4, typename A5>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5) const> {
  public:
   typedef R (RunType)(const T*, A1, A2, A3, A4, A5);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5) {
-    return (object->*method_)(a1, a2, a3, a4, a5);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4, A5) const;
 };
 
 // Function: Arity 6.
 template <typename R, typename A1, typename A2, typename A3, typename A4,
     typename A5, typename A6>
 class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6)> {
  public:
   typedef R (RunType)(A1, A2, A3, A4, A5, A6);
 
   explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5,
       typename CallbackParamTraits<A6>::ForwardType a6) {
-    return function_(a1, a2, a3, a4, a5, a6);
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
   }
 
  private:
   R (*function_)(A1, A2, A3, A4, A5, A6);
 };
 
 // Method: Arity 6.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6)> {
  public:
   typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5,
       typename CallbackParamTraits<A6>::ForwardType a6) {
-    return (object->*method_)(a1, a2, a3, a4, a5, a6);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4, A5, A6);
 };
 
 // Const Method: Arity 6.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6) const> {
  public:
   typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5,
       typename CallbackParamTraits<A6>::ForwardType a6) {
-    return (object->*method_)(a1, a2, a3, a4, a5, a6);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4, A5, A6) const;
 };
 
 // Function: Arity 7.
 template <typename R, typename A1, typename A2, typename A3, typename A4,
     typename A5, typename A6, typename A7>
 class RunnableAdapter<R(*)(A1, A2, A3, A4, A5, A6, A7)> {
  public:
   typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7);
 
   explicit RunnableAdapter(R(*function)(A1, A2, A3, A4, A5, A6, A7))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5,
       typename CallbackParamTraits<A6>::ForwardType a6,
       typename CallbackParamTraits<A7>::ForwardType a7) {
-    return function_(a1, a2, a3, a4, a5, a6, a7);
+    return function_(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
   }
 
  private:
   R (*function_)(A1, A2, A3, A4, A5, A6, A7);
 };
 
 // Method: Arity 7.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6, typename A7>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7)> {
  public:
   typedef R (RunType)(T*, A1, A2, A3, A4, A5, A6, A7);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5,
       typename CallbackParamTraits<A6>::ForwardType a6,
       typename CallbackParamTraits<A7>::ForwardType a7) {
-    return (object->*method_)(a1, a2, a3, a4, a5, a6, a7);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4, A5, A6, A7);
 };
 
 // Const Method: Arity 7.
 template <typename R, typename T, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6, typename A7>
 class RunnableAdapter<R(T::*)(A1, A2, A3, A4, A5, A6, A7) const> {
  public:
   typedef R (RunType)(const T*, A1, A2, A3, A4, A5, A6, A7);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)(A1, A2, A3, A4, A5, A6, A7) const)
       : method_(method) {
   }
 
   R Run(const T* object, typename CallbackParamTraits<A1>::ForwardType a1,
       typename CallbackParamTraits<A2>::ForwardType a2,
       typename CallbackParamTraits<A3>::ForwardType a3,
       typename CallbackParamTraits<A4>::ForwardType a4,
       typename CallbackParamTraits<A5>::ForwardType a5,
       typename CallbackParamTraits<A6>::ForwardType a6,
       typename CallbackParamTraits<A7>::ForwardType a7) {
-    return (object->*method_)(a1, a2, a3, a4, a5, a6, a7);
+    return (object->*method_)(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
   }
 
  private:
   R (T::*method_)(A1, A2, A3, A4, A5, A6, A7) const;
 };
 
 
 // FunctionTraits<>
 //
 // Breaks a function signature apart into typedefs for easier introspection.
@@ skipping 201 matching lines @@
     void()>  {
   static void MakeItSo(Runnable runnable) {
     runnable.Run();
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1) {
-    return runnable.Run(a1);
+    return runnable.Run(CallbackForward(a1));
   }
 };
 
 template <typename Runnable,typename A1>
 struct InvokeHelper<false, void, Runnable,
     void(A1)>  {
   static void MakeItSo(Runnable runnable, A1 a1) {
-    runnable.Run(a1);
+    runnable.Run(CallbackForward(a1));
   }
 };
 
 template <typename Runnable, typename A1>
 struct InvokeHelper<true, void, Runnable,
     void(A1)>  {
   static void MakeItSo(Runnable runnable, A1 a1) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1);
+    runnable.Run(CallbackForward(a1));
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1, typename A2>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1, A2)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2) {
-    return runnable.Run(a1, a2);
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2));
   }
 };
 
 template <typename Runnable,typename A1, typename A2>
 struct InvokeHelper<false, void, Runnable,
     void(A1, A2)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2) {
-    runnable.Run(a1, a2);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2));
   }
 };
 
 template <typename Runnable, typename A1, typename A2>
 struct InvokeHelper<true, void, Runnable,
     void(A1, A2)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1, a2);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2));
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1, typename A2,
     typename A3>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1, A2, A3)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
-    return runnable.Run(a1, a2, a3);
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3));
   }
 };
 
 template <typename Runnable,typename A1, typename A2, typename A3>
 struct InvokeHelper<false, void, Runnable,
     void(A1, A2, A3)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
-    runnable.Run(a1, a2, a3);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
   }
 };
 
 template <typename Runnable, typename A1, typename A2, typename A3>
 struct InvokeHelper<true, void, Runnable,
     void(A1, A2, A3)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1, a2, a3);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3));
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1, typename A2,
     typename A3, typename A4>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1, A2, A3, A4)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
-    return runnable.Run(a1, a2, a3, a4);
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4));
   }
 };
 
 template <typename Runnable,typename A1, typename A2, typename A3, typename A4>
 struct InvokeHelper<false, void, Runnable,
     void(A1, A2, A3, A4)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
-    runnable.Run(a1, a2, a3, a4);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4));
   }
 };
 
 template <typename Runnable, typename A1, typename A2, typename A3, typename A4>
 struct InvokeHelper<true, void, Runnable,
     void(A1, A2, A3, A4)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1, a2, a3, a4);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4));
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1, typename A2,
     typename A3, typename A4, typename A5>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1, A2, A3, A4, A5)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
       A5 a5) {
-    return runnable.Run(a1, a2, a3, a4, a5);
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5));
   }
 };
 
 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
     typename A5>
 struct InvokeHelper<false, void, Runnable,
     void(A1, A2, A3, A4, A5)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    runnable.Run(a1, a2, a3, a4, a5);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5));
   }
 };
 
 template <typename Runnable, typename A1, typename A2, typename A3,
     typename A4, typename A5>
 struct InvokeHelper<true, void, Runnable,
     void(A1, A2, A3, A4, A5)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1, a2, a3, a4, a5);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5));
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1, typename A2,
     typename A3, typename A4, typename A5, typename A6>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1, A2, A3, A4, A5, A6)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
       A5 a5, A6 a6) {
-    return runnable.Run(a1, a2, a3, a4, a5, a6);
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6));
   }
 };
 
 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
     typename A5, typename A6>
 struct InvokeHelper<false, void, Runnable,
     void(A1, A2, A3, A4, A5, A6)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
       A6 a6) {
-    runnable.Run(a1, a2, a3, a4, a5, a6);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
   }
 };
 
 template <typename Runnable, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6>
 struct InvokeHelper<true, void, Runnable,
     void(A1, A2, A3, A4, A5, A6)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
       A6 a6) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1, a2, a3, a4, a5, a6);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6));
   }
 };
 
 template <typename ReturnType, typename Runnable,typename A1, typename A2,
     typename A3, typename A4, typename A5, typename A6, typename A7>
 struct InvokeHelper<false, ReturnType, Runnable,
     void(A1, A2, A3, A4, A5, A6, A7)>  {
   static ReturnType MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4,
       A5 a5, A6 a6, A7 a7) {
-    return runnable.Run(a1, a2, a3, a4, a5, a6, a7);
+    return runnable.Run(CallbackForward(a1), CallbackForward(a2),
+        CallbackForward(a3), CallbackForward(a4), CallbackForward(a5),
+        CallbackForward(a6), CallbackForward(a7));
   }
 };
 
 template <typename Runnable,typename A1, typename A2, typename A3, typename A4,
     typename A5, typename A6, typename A7>
 struct InvokeHelper<false, void, Runnable,
     void(A1, A2, A3, A4, A5, A6, A7)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
       A6 a6, A7 a7) {
-    runnable.Run(a1, a2, a3, a4, a5, a6, a7);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
+        CallbackForward(a7));
   }
 };
 
 template <typename Runnable, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6, typename A7>
 struct InvokeHelper<true, void, Runnable,
     void(A1, A2, A3, A4, A5, A6, A7)>  {
   static void MakeItSo(Runnable runnable, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
       A6 a6, A7 a7) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run(a1, a2, a3, a4, a5, a6, a7);
+    runnable.Run(CallbackForward(a1), CallbackForward(a2), CallbackForward(a3),
+        CallbackForward(a4), CallbackForward(a5), CallbackForward(a6),
+        CallbackForward(a7));
   }
 };
 
 #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 42 matching lines @@
       typename CallbackParamTraits<X1>::ForwardType x1) {
     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 InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1)>
-               ::MakeItSo(storage->runnable_, x1);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1));
   }
 };
 
 // Arity 1 -> 0.
 template <typename StorageType, typename R,typename X1>
 struct Invoker<1, StorageType, R(X1)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
 
   static R Run(BindStateBase* base) {
     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.
     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1));
   }
 };
 
 // Arity 2 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2>
 struct Invoker<0, StorageType, R(X1, X2)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X1>::ForwardType,
       typename CallbackParamTraits<X2>::ForwardType);
 
   typedef R(UnboundRunType)(X1, X2);
 
   static R Run(BindStateBase* base,
       typename CallbackParamTraits<X1>::ForwardType x1,
       typename CallbackParamTraits<X2>::ForwardType x2) {
     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 InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1,
                typename CallbackParamTraits<X2>::ForwardType x2)>
-               ::MakeItSo(storage->runnable_, x1, x2);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
   }
 };
 
 // Arity 2 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2>
 struct Invoker<1, StorageType, R(X1, X2)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X2>::ForwardType);
 
   typedef R(UnboundRunType)(X2);
 
   static R Run(BindStateBase* base,
       typename CallbackParamTraits<X2>::ForwardType x2) {
     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.
     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X2>::ForwardType x2)>
-               ::MakeItSo(storage->runnable_, x1, x2);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
   }
 };
 
 // Arity 2 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2>
 struct Invoker<2, StorageType, R(X1, X2)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
 
   static R Run(BindStateBase* base) {
     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.
     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
     typedef typename StorageType::Bound2UnwrapTraits Bound2UnwrapTraits;
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1, x2);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2));
   }
 };
 
 // Arity 3 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
 struct Invoker<0, StorageType, R(X1, X2, X3)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X1>::ForwardType,
       typename CallbackParamTraits<X2>::ForwardType,
       typename CallbackParamTraits<X3>::ForwardType);
 
   typedef R(UnboundRunType)(X1, X2, X3);
 
   static R Run(BindStateBase* base,
       typename CallbackParamTraits<X1>::ForwardType x1,
       typename CallbackParamTraits<X2>::ForwardType x2,
       typename CallbackParamTraits<X3>::ForwardType x3) {
     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 InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
   }
 };
 
 // Arity 3 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
 struct Invoker<1, StorageType, R(X1, X2, X3)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X2>::ForwardType,
       typename CallbackParamTraits<X3>::ForwardType);
@@ skipping 10 matching lines @@
     // InvokeHelper<>::MakeItSo() call below.
     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
   }
 };
 
 // Arity 3 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
 struct Invoker<2, StorageType, R(X1, X2, X3)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X3>::ForwardType);
 
@@ skipping 11 matching lines @@
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X3>::ForwardType x3)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
   }
 };
 
 // Arity 3 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
 struct Invoker<3, StorageType, R(X1, X2, X3)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
@@ skipping 12 matching lines @@
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     typename Bound3UnwrapTraits::ForwardType x3 =
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3));
   }
 };
 
 // Arity 4 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
 struct Invoker<0, StorageType, R(X1, X2, X3, X4)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X1>::ForwardType,
       typename CallbackParamTraits<X2>::ForwardType,
@@ skipping 12 matching lines @@
     // 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 InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
   }
 };
 
 // Arity 4 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
 struct Invoker<1, StorageType, R(X1, X2, X3, X4)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X2>::ForwardType,
       typename CallbackParamTraits<X3>::ForwardType,
@@ skipping 13 matching lines @@
     typedef typename StorageType::Bound1UnwrapTraits Bound1UnwrapTraits;
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
   }
 };
 
 // Arity 4 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
 struct Invoker<2, StorageType, R(X1, X2, X3, X4)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X3>::ForwardType,
       typename CallbackParamTraits<X4>::ForwardType);
@@ skipping 14 matching lines @@
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
   }
 };
 
 // Arity 4 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
 struct Invoker<3, StorageType, R(X1, X2, X3, X4)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X4>::ForwardType);
 
@@ skipping 15 matching lines @@
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     typename Bound3UnwrapTraits::ForwardType x3 =
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X4>::ForwardType x4)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
   }
 };
 
 // Arity 4 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
 struct Invoker<4, StorageType, R(X1, X2, X3, X4)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
@@ skipping 16 matching lines @@
     typename Bound3UnwrapTraits::ForwardType x3 =
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     typename Bound4UnwrapTraits::ForwardType x4 =
         Bound4UnwrapTraits::Unwrap(storage->p4_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4));
   }
 };
 
 // Arity 5 -> 5.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
 struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X1>::ForwardType,
       typename CallbackParamTraits<X2>::ForwardType,
@@ skipping 15 matching lines @@
     // you really want to warp ahead and step through the
     // InvokeHelper<>::MakeItSo() call below.
 
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
   }
 };
 
 // Arity 5 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
 struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X2>::ForwardType,
       typename CallbackParamTraits<X3>::ForwardType,
@@ skipping 16 matching lines @@
 
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
   }
 };
 
 // Arity 5 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
 struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X3>::ForwardType,
       typename CallbackParamTraits<X4>::ForwardType,
@@ skipping 17 matching lines @@
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
   }
 };
 
 // Arity 5 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
 struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X4>::ForwardType,
       typename CallbackParamTraits<X5>::ForwardType);
@@ skipping 18 matching lines @@
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     typename Bound3UnwrapTraits::ForwardType x3 =
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
   }
 };
 
 // Arity 5 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
 struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X5>::ForwardType);
 
@@ skipping 19 matching lines @@
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     typename Bound4UnwrapTraits::ForwardType x4 =
         Bound4UnwrapTraits::Unwrap(storage->p4_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X5>::ForwardType x5)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
   }
 };
 
 // Arity 5 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
 struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
@@ skipping 20 matching lines @@
         Bound4UnwrapTraits::Unwrap(storage->p4_);
     typename Bound5UnwrapTraits::ForwardType x5 =
         Bound5UnwrapTraits::Unwrap(storage->p5_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename Bound5UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5));
   }
 };
 
 // Arity 6 -> 6.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X1>::ForwardType,
       typename CallbackParamTraits<X2>::ForwardType,
@@ skipping 18 matching lines @@
     // InvokeHelper<>::MakeItSo() call below.
 
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 6 -> 5.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X2>::ForwardType,
       typename CallbackParamTraits<X3>::ForwardType,
@@ skipping 19 matching lines @@
     typename Bound1UnwrapTraits::ForwardType x1 =
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 6 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X3>::ForwardType,
       typename CallbackParamTraits<X4>::ForwardType,
@@ skipping 20 matching lines @@
     typename Bound2UnwrapTraits::ForwardType x2 =
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 6 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X4>::ForwardType,
       typename CallbackParamTraits<X5>::ForwardType,
@@ skipping 21 matching lines @@
     typename Bound3UnwrapTraits::ForwardType x3 =
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 6 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X5>::ForwardType,
       typename CallbackParamTraits<X6>::ForwardType);
@@ skipping 22 matching lines @@
     typename Bound4UnwrapTraits::ForwardType x4 =
         Bound4UnwrapTraits::Unwrap(storage->p4_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 6 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X6>::ForwardType);
 
@@ skipping 23 matching lines @@
     typename Bound5UnwrapTraits::ForwardType x5 =
         Bound5UnwrapTraits::Unwrap(storage->p5_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename Bound5UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X6>::ForwardType x6)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 6 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
 struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
@@ skipping 24 matching lines @@
     typename Bound6UnwrapTraits::ForwardType x6 =
         Bound6UnwrapTraits::Unwrap(storage->p6_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename Bound5UnwrapTraits::ForwardType,
                typename Bound6UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6));
   }
 };
 
 // Arity 7 -> 7.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<0, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X1>::ForwardType,
       typename CallbackParamTraits<X2>::ForwardType,
@@ skipping 21 matching lines @@
 
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename CallbackParamTraits<X1>::ForwardType x1,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 6.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<1, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X2>::ForwardType,
       typename CallbackParamTraits<X3>::ForwardType,
@@ skipping 22 matching lines @@
         Bound1UnwrapTraits::Unwrap(storage->p1_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X2>::ForwardType x2,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 5.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<2, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X3>::ForwardType,
       typename CallbackParamTraits<X4>::ForwardType,
@@ skipping 23 matching lines @@
         Bound2UnwrapTraits::Unwrap(storage->p2_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X3>::ForwardType x3,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<3, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X4>::ForwardType,
       typename CallbackParamTraits<X5>::ForwardType,
@@ skipping 24 matching lines @@
         Bound3UnwrapTraits::Unwrap(storage->p3_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X4>::ForwardType x4,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<4, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X5>::ForwardType,
       typename CallbackParamTraits<X6>::ForwardType,
@@ skipping 25 matching lines @@
         Bound4UnwrapTraits::Unwrap(storage->p4_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X5>::ForwardType x5,
                typename CallbackParamTraits<X6>::ForwardType x6,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<5, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X6>::ForwardType,
       typename CallbackParamTraits<X7>::ForwardType);
@@ skipping 26 matching lines @@
         Bound5UnwrapTraits::Unwrap(storage->p5_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename Bound5UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X6>::ForwardType x6,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<6, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*,
       typename CallbackParamTraits<X7>::ForwardType);
 
@@ skipping 27 matching lines @@
         Bound6UnwrapTraits::Unwrap(storage->p6_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename Bound5UnwrapTraits::ForwardType,
                typename Bound6UnwrapTraits::ForwardType,
                typename CallbackParamTraits<X7>::ForwardType x7)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 // Arity 7 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6, typename X7>
 struct Invoker<7, StorageType, R(X1, X2, X3, X4, X5, X6, X7)> {
   typedef R(RunType)(BindStateBase*);
 
   typedef R(UnboundRunType)();
@@ skipping 28 matching lines @@
         Bound7UnwrapTraits::Unwrap(storage->p7_);
     return InvokeHelper<StorageType::IsWeakCall::value, R,
            typename StorageType::RunnableType,
            void(typename Bound1UnwrapTraits::ForwardType,
                typename Bound2UnwrapTraits::ForwardType,
                typename Bound3UnwrapTraits::ForwardType,
                typename Bound4UnwrapTraits::ForwardType,
                typename Bound5UnwrapTraits::ForwardType,
                typename Bound6UnwrapTraits::ForwardType,
                typename Bound7UnwrapTraits::ForwardType)>
-               ::MakeItSo(storage->runnable_, x1, x2, x3, x4, x5, x6, x7);
+               ::MakeItSo(storage->runnable_, CallbackForward(x1),
+                   CallbackForward(x2), CallbackForward(x3),
+                   CallbackForward(x4), CallbackForward(x5),
+                   CallbackForward(x6), CallbackForward(x7));
   }
 };
 
 
 // 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.
@@ skipping 255 matching lines @@
   P4 p4_;
   P5 p5_;
   P6 p6_;
   P7 p7_;
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_