[gin] Use variadic templates in gin/function_template.h

gin/wrappable_unittest.cc

 // 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/logging.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 79 matching lines @@
     return Wrappable<MyCallableObject>::GetObjectTemplateBuilder(isolate)
         .SetCallAsFunctionHandler(&MyCallableObject::Call);
   }
 
   MyCallableObject() : result_(0) {
   }
 
   virtual ~MyCallableObject() {
   }
 
-  void Call(int val, const gin::Arguments& arguments) {
+  void Call(int val1, int val2, int val3, const gin::Arguments& arguments) {
     if (arguments.IsConstructCall())
       arguments.ThrowTypeError("Cannot be called as constructor.");
     else
-      result_ = val;
+      result_ = val1;
   }
 
   int result_;
 };
 
 class MyObject2 : public Wrappable<MyObject2> {
  public:
   static WrapperInfo kWrapperInfo;
 };
 
@@ skipping 111 matching lines @@
 }
 
 TEST_F(WrappableTest, CallAsFunction) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(isolate);
 
   gin::Handle<MyCallableObject> object(MyCallableObject::Create(isolate));
   EXPECT_EQ(0, object->result());
   v8::Handle<v8::String> source = StringToV8(isolate,
                                              "(function(obj) {"
-                                             "obj(42);"
+                                             "obj(42, 2, 5);"
                                              "})");
   gin::TryCatch try_catch;
   v8::Handle<v8::Script> script = v8::Script::Compile(source);
   v8::Handle<v8::Value> val = script->Run();
   v8::Handle<v8::Function> func;
   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
   v8::Handle<v8::Value> argv[] = {
     ConvertToV8(isolate, object.get())
   };
   func->Call(v8::Undefined(isolate), 1, argv);
   EXPECT_FALSE(try_catch.HasCaught());
   EXPECT_EQ(42, object->result());
 }
 
 TEST_F(WrappableTest, CallAsConstructor) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(isolate);
 
   gin::Handle<MyCallableObject> object(MyCallableObject::Create(isolate));
   EXPECT_EQ(0, object->result());
   v8::Handle<v8::String> source = StringToV8(isolate,
                                              "(function(obj) {"
-                                             "new obj(42);"
+                                             "new obj(42, 2, 5);"
                                              "})");
   gin::TryCatch try_catch;
   v8::Handle<v8::Script> script = v8::Script::Compile(source);
   v8::Handle<v8::Value> val = script->Run();
   v8::Handle<v8::Function> func;
   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
   v8::Handle<v8::Value> argv[] = {
     ConvertToV8(isolate, object.get())
   };
   func->Call(v8::Undefined(isolate), 1, argv);
   EXPECT_TRUE(try_catch.HasCaught());
 }
 
 }  // namespace gin