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

gin/function_template.h

 // This file was GENERATED by command:
 //     pump.py function_template.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 
 // 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.
 
@@ skipping 51 matching lines @@
 };
 
 
 // This set of templates invokes a base::Callback, converts the return type to a
 // JavaScript value, and returns that value to script via the provided
 // gin::Arguments object.
 //
 // In C++, you can declare the function foo(void), but you can't pass a void
 // expression to foo. As a result, we must specialize the case of Callbacks that
 // have the void return type.
-template<typename R, typename P1 = void, typename P2 = void, typename P3 = void>
+template<typename R, typename P1 = void, typename P2 = void,
+    typename P3 = void, typename P4 = void>
 struct Invoker {
   inline static void Go(
       Arguments* args,
+      const base::Callback<R(P1, P2, P3, P4)>& callback,
+      const P1& a1,
+      const P2& a2,
+      const P3& a3,
+      const P4& a4) {
+    args->Return(callback.Run(a1, a2, a3, a4));
+  }
+};
+template<typename P1, typename P2, typename P3, typename P4>
+struct Invoker<void, P1, P2, P3, P4> {
+  inline static void Go(
+      Arguments* args,
+      const base::Callback<void(P1, P2, P3, P4)>& callback,
+      const P1& a1,
+      const P2& a2,
+      const P3& a3,
+      const P4& a4) {
+    callback.Run(a1, a2, a3, a4);
+  }
+};
+
+template<typename R, typename P1, typename P2, typename P3>
+struct Invoker<R, P1, P2, P3, void> {
+  inline static void Go(
+      Arguments* args,
       const base::Callback<R(P1, P2, P3)>& callback,
       const P1& a1,
       const P2& a2,
       const P3& a3) {
     args->Return(callback.Run(a1, a2, a3));
   }
 };
 template<typename P1, typename P2, typename P3>
-struct Invoker<void, P1, P2, P3> {
+struct Invoker<void, P1, P2, P3, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1, P2, P3)>& callback,
       const P1& a1,
       const P2& a2,
       const P3& a3) {
     callback.Run(a1, a2, a3);
   }
 };
 
 template<typename R, typename P1, typename P2>
-struct Invoker<R, P1, P2, void> {
+struct Invoker<R, P1, P2, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R(P1, P2)>& callback,
       const P1& a1,
       const P2& a2) {
     args->Return(callback.Run(a1, a2));
   }
 };
 template<typename P1, typename P2>
-struct Invoker<void, P1, P2, void> {
+struct Invoker<void, P1, P2, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1, P2)>& callback,
       const P1& a1,
       const P2& a2) {
     callback.Run(a1, a2);
   }
 };
 
 template<typename R, typename P1>
-struct Invoker<R, P1, void, void> {
+struct Invoker<R, P1, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R(P1)>& callback,
       const P1& a1) {
     args->Return(callback.Run(a1));
   }
 };
 template<typename P1>
-struct Invoker<void, P1, void, void> {
+struct Invoker<void, P1, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1)>& callback,
       const P1& a1) {
     callback.Run(a1);
   }
 };
 
 template<typename R>
-struct Invoker<R, void, void, void> {
+struct Invoker<R, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R()>& callback) {
     args->Return(callback.Run());
   }
 };
 template<>
-struct Invoker<void, void, void, void> {
+struct Invoker<void, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void()>& callback) {
     callback.Run();
   }
 };
 
 
 // DispatchToCallback converts all the JavaScript arguments to C++ types and
 // invokes the base::Callback.
@@ skipping 66 matching lines @@
   if (!args.GetNext(&a1) ||
       !args.GetNext(&a2) ||
       !args.GetNext(&a3)) {
     args.ThrowError();
     return;
   }
 
   Invoker<R, P1, P2, P3>::Go(&args, holder->callback, a1, a2, a3);
 }
 
+template<typename R, typename P1, typename P2, typename P3, typename P4>
+static void DispatchToCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  Arguments args(info);
+  CallbackHolderBase* holder_base = NULL;
+  CHECK(args.GetData(&holder_base));
+
+  typedef CallbackHolder<R(P1, P2, P3, P4)> HolderT;
+  HolderT* holder = static_cast<HolderT*>(holder_base);
+
+  typename RemoveConstRef<P1>::Type a1;
+  typename RemoveConstRef<P2>::Type a2;
+  typename RemoveConstRef<P3>::Type a3;
+  typename RemoveConstRef<P4>::Type a4;
+  if (!args.GetNext(&a1) ||
+      !args.GetNext(&a2) ||
+      !args.GetNext(&a3) ||
+      !args.GetNext(&a4)) {
+    args.ThrowError();
+    return;
+  }
+
+  Invoker<R, P1, P2, P3, P4>::Go(&args, holder->callback, a1, a2, a3, a4);
+}
+
 }  // 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
@@ skipping 35 matching lines @@
 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
     v8::Isolate* isolate,
     const base::Callback<R(P1, P2, P3)> callback) {
   typedef internal::CallbackHolder<R(P1, P2, P3)> HolderT;
   scoped_refptr<HolderT> holder(new HolderT(callback));
   return v8::FunctionTemplate::New(
       &internal::DispatchToCallback<R, P1, P2, P3>,
       ConvertToV8<internal::CallbackHolderBase*>(isolate, holder.get()));
 }
 
+template<typename R, typename P1, typename P2, typename P3, typename P4>
+v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
+    v8::Isolate* isolate,
+    const base::Callback<R(P1, P2, P3, P4)> callback) {
+  typedef internal::CallbackHolder<R(P1, P2, P3, P4)> HolderT;
+  scoped_refptr<HolderT> holder(new HolderT(callback));
+  return v8::FunctionTemplate::New(
+      &internal::DispatchToCallback<R, P1, P2, P3, P4>,
+      ConvertToV8<internal::CallbackHolderBase*>(isolate, holder.get()));
+}
+
 }  // namespace gin