[Extensions Binding] Allow for registering custom hooks

extensions/renderer/api_binding.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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/common/extension_api.h"
+#include "extensions/renderer/api_binding_hooks.h"
+#include "extensions/renderer/api_binding_types.h"
 #include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "gin/arguments.h"
 #include "gin/per_context_data.h"
 
 namespace extensions {
 
 namespace {
 
 const char kExtensionAPIPerContextKey[] = "extension_api_binding";
 
-using APISignature = std::vector<std::unique_ptr<ArgumentSpec>>;
-
 // Returns the expected APISignature for a dictionary describing an API method.
-std::unique_ptr<APISignature> GetAPISignature(
+std::unique_ptr<binding::APISignature> GetAPISignature(
     const base::DictionaryValue& dict) {
-  std::unique_ptr<APISignature> signature = base::MakeUnique<APISignature>();
+  auto signature = base::MakeUnique<binding::APISignature>();
   const base::ListValue* params = nullptr;
   CHECK(dict.GetList("parameters", &params));
   signature->reserve(params->GetSize());
   for (const auto& value : *params) {
     const base::DictionaryValue* param = nullptr;
     CHECK(value->GetAsDictionary(&param));
     std::string name;
     CHECK(param->GetString("name", &name));
     signature->push_back(base::MakeUnique<ArgumentSpec>(*param));
   }
@@ skipping 61 matching lines @@
     return false;
   }
 
   *callback_out = value.As<v8::Function>();
   arguments->Skip();
   return true;
 }
 
 // Parses |args| against |signature| and populates error with any errors.
 std::unique_ptr<base::ListValue> ParseArguments(
-    const APISignature* signature,
+    const binding::APISignature* signature,
     gin::Arguments* arguments,
     const ArgumentSpec::RefMap& type_refs,
     v8::Local<v8::Function>* callback,
     std::string* error) {
   auto results = base::MakeUnique<base::ListValue>();
 
   // TODO(devlin): This is how extension APIs have always determined if a
   // function has a callback, but it seems a little silly. In the long run (once
   // signatures are generated), it probably makes sense to indicate this
   // differently.
@@ skipping 62 matching lines @@
   callback->Run(&args);
 }
 
 }  // namespace
 
 APIBinding::APIBinding(const std::string& api_name,
                        const base::ListValue& function_definitions,
                        const base::ListValue* type_definitions,
                        const base::ListValue* event_definitions,
                        const APIMethodCallback& callback,
+                       std::unique_ptr<APIBindingHooks> binding_hooks,
                        ArgumentSpec::RefMap* type_refs)
     : api_name_(api_name),
       method_callback_(callback),
+      binding_hooks_(std::move(binding_hooks)),
       type_refs_(type_refs),
       weak_factory_(this) {
   DCHECK(!method_callback_.is_null());
   for (const auto& func : function_definitions) {
     const base::DictionaryValue* func_dict = nullptr;
     CHECK(func->GetAsDictionary(&func_dict));
     std::string name;
     CHECK(func_dict->GetString("name", &name));
-    std::unique_ptr<APISignature> spec = GetAPISignature(*func_dict);
+    std::unique_ptr<binding::APISignature> spec = GetAPISignature(*func_dict);
     signatures_[name] = std::move(spec);
   }
   if (type_definitions) {
     for (const auto& type : *type_definitions) {
       const base::DictionaryValue* type_dict = nullptr;
       CHECK(type->GetAsDictionary(&type_dict));
       std::string id;
       CHECK(type_dict->GetString("id", &id));
       DCHECK(type_refs->find(id) == type_refs->end());
       // TODO(devlin): refs are sometimes preceeded by the API namespace; we
@@ skipping 67 matching lines @@
     v8::Maybe<bool> success = object->CreateDataProperty(
         context, gin::StringToSymbol(isolate, event_name), event);
     DCHECK(success.IsJust());
     DCHECK(success.FromJust());
   }
 
   return object;
 }
 
 void APIBinding::HandleCall(const std::string& name,
-                            const APISignature* signature,
+                            const binding::APISignature* signature,
                             gin::Arguments* arguments) {
   std::string error;
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
+
+  if (binding_hooks_) {
+    // Check for a custom hook to handle the method.
+    APIBindingHooks::HandleRequestHook handler =
+        binding_hooks_->GetHandleRequest(name);
+    if (!handler.is_null()) {
+      handler.Run(signature, arguments);
+      return;
+    }
+  }
+
   std::unique_ptr<base::ListValue> parsed_arguments;
   v8::Local<v8::Function> callback;
   {
     v8::TryCatch try_catch(isolate);
     parsed_arguments =
         ParseArguments(signature, arguments, *type_refs_, &callback, &error);
     if (try_catch.HasCaught()) {
       DCHECK(!parsed_arguments);
       try_catch.ReThrow();
       return;
     }
   }
   if (!parsed_arguments) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   // Since this is called synchronously from the JS entry point,
   // GetCurrentContext() should always be correct.
   method_callback_.Run(name, std::move(parsed_arguments), isolate,
                        isolate->GetCurrentContext(), callback);
 }
 
 }  // namespace extensions