Make Callback::Reset() return a copy to support use-cases where Run() ends up modifying |*this|.

base/callback.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
 
@@ skipping 26 matching lines @@
 //
 // MEMORY MANAGEMENT AND PASSING
 //
 // The Callback objects themselves should be passed by const-reference, and
 // stored by copy. They internally store their state via a refcounted class
 // and thus do not need to be deleted.
 //
 // The reason to pass via a const-reference is to avoid unnecessary
 // AddRef/Release pairs to the internal state.
 //
+// If a Callback variable must be empty during the Run() of a previous value of

[akalin, 2012/03/19 21:53:20]

I couldn't parse this comment.  Maybe something like:

// ResetAndRun() is like Run(), but the callback variable is reset before it's
run.  This is handy if Run() reads/writes the callback variable.

?

+// that variable, use ResetAndRun().  E.g. if MyClass has a member variable
+// Callback which gets set as a side-effect of Run()'ing the Callback (to
+// something else), ResetAndRun() can be handy.
 //
 // EXAMPLE USAGE:
 //
 // /* Binding a normal function. */
 // int Return5() { return 5; }
 // base::Callback<int(void)> func_cb = base::Bind(&Return5);
 // LOG(INFO) << func_cb.Run();  // Prints 5.
 //
 // void PrintHi() { LOG(INFO) << "hi."; }
 // base::Closure void_func_cb = base::Bind(&PrintHi);
@@ skipping 228 matching lines @@
         [[typename internal::CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) const {
     PolymorphicInvoke f =
         reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
 
     return f(bind_state_.get()[[]]
 $if ARITY != 0 [[, ]]
 $for ARG ,
              [[internal::CallbackForward(a$(ARG))]]);
   }
 
+

[akalin, 2012/03/19 21:53:20]

remove extra space

+  R ResetAndRun($for ARG ,
+        [[typename internal::CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]]) {
+    Callback<RunType> tmp(*this);
+    Reset();
+    tmp.Run(
+$for ARG ,
+            [[internal::CallbackForward(a$(ARG))]]);
+  }
+
  private:
   typedef R(*PolymorphicInvoke)(
       internal::BindStateBase*[[]]
 $if ARITY != 0 [[, ]]
 $for ARG , [[typename internal::CallbackParamTraits<A$(ARG)>::ForwardType]]);
 
 };
 
 
 ]]  $$ for ARITY
 
 // Syntactic sugar to make Callbacks<void(void)> easier to declare since it
 // will be used in a lot of APIs with delayed execution.
 typedef Callback<void(void)> Closure;
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H