base::Bind: Increase the arity to 7.

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
 $$
 
-$var MAX_ARITY = 6
+$var MAX_ARITY = 7
 
 // 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_
 #define BASE_BIND_INTERNAL_H_
 #pragma once
 
 #include "base/bind_helpers.h"
@@ skipping 13 matching lines @@
 // The method by which a function is invoked is determined by 3 different
 // dimensions:
 //
 //   1) The type of function (normal or method).
 //   2) The arity of the function.
 //   3) The number of bound parameters.
 //
 // The templates below handle the determination of each of these dimensions.
 // In brief:
 //
-//   FunctionTraits<> -- Provides a normalied signature, and other traits.
+//   FunctionTraits<> -- Provides a normalized signature, and other traits.
 //   InvokerN<> -- Provides a DoInvoke() function that actually executes
-//                 a calback.
+//                 a callback.
 //   InvokerStorageN<> -- Provides storage for the bound parameters, and
 //                        typedefs to the above.
 //   IsWeakMethod<> -- Determines if we are binding a method to a WeakPtr<>.
 //
 // More details about the design of each class is included in a comment closer
-// to their defition.
+// to their definition.
 
 
 // IsWeakMethod determines if we are binding a method to a WeakPtr<> for an
 // object.  It is used to select an InvokerN that will no-op itself in the
 // event the WeakPtr<> for the target object is invalidated.
 template <bool IsMethod, typename T>
 struct IsWeakMethod : public false_type {};
 
 template <typename T>
 struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
 
 // FunctionTraits<>
 //
 // The FunctionTraits<> template determines the type of function, and also
 // creates a NormalizedType used to select the InvokerN classes.  It turns out
 // that syntactically, you only really have 2 variations when invoking a
-// funciton pointer: normal, and method.  One is invoked func_ptr(arg1). The
+// function pointer: normal, and method.  One is invoked func_ptr(arg1). The
 // other is invoked (*obj_->method_ptr(arg1)).
 //
 // However, in the type system, there are many more distinctions. In standard
 // C++, there's all variations of const, and volatile on the function pointer.
 // In Windows, there are additional calling conventions (eg., __stdcall,
 // __fastcall, etc.). FunctionTraits<> handles categorizing each of these into
 // a normalized signature.
 //
 // Having a NormalizedSignature signature, reduces the combinatoric
-// complexity of defintions for the InvokerN<> later.  Even though there are
+// complexity of definitions for the InvokerN<> later.  Even though there are
 // only 2 syntactic variations on invoking a function, without normalizing the
 // signature, there would need to be one specialization of InvokerN for each
 // unique (function_type, bound_arg, unbound_args) tuple in order to match all
 // function signatures.
 //
 // By normalizing the function signature, we reduce function_type to exactly 2.
 
 template <typename Sig>
 struct FunctionTraits;
 
@@ skipping 62 matching lines @@
 
 ]]  $$for ARITY
 
 // InvokerN<>
 //
 // The InvokerN templates contain a static DoInvoke() function that is the key
 // to implementing type erasure in the Callback() classes.
 //
 // DoInvoke() is a static function with a fixed signature that is independent
 // of StorageType; its first argument is a pointer to the non-templated common
-// baseclass of StorageType. This lets us store pointer to DoInvoke() in a
+// base class of StorageType. This lets us store pointer to DoInvoke() in a
 // function pointer that has knowledge of the specific StorageType, and thus
 // no knowledge of the bound function and bound parameter types.
 //
 // As long as we ensure that DoInvoke() is only used with pointers there were
-// upcasted from the correct StorageType, we can be sure that execution is
+// up-casted from the correct StorageType, we can be sure that execution is
 // safe.
 //
 // The InvokerN templates are the only point that knows the number of bound
 // and unbound arguments.  This is intentional because it allows the other
 // templates classes in the system to only have as many specializations as
 // the max arity of function we wish to support.
 
 $range BOUND 0..MAX_ARITY
 $for BOUND [[
 
@@ skipping 216 matching lines @@
 
 ]]
 };
 
 ]]  $$ for BOUND
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_