gin: Remove ability to install call-as-function handlers on gin::Wrappable

This is a functional revert of https://codereview.chromium.org/192693002.

Per `git log -S CreateFunctionHandler`, this API was never used, and was
only part of refactoring:
https://codereview.chromium.org/671433004
https://chromium-review.googlesource.com/760376

Change-Id: Ibcbad96a7f145dbf14e87e70a59318802971ba3f
Reviewed-on: https://chromium-review.googlesource.com/886442Reviewed-by: Jochen Eisinger <jochen@chromium.org>
Commit-Queue: Philip Jägenstedt <foolip@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532188}

gin/function_template.h

@@ -225,20 +225,6 @@ v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
   return tmpl;
 }
 
-// CreateFunctionHandler installs a CallAsFunction handler on the given
-// object template that forwards to a provided C++ function or base::Callback.
-template <typename Sig>
-void CreateFunctionHandler(v8::Isolate* isolate,
-                           v8::Local<v8::ObjectTemplate> tmpl,
-                           base::RepeatingCallback<Sig> callback,
-                           int callback_flags = 0) {
-  typedef internal::CallbackHolder<Sig> HolderT;
-  HolderT* holder = new HolderT(isolate, std::move(callback), callback_flags);
-  tmpl->SetCallAsFunctionHandler(&internal::Dispatcher<Sig>::DispatchToCallback,
-                                 ConvertToV8<v8::Local<v8::External> >(
-                                     isolate, holder->GetHandle(isolate)));
-}
-
 }  // namespace gin
 
 #endif  // GIN_FUNCTION_TEMPLATE_H_

gin/object_template_builder.h

@@ -85,11 +85,6 @@ class GIN_EXPORT ObjectTemplateBuilder {
     return SetPropertyImpl(name, CreateFunctionTemplate(isolate_, getter),
                            CreateFunctionTemplate(isolate_, setter));
   }
-  template<typename T>
-  ObjectTemplateBuilder& SetCallAsFunctionHandler(const T& callback) {
-    SetAsFunctionHandler(isolate_, template_, callback);
-    return *this;
-  }
   ObjectTemplateBuilder& AddNamedPropertyInterceptor();
   ObjectTemplateBuilder& AddIndexedPropertyInterceptor();
 

gin/wrappable_unittest.cc

@@ -57,44 +57,12 @@ class MyObject : public BaseClass,
   int value_;
 };
 
-class MyCallableObject : public Wrappable<MyCallableObject> {
- public:
-  static WrapperInfo kWrapperInfo;
-
-  static gin::Handle<MyCallableObject> Create(v8::Isolate* isolate) {
-    return CreateHandle(isolate, new MyCallableObject());
-  }
-
-  int result() { return result_; }
-
- private:
-  ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) final {
-    return Wrappable<MyCallableObject>::GetObjectTemplateBuilder(isolate)
-        .SetCallAsFunctionHandler(&MyCallableObject::Call);
-  }
-
-  MyCallableObject() : result_(0) {
-  }
-
-  ~MyCallableObject() override = default;
-
-  void Call(int val1, int val2, int val3, const gin::Arguments& arguments) {
-    if (arguments.IsConstructCall())
-      arguments.ThrowTypeError("Cannot be called as constructor.");
-    else
-      result_ = val1;
-  }
-
-  int result_;
-};
-
 class MyObject2 : public Wrappable<MyObject2> {
  public:
   static WrapperInfo kWrapperInfo;
 };
 
 WrapperInfo MyObject::kWrapperInfo = { kEmbedderNativeGin };
-WrapperInfo MyCallableObject::kWrapperInfo = { kEmbedderNativeGin };
 WrapperInfo MyObject2::kWrapperInfo = { kEmbedderNativeGin };
 
 typedef V8Test WrappableTest;
@@ -169,53 +137,4 @@ TEST_F(WrappableTest, GetAndSetProperty) {
   EXPECT_EQ(191, obj->value());
 }
 
-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::Local<v8::String> source = StringToV8(isolate,
-                                             "(function(obj) {"
-                                             "obj(42, 2, 5);"
-                                             "})");
-  gin::TryCatch try_catch(isolate);
-  v8::Local<v8::Script> script =
-      v8::Script::Compile(context_.Get(isolate), source).ToLocalChecked();
-  v8::Local<v8::Value> val =
-      script->Run(context_.Get(isolate)).ToLocalChecked();
-  v8::Local<v8::Function> func;
-  EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
-  v8::Local<v8::Value> argv[] = {
-      ConvertToV8(isolate->GetCurrentContext(), object.get()).ToLocalChecked(),
-  };
-  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::Local<v8::String> source = StringToV8(isolate,
-                                             "(function(obj) {"
-                                             "new obj(42, 2, 5);"
-                                             "})");
-  gin::TryCatch try_catch(isolate);
-  v8::Local<v8::Script> script =
-      v8::Script::Compile(context_.Get(isolate), source).ToLocalChecked();
-  v8::Local<v8::Value> val =
-      script->Run(context_.Get(isolate)).ToLocalChecked();
-  v8::Local<v8::Function> func;
-  EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
-  v8::Local<v8::Value> argv[] = {
-      ConvertToV8(isolate->GetCurrentContext(), object.get()).ToLocalChecked(),
-  };
-  func->Call(v8::Undefined(isolate), 1, argv);
-  EXPECT_TRUE(try_catch.HasCaught());
-}
-
 }  // namespace gin