[Extensions Binding] Allow for registering custom hooks

extensions/renderer/api_bindings_system.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_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
+#include "extensions/renderer/api_binding_hooks.h"
 
 namespace extensions {
 
 APIBindingsSystem::Request::Request() {}
 APIBindingsSystem::Request::~Request() {}
 
 APIBindingsSystem::APIBindingsSystem(const binding::RunJSFunction& call_js,
                                      const GetAPISchemaMethod& get_api_schema,
                                      const SendRequestMethod& send_request)
     : request_handler_(call_js),
@@ skipping 20 matching lines @@
   const base::DictionaryValue& api_schema = get_api_schema_.Run(api_name);
 
   const base::ListValue* function_definitions = nullptr;
   CHECK(api_schema.GetList("functions", &function_definitions));
   const base::ListValue* type_definitions = nullptr;
   // Type definitions might not exist for the given API.
   api_schema.GetList("types", &type_definitions);
   const base::ListValue* event_definitions = nullptr;
   api_schema.GetList("events", &event_definitions);
 
+  // Find the hooks for the API. If none are registered, we create one.

[jbroman, 2016/12/08 16:58:56]

nit: Is there a need to heap-allocate one when we know it will forever remain
empty?

[Devlin, 2016/12/08 19:12:03]

Mostly just because I didn't want to have to nullcheck in the APIBinding, but
that's not a very compelling reason. :)  Removed the allocation.

+  std::unique_ptr<APIBindingHooks> hooks;
+  auto iter = binding_hooks_.find(api_name);
+  if (iter != binding_hooks_.end()) {
+    hooks = std::move(iter->second);
+    binding_hooks_.erase(iter);
+  } else {
+    hooks = base::MakeUnique<APIBindingHooks>(api_name);
+  }
+
   return base::MakeUnique<APIBinding>(
       api_name, *function_definitions, type_definitions, event_definitions,
       base::Bind(&APIBindingsSystem::OnAPICall, base::Unretained(this)),
-      &type_reference_map_);
+      std::move(hooks), &type_reference_map_);
 }
 
 void APIBindingsSystem::CompleteRequest(int request_id,
                                         const base::ListValue& response) {
   request_handler_.CompleteRequest(request_id, response);
 }
 
 void APIBindingsSystem::FireEventInContext(const std::string& event_name,
                                            v8::Local<v8::Context> context,
                                            const base::ListValue& response) {
   event_handler_.FireEventInContext(event_name, context, response);
 }
 
+APIBindingHooks* APIBindingsSystem::GetHooksForAPI(
+    const std::string& api_name) {
+  DCHECK(api_bindings_.empty())
+      << "Hook registration must happen before creating any binding instances.";
+  auto iter = binding_hooks_.find(api_name);

[jbroman, 2016/12/08 16:58:56]

super-duper-nit: This can be written without doing two map lookups in the new
case (it also winds up a little shorter):

std::unique_ptr<APIBindingHooks>& hooks = binding_hooks_[api_name];
if (!hooks)
  hooks = base::MakeUnique<APIBindingHooks>(api_name);
return hooks.get();

[Devlin, 2016/12/08 19:12:03]

I like it, done.

+  if (iter != binding_hooks_.end())
+    return iter->second.get();
+  auto hooks = base::MakeUnique<APIBindingHooks>(api_name);
+  APIBindingHooks* hooks_weak = hooks.get();
+  binding_hooks_[api_name] = std::move(hooks);
+  return hooks_weak;
+}
+
 void APIBindingsSystem::OnAPICall(const std::string& name,
                                   std::unique_ptr<base::ListValue> arguments,
                                   v8::Isolate* isolate,
                                   v8::Local<v8::Context> context,
                                   v8::Local<v8::Function> callback) {
   auto request = base::MakeUnique<Request>();
   if (!callback.IsEmpty()) {
     request->request_id =
         request_handler_.AddPendingRequest(isolate, callback, context);
     request->has_callback = true;
   }
   // TODO(devlin): Query and curry user gestures around.
   request->has_user_gesture = false;
   request->arguments = std::move(arguments);
   request->method_name = name;
 
   send_request_.Run(std::move(request), context);
 }
 
 }  // namespace extensions