Convert the rest of the functions in core.cc to use CreateFunctionTemplate.

gin/function_template.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 = 3
+$var MAX_ARITY = 4
 
 // Copyright 2013 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.
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/public/gin_embedders.h"
@@ skipping 22 matching lines @@
 // CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to 
 // DispatchToCallback, where it is invoked.
 //
 // v8::FunctionTemplate only supports passing void* as data so how do we know
 // when to delete the base::Callback? That's where CallbackHolderBase comes in.
 // It inherits from Wrappable, which delete itself when both (a) the refcount
 // via base::RefCounted has dropped to zero, and (b) there are no more
 // JavaScript references in V8.
 class CallbackHolderBase : public Wrappable {
  public:
-  static void EnsureRegistered(PerIsolateData* isolate_data);
   virtual WrapperInfo* GetWrapperInfo() OVERRIDE;
   static WrapperInfo kWrapperInfo;
  protected:
   virtual ~CallbackHolderBase() {}
 };
 
 template<typename Sig>
 class CallbackHolder : public CallbackHolderBase {
  public:
   CallbackHolder(const base::Callback<Sig>& callback)
@@ skipping 78 matching lines @@
 ]]
 
   Invoker<R$for ARG [[, P$(ARG)]]>::Go(&args, holder->callback$for ARG [[, a$(ARG)]]);
 }
 
 ]]
 
 }  // namespace internal
 
 
+// This should be called once per-isolate to initialize the function template
+// system.
+void InitFunctionTemplates(PerIsolateData* isolate_data);
+
+
 // This has to be outside the internal namespace because template
 // specializations must be declared in the same namespace as the original
 // template.
 template<>
 struct Converter<internal::CallbackHolderBase*>
     : public WrappableConverter<internal::CallbackHolderBase> {};
 
 
 // Creates a v8::FunctionTemplate that will run the provided base::Callback each
 // time it is called. JavaScript arguments and return values are converted via
 // gin::Converter.
 $range ARITY 0..MAX_ARITY
 $for ARITY [[
 $range ARG 1..ARITY
 
 template<typename R$for ARG [[, typename P$(ARG)]]>
 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
     v8::Isolate* isolate,
     const base::Callback<R($for ARG , [[P$(ARG)]])> callback) {
   typedef internal::CallbackHolder<R($for ARG , [[P$(ARG)]])> HolderT;
   scoped_refptr<HolderT> holder(new HolderT(callback));
   return v8::FunctionTemplate::New(
       &internal::DispatchToCallback<R$for ARG [[, P$(ARG)]]>,
       ConvertToV8<internal::CallbackHolderBase*>(isolate, holder.get()));
 }
 
 ]]
 
 }  // namespace gin