[Extensions Bindings] Add a bridge to use current custom bindings

extensions/renderer/api_binding_hooks.cc

 // Copyright 2016 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 "extensions/renderer/api_binding_hooks.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
 #include "gin/arguments.h"
@@ skipping 66 matching lines @@
   }
 
   v8::Isolate* isolate;
 
   std::map<std::string, v8::Global<v8::Object>> hook_interfaces;
 };
 
 gin::WrapperInfo JSHookInterface::kWrapperInfo =
     {gin::kEmbedderNativeGin};
 
-// Creates and returns JS object for the hook interface to allow for
-// registering custom hooks from JS.
-v8::Local<v8::Object> CreateJSHookInterface(const std::string& api_name,
-                                            v8::Local<v8::Context> context) {
-  gin::PerContextData* per_context_data = gin::PerContextData::From(context);
-  DCHECK(per_context_data);
-  APIHooksPerContextData* data = static_cast<APIHooksPerContextData*>(
-      per_context_data->GetUserData(kExtensionAPIHooksPerContextKey));
-  if (!data) {
-    auto api_data =
-        base::MakeUnique<APIHooksPerContextData>(context->GetIsolate());
-    data = api_data.get();
-    per_context_data->SetUserData(kExtensionAPIHooksPerContextKey,
-                                  api_data.release());
-  }
-
-  DCHECK(data->hook_interfaces.find(api_name) == data->hook_interfaces.end());
-
-  gin::Handle<JSHookInterface> hooks =
-      gin::CreateHandle(context->GetIsolate(), new JSHookInterface(api_name));
-  CHECK(!hooks.IsEmpty());
-  v8::Local<v8::Object> hooks_object = hooks.ToV8().As<v8::Object>();
-  data->hook_interfaces[api_name].Reset(context->GetIsolate(), hooks_object);
-
-  return hooks_object;
-}
-
 }  // namespace
 
 APIBindingHooks::APIBindingHooks(const binding::RunJSFunction& run_js)
     : run_js_(run_js) {}
 APIBindingHooks::~APIBindingHooks() {}
 
 void APIBindingHooks::RegisterHandleRequest(const std::string& method_name,
                                             const HandleRequestHook& hook) {
   DCHECK(!hooks_used_) << "Hooks must be registered before the first use!";
   request_hooks_[method_name] = hook;
@@ skipping 38 matching lines @@
   CHECK(hook_interface);
 
   auto js_hook_iter = hook_interface->js_hooks()->find(method_name);
   if (js_hook_iter == hook_interface->js_hooks()->end())
     return false;
 
   // Found a JS handler.
   std::vector<v8::Local<v8::Value>> v8_args;
   // TODO(devlin): Right now, this doesn't support exceptions or return values,
   // which we will need to at some point.
-  if (arguments->GetRemaining(&v8_args)) {
+  if (arguments->Length() == 0 || arguments->GetRemaining(&v8_args)) {
     v8::Local<v8::Function> handler =
         js_hook_iter->second.Get(context->GetIsolate());
     run_js_.Run(handler, context, v8_args.size(), v8_args.data());
   }
 
   return true;
 }
 
 void APIBindingHooks::InitializeInContext(
     v8::Local<v8::Context> context,
     const std::string& api_name) {
   if (js_hooks_source_.IsEmpty())
     return;
 
   v8::Local<v8::String> source = js_hooks_source_.Get(context->GetIsolate());
   v8::Local<v8::String> resource_name =
       js_resource_name_.Get(context->GetIsolate());
   v8::Local<v8::Script> script;
   v8::ScriptOrigin origin(resource_name);
   if (!v8::Script::Compile(context, source, &origin).ToLocal(&script))
     return;
   v8::Local<v8::Value> func_as_value = script->Run();
   v8::Local<v8::Function> function;
   if (!gin::ConvertFromV8(context->GetIsolate(), func_as_value, &function))
     return;
-  v8::Local<v8::Object> api_hooks = CreateJSHookInterface(api_name, context);
+  v8::Local<v8::Value> api_hooks = GetJSHookInterface(api_name, context);
   v8::Local<v8::Value> args[] = {api_hooks};
   run_js_.Run(function, context, arraysize(args), args);
 }
 
+v8::Local<v8::Object> APIBindingHooks::GetJSHookInterface(
+    const std::string& api_name,
+    v8::Local<v8::Context> context) {
+  gin::PerContextData* per_context_data = gin::PerContextData::From(context);
+  DCHECK(per_context_data);
+  APIHooksPerContextData* data = static_cast<APIHooksPerContextData*>(
+      per_context_data->GetUserData(kExtensionAPIHooksPerContextKey));
+  if (!data) {
+    auto api_data =
+        base::MakeUnique<APIHooksPerContextData>(context->GetIsolate());
+    data = api_data.get();
+    per_context_data->SetUserData(kExtensionAPIHooksPerContextKey,
+                                  api_data.release());
+  }
+
+  auto iter = data->hook_interfaces.find(api_name);
+  if (iter != data->hook_interfaces.end())
+    return iter->second.Get(context->GetIsolate());
+
+  gin::Handle<JSHookInterface> hooks =
+      gin::CreateHandle(context->GetIsolate(), new JSHookInterface(api_name));
+  CHECK(!hooks.IsEmpty());
+  v8::Local<v8::Object> hooks_object = hooks.ToV8().As<v8::Object>();
+  data->hook_interfaces[api_name].Reset(context->GetIsolate(), hooks_object);
+
+  return hooks_object;
+}
+
 }  // namespace extensions