[Extensions Bindings] Move custom handling to APIBindingHooksDelegate

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 "extensions/renderer/api_binding_hooks_delegate.h"
@@ skipping 189 matching lines @@
     : code(code), custom_callback(custom_callback) {}
 APIBindingHooks::RequestResult::~RequestResult() {}
 APIBindingHooks::RequestResult::RequestResult(const RequestResult& other) =
     default;
 
 APIBindingHooks::APIBindingHooks(const std::string& api_name,
                                  const binding::RunJSFunctionSync& run_js)
     : api_name_(api_name), 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;
-}
-
 APIBindingHooks::RequestResult APIBindingHooks::RunHooks(
     const std::string& method_name,
     v8::Local<v8::Context> context,
     const APISignature* signature,
     std::vector<v8::Local<v8::Value>>* arguments,
     const APITypeReferenceMap& type_refs) {
   // Easy case: a native custom hook.
-  auto request_hooks_iter = request_hooks_.find(method_name);
-  if (request_hooks_iter != request_hooks_.end()) {
-    RequestResult result =
-        request_hooks_iter->second.Run(
-            signature, context, arguments, type_refs);
-    // Right now, it doesn't make sense to register a request handler that
-    // doesn't handle the request.
-    DCHECK_NE(RequestResult::NOT_HANDLED, result.code);
-    return result;
+  if (delegate_) {
+    RequestResult result = delegate_->HandleRequest(
+        method_name, signature, context, arguments, type_refs);
+    if (result.code != RequestResult::NOT_HANDLED)
+      return result;
   }
 
   // Harder case: looking up a custom hook registered on the context (since
   // these are JS, each context has a separate instance).
   v8::Local<v8::Object> hook_interface_object =
       GetJSHookInterfaceObject(api_name_, context, false);
   if (hook_interface_object.IsEmpty())
     return RequestResult(RequestResult::NOT_HANDLED);
 
   v8::Isolate* isolate = context->GetIsolate();
@@ skipping 126 matching lines @@
   if (result.IsEmpty() ||
       !gin::Converter<std::vector<v8::Local<v8::Value>>>::FromV8(
           context->GetIsolate(), result, &new_args)) {
     return false;
   }
   arguments->swap(new_args);
   return true;
 }
 
 }  // namespace extensions