base::Bind: Make use of partial currying to get rid of a helper class.

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 111 matching lines @@
 // The design Callback and Bind is heavily influenced by C++'s
 // tr1::function/tr1::bind, and by the "Google Callback" system used inside
 // Google.
 //
 //
 // HOW THE IMPLEMENTATION WORKS:
 //
 // There are three main components to the system:
 //   1) The Callback classes.
 //   2) The Bind() functions.
-//   3) The arguments wrappers (eg., Unretained() and ConstRef()).
+//   3) The arguments wrappers (e.g., Unretained() and ConstRef()).
 //
 // The Callback classes represent a generic function pointer. Internally,
 // it stores a refcounted piece of state that represents the target function
 // and all its bound parameters.  Each Callback specialization has a templated
 // constructor that takes an BindStateHolder<> object.  In the context of
 // the constructor, the static type of this BindStateHolder<> object
 // uniquely identifies the function it is representing, all its bound
 // parameters, and a DoInvoke() that is capable of invoking the target.
 //
 // Callback's constructor is takes the BindStateHolder<> that has the
@@ skipping 15 matching lines @@
 //    refcounting semantics for the target object if we are binding a class
 //    method.
 //
 // The Bind functions do the above using type-inference, and template
 // specializations.
 //
 // By default Bind() will store copies of all bound parameters, and attempt
 // to refcount a target object if the function being bound is a class method.
 //
 // To change this behavior, we introduce a set of argument wrappers
-// (eg. Unretained(), and ConstRef()).  These are simple container templates
+// (e.g., Unretained(), and ConstRef()).  These are simple container templates
 // that are passed by value, and wrap a pointer to argument.  See the
 // file-level comment in base/bind_helpers.h for more info.
 //
 // These types are passed to the Unwrap() functions, and the MaybeRefcount()
 // functions respectively to modify the behavior of Bind().  The Unwrap()
 // and MaybeRefcount() functions change behavior by doing partial
 // specialization based on whether or not a parameter is a wrapper type.
 //
 // ConstRef() is similar to tr1::cref.  Unretained() is specific to Chromium.
 //
@@ skipping 16 matching lines @@
 // tr1::function causes a copy to be made of all the bound parameters and
 // state.
 //
 // Furthermore, in Chromium, it is desirable for the Callback to take a
 // reference on a target object when representing a class method call.  This
 // is not supported by tr1.
 //
 // Lastly, tr1::function and tr1::bind has a more general and flexible API.
 // This includes things like argument reordering by use of
 // tr1::bind::placeholder, support for non-const reference parameters, and some
-// limited amount of subtyping of the tr1::function object (eg.,
+// limited amount of subtyping of the tr1::function object (e.g.,
 // tr1::function<int(int)> is convertible to tr1::function<void(int)>).
 //
 // These are not features that are required in Chromium. Some of them, such as
 // allowing for reference parameters, and subtyping of functions, may actually
 // become a source of errors. Removing support for these features actually
 // allows for a simpler implementation, and a terser Currying API.
 //
 //
 // WHY NOT GOOGLE CALLBACKS?
 //
@@ skipping 89 matching lines @@
 
 ]]  $$ 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