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

base/bind_internal.h.pump

 $$ This is a pump file for generating file templates.  Pump is a python
 $$ script that is part of the Google Test suite of utilities.  Description
 $$ can be found here:
 $$
 $$ http://code.google.com/p/googletest/wiki/PumpManual
 $$
 
 $$ See comment for MAX_ARITY in base/bind.h.pump.
 $var MAX_ARITY = 7
 $range ARITY 0..MAX_ARITY
@@ skipping 64 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 18 matching lines @@
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 class RunnableAdapter<R(*)($for ARG , [[A$(ARG)]])> {
  public:
   typedef R (RunType)($for ARG , [[A$(ARG)]]);
 
   explicit RunnableAdapter(R(*function)($for ARG , [[A$(ARG)]]))
       : function_(function) {
   }
 
   R Run($for ARG , [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
-    return function_($for ARG , [[a$(ARG)]]);
+    return function_($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 
  private:
   R (*function_)($for ARG , [[A$(ARG)]]);
 };
 
 // Method: Arity $(ARITY).
 template <typename R, typename T[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 class RunnableAdapter<R(T::*)($for ARG , [[A$(ARG)]])> {
  public:
   typedef R (RunType)(T*[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG)]]);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)($for ARG , [[A$(ARG)]]))
       : method_(method) {
   }
 
   R Run(T* object[[]]
 $if ARITY > 0[[, ]]  $for ARG, [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
-    return (object->*method_)($for ARG , [[a$(ARG)]]);
+    return (object->*method_)($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 
  private:
   R (T::*method_)($for ARG , [[A$(ARG)]]);
 };
 
 // Const Method: Arity $(ARITY).
 template <typename R, typename T[[]]
 $if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
 class RunnableAdapter<R(T::*)($for ARG , [[A$(ARG)]]) const> {
  public:
   typedef R (RunType)(const T*[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG)]]);
   typedef true_type IsMethod;
 
   explicit RunnableAdapter(R(T::*method)($for ARG , [[A$(ARG)]]) const)
       : method_(method) {
   }
 
   R Run(const T* object[[]]
 $if ARITY > 0[[, ]]  $for ARG, [[typename CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
-    return (object->*method_)($for ARG , [[a$(ARG)]]);
+    return (object->*method_)($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 
  private:
   R (T::*method_)($for ARG , [[A$(ARG)]]) const;
 };
 
 ]]  $$ for ARITY
 
 
 // FunctionTraits<>
@@ skipping 105 matching lines @@
 
 $for ARITY [[
 $range ARG 1..ARITY
 
 template <typename ReturnType, typename Runnable[[]]
 $if ARITY > 0 [[,]] $for ARG , [[typename A$(ARG)]]>
 struct InvokeHelper<false, ReturnType, Runnable,
     void($for ARG , [[A$(ARG)]])>  {
   static ReturnType MakeItSo(Runnable runnable[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
-    return runnable.Run($for ARG , [[a$(ARG)]]);
+    return runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 };
 
 template <typename Runnable[[]]
 $if ARITY > 0 [[,]] $for ARG , [[typename A$(ARG)]]>
 struct InvokeHelper<false, void, Runnable,
     void($for ARG , [[A$(ARG)]])>  {
   static void MakeItSo(Runnable runnable[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
-    runnable.Run($for ARG , [[a$(ARG)]]);
+    runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 };
 
 $if ARITY > 0 [[
 
 template <typename Runnable[[]], $for ARG , [[typename A$(ARG)]]>
 struct InvokeHelper<true, void, Runnable,
     void($for ARG , [[A$(ARG)]])>  {
   static void MakeItSo(Runnable runnable[[]]
 $if ARITY > 0[[, ]] $for ARG , [[A$(ARG) a$(ARG)]]) {
     if (!a1.get()) {
       return;
     }
 
-    runnable.Run($for ARG , [[a$(ARG)]]);
+    runnable.Run($for ARG , [[CallbackForward(a$(ARG))]]);
   }
 };
 
 ]]
 
 ]] $$ for ARITY
 
 #if !defined(_MSC_VER)
 
 template <typename ReturnType, typename Runnable, typename ArgsType>
@@ skipping 67 matching lines @@
 typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType
 ]]
 
 $if UNBOUND > 0 [[$if BOUND > 0 [[, ]]]][[]]
 
 $for UNBOUND_ARG , [[
 typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
 ]]
 )>
                ::MakeItSo(storage->runnable_
-$if ARITY > 0[[, ]] $for ARG , [[x$(ARG)]]);
+$if ARITY > 0[[, ]] $for ARG , [[CallbackForward(x$(ARG))]]);
   }
 };
 
 ]] $$ for BOUND
 ]] $$ for ARITY
 
 
 // BindState<>
 //
 // This stores all the state passed into Bind() and is also where most
@@ skipping 68 matching lines @@
 
 ]]
 };
 
 ]] $$ for ARITY
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_