Add Pass(), which implements move semantics, to scoped_ptr, scoped_array, and scoped_ptr_malloc.

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_(BindMoveSupport(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_)(BindMoveSupport(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_)(BindMoveSupport(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_(BindMoveSupport(a1), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(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_(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(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_(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(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_(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(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_(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(a5),
+        BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(a5),
+        BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(a5),
+        BindMoveSupport(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_(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(a5),
+        BindMoveSupport(a6), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(a5),
+        BindMoveSupport(a6), BindMoveSupport(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_)(BindMoveSupport(a1), BindMoveSupport(a2),
+        BindMoveSupport(a3), BindMoveSupport(a4), BindMoveSupport(a5),
+        BindMoveSupport(a6), BindMoveSupport(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 2041 matching lines @@
   P4 p4_;
   P5 p5_;
   P6 p6_;
   P7 p7_;
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_