[Extension Bindings] Add JS custom hook support

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"
@@ skipping 272 matching lines @@
         base::StringPrintf("%s.%s", api_name_.c_str(), event_name.c_str());
     v8::Local<v8::Object> event =
         event_handler->CreateEventInstance(full_event_name, context);
     DCHECK(!event.IsEmpty());
     v8::Maybe<bool> success = object->CreateDataProperty(
         context, gin::StringToSymbol(isolate, event_name), event);
     DCHECK(success.IsJust());
     DCHECK(success.FromJust());
   }
 
+  if (binding_hooks_)
+    binding_hooks_->InitializeInContext(context, api_name_);
+
   return object;
 }
 
 void APIBinding::HandleCall(const std::string& name,
                             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;
-    }
+  // Since this is called synchronously from the JS entry point,
+  // GetCurrentContext() should always be correct.
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  // Check for a custom hook to handle the method.
+  if (binding_hooks_ &&
+      binding_hooks_->HandleRequest(api_name_, name, context,
+                                    signature, arguments)) {
+    return;  // Handled by a custom hook.
   }
 
   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);
+                       context, callback);
 }
 
 }  // namespace extensions