[Extensions Bindings] Move custom handling to APIBindingHooksDelegate

extensions/renderer/api_binding_unittest.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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding.h"
 #include "extensions/renderer/api_binding_hooks.h"
+#include "extensions/renderer/api_binding_hooks_test_delegate.h"
 #include "extensions/renderer/api_binding_test.h"
 #include "extensions/renderer/api_binding_test_util.h"
 #include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "extensions/renderer/api_type_reference_map.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/public/context_holder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
@@ skipping 149 matching lines @@
   void SetProperties(const char* properties) {
     binding_properties_ = DictionaryValueFromString(properties);
     ASSERT_TRUE(binding_properties_);
   }
 
   void SetHooks(std::unique_ptr<APIBindingHooks> hooks) {
     binding_hooks_ = std::move(hooks);
     ASSERT_TRUE(binding_hooks_);
   }
 
+  void SetHooksDelegate(
+      std::unique_ptr<APIBindingHooksDelegate> hooks_delegate) {
+    binding_hooks_delegate_ = std::move(hooks_delegate);
+    ASSERT_TRUE(binding_hooks_delegate_);
+  }
+
   void SetCreateCustomType(const APIBinding::CreateCustomType& callback) {
     create_custom_type_ = callback;
   }
 
   void InitializeBinding() {
     if (!binding_hooks_) {
       binding_hooks_ = base::MakeUnique<APIBindingHooks>(
           kBindingName, binding::RunJSFunctionSync());
     }
+    if (binding_hooks_delegate_)
+      binding_hooks_->SetDelegate(std::move(binding_hooks_delegate_));
     event_handler_ = base::MakeUnique<APIEventHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         base::Bind(&OnEventListenersChanged));
     binding_ = base::MakeUnique<APIBinding>(
         kBindingName, binding_functions_.get(), binding_types_.get(),
         binding_events_.get(), binding_properties_.get(), create_custom_type_,
         std::move(binding_hooks_), &type_refs_, request_handler_.get(),
         event_handler_.get());
     EXPECT_EQ(!binding_types_.get(), type_refs_.empty());
   }
@@ skipping 46 matching lines @@
   std::unique_ptr<APIBinding> binding_;
   std::unique_ptr<APIEventHandler> event_handler_;
   std::unique_ptr<APIRequestHandler> request_handler_;
   APITypeReferenceMap type_refs_;
 
   std::unique_ptr<base::ListValue> binding_functions_;
   std::unique_ptr<base::ListValue> binding_events_;
   std::unique_ptr<base::ListValue> binding_types_;
   std::unique_ptr<base::DictionaryValue> binding_properties_;
   std::unique_ptr<APIBindingHooks> binding_hooks_;
+  std::unique_ptr<APIBindingHooksDelegate> binding_hooks_delegate_;
   APIBinding::CreateCustomType create_custom_type_;
 
   DISALLOW_COPY_AND_ASSIGN(APIBindingUnittest);
 };
 
 void APIBindingUnittest::RunTest(v8::Local<v8::Context> context,
                                  v8::Local<v8::Object> object,
                                  const std::string& script_source,
                                  bool should_pass,
                                  const std::string& expected_json_arguments,
@@ skipping 418 matching lines @@
   DisposeContext(context_a);
   ExpectPass(context_b, binding_object_b, "obj.oneString('foo');", "['foo']",
              false);
 }
 
 // Tests adding custom hooks for an API method.
 TEST_F(APIBindingUnittest, TestCustomHooks) {
   SetFunctions(kFunctions);
 
   // Register a hook for the test.oneString method.
-  auto hooks = base::MakeUnique<APIBindingHooks>(
-      kBindingName, base::Bind(&RunFunctionOnGlobalAndReturnHandle));
+  auto hooks = base::MakeUnique<APIBindingHooksTestDelegate>();
   bool did_call = false;
   auto hook = [](bool* did_call, const APISignature* signature,
                  v8::Local<v8::Context> context,
                  std::vector<v8::Local<v8::Value>>* arguments,
                  const APITypeReferenceMap& ref_map) {
     *did_call = true;
     APIBindingHooks::RequestResult result(
         APIBindingHooks::RequestResult::HANDLED);
     if (arguments->size() != 1u) {  // ASSERT* messes with the return type.
       EXPECT_EQ(1u, arguments->size());
       return result;
     }
     EXPECT_EQ("foo", gin::V8ToString(arguments->at(0)));
     return result;
   };
-  hooks->RegisterHandleRequest("test.oneString", base::Bind(hook, &did_call));
-  SetHooks(std::move(hooks));
+  hooks->AddHandler("test.oneString", base::Bind(hook, &did_call));
+  SetHooksDelegate(std::move(hooks));
 
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   v8::Local<v8::Object> binding_object =
       binding()->CreateInstance(context, isolate(), base::Bind(&AllowAllAPIs));
 
   // First try calling the oneString() method, which has a custom hook
@@ skipping 260 matching lines @@
 }
 
 // Tests that native custom hooks can return results synchronously, or throw
 // exceptions for bad invocations.
 TEST_F(APIBindingUnittest,
        TestReturningResultAndThrowingExceptionFromCustomNativeHook) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   // Register a hook for the test.oneString method.
-  auto hooks = base::MakeUnique<APIBindingHooks>(
-      kBindingName, base::Bind(&RunFunctionOnGlobalAndReturnHandle));
+  auto hooks = base::MakeUnique<APIBindingHooksTestDelegate>();
   bool did_call = false;
   auto hook = [](bool* did_call, const APISignature* signature,
                  v8::Local<v8::Context> context,
                  std::vector<v8::Local<v8::Value>>* arguments,
                  const APITypeReferenceMap& ref_map) {
     APIBindingHooks::RequestResult result(
         APIBindingHooks::RequestResult::HANDLED);
     if (arguments->size() != 1u) {  // ASSERT* messes with the return type.
       EXPECT_EQ(1u, arguments->size());
       return result;
     }
     v8::Isolate* isolate = context->GetIsolate();
     std::string arg_value = gin::V8ToString(arguments->at(0));
     if (arg_value == "throw") {
       isolate->ThrowException(v8::Exception::Error(
           gin::StringToV8(isolate, "Custom Hook Error")));
       result.code = APIBindingHooks::RequestResult::THROWN;
       return result;
     }
     result.return_value =
         gin::StringToV8(context->GetIsolate(), arg_value + " pong");
     return result;
   };
-  hooks->RegisterHandleRequest("test.oneString", base::Bind(hook, &did_call));
+  hooks->AddHandler("test.oneString", base::Bind(hook, &did_call));
 
-  SetHooks(std::move(hooks));
+  SetHooksDelegate(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::Local<v8::Object> binding_object =
       binding()->CreateInstance(context, isolate(), base::Bind(&AllowAllAPIs));
 
   {
     // Test an invocation that we expect to throw an exception.
     v8::Local<v8::Function> function =
         FunctionFromString(
@@ skipping 125 matching lines @@
 
   blink::WebScopedUserGesture user_gesture(nullptr);
   RunFunction(function, context, arraysize(argv), argv);
   ASSERT_TRUE(last_request());
   EXPECT_TRUE(last_request()->has_user_gesture);
 
   reset_last_request();
 }
 
 }  // namespace extensions