[Extensions Bindings] Move custom handling to APIBindingHooksDelegate

extensions/renderer/api_bindings_system_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 "extensions/renderer/api_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/common/event_filtering_info.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/renderer/api_binding.h"
 #include "extensions/renderer/api_binding_hooks.h"
-#include "extensions/renderer/api_binding_hooks_delegate.h"
+#include "extensions/renderer/api_binding_hooks_test_delegate.h"
 #include "extensions/renderer/api_binding_test_util.h"
 #include "extensions/renderer/api_binding_types.h"
 #include "extensions/renderer/api_bindings_system_unittest.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/try_catch.h"
 
 namespace extensions {
 
 namespace {
@@ skipping 59 matching lines @@
     "  'functions': [{"
     "    'name': 'functionWithExternalRef',"
     "    'parameters': [{ 'name': 'someRef', '$ref': 'alpha.objRef' }]"
     "  }]"
     "}";
 
 bool AllowAllAPIs(const std::string& name) {
   return true;
 }
 
-class TestHooks : public APIBindingHooksDelegate {
- public:
-  TestHooks() {}
-  ~TestHooks() override {}
-
-  using CustomEventFactory = base::Callback<v8::Local<v8::Value>(
-      v8::Local<v8::Context>,
-      const binding::RunJSFunctionSync& run_js,
-      const std::string& event_name)>;
-
-  bool CreateCustomEvent(v8::Local<v8::Context> context,
-                         const binding::RunJSFunctionSync& run_js_sync,
-                         const std::string& event_name,
-                         v8::Local<v8::Value>* event_out) override {
-    if (!custom_event_.is_null()) {
-      *event_out = custom_event_.Run(context, run_js_sync, event_name);
-      return true;
-    }
-    return false;
-  }
-
-  void RegisterHooks(APIBindingHooks* hooks) {
-    for (const auto& request_handler : request_handlers_) {
-      hooks->RegisterHandleRequest(request_handler.first,
-                                   request_handler.second);
-    }
-  }
-
-  void AddHandler(base::StringPiece name,
-                  const APIBindingHooks::HandleRequestHook& hook) {
-    request_handlers_[name.as_string()] = hook;
-  }
-
-  void SetCustomEvent(const CustomEventFactory& custom_event) {
-    custom_event_ = custom_event;
-  }
-
- private:
-  std::map<std::string, APIBindingHooks::HandleRequestHook> request_handlers_;
-  CustomEventFactory custom_event_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestHooks);
-};
-
 }  // namespace
 
 APIBindingsSystemTest::APIBindingsSystemTest() {}
 APIBindingsSystemTest::~APIBindingsSystemTest() = default;
 
 void APIBindingsSystemTest::SetUp() {
   APIBindingTest::SetUp();
 
   // Create the fake API schemas.
   for (const auto& api : GetAPIs()) {
@@ skipping 211 matching lines @@
       return result;
     }
     v8::Local<v8::String> response =
         gin::StringToV8(context->GetIsolate(), "bar");
     v8::Local<v8::Value> response_args[] = {response};
     RunFunctionOnGlobal(arguments->at(1).As<v8::Function>(),
                         context, 1, response_args);
     return result;
   };
 
-  auto test_hooks = base::MakeUnique<TestHooks>();
+  auto test_hooks = base::MakeUnique<APIBindingHooksTestDelegate>();
   test_hooks->AddHandler("alpha.functionWithCallback",
                          base::Bind(hook, &did_call));
   APIBindingHooks* binding_hooks =
       bindings_system()->GetHooksForAPI(kAlphaAPIName);
-  test_hooks->RegisterHooks(binding_hooks);
   binding_hooks->SetDelegate(std::move(test_hooks));
 
   v8::Local<v8::Object> alpha_api = bindings_system()->CreateAPIInstance(
       kAlphaAPIName, context, isolate(), base::Bind(&AllowAllAPIs), nullptr);
   ASSERT_FALSE(alpha_api.IsEmpty());
 
   {
     // Test a simple call -> response.
     const char kTestCall[] =
         "obj.functionWithCallback('foo', function() {\n"
@@ skipping 91 matching lines @@
                                 const binding::RunJSFunctionSync& run_js,
                                 const std::string& event_name) {
     v8::Isolate* isolate = context->GetIsolate();
     v8::Local<v8::Object> ret = v8::Object::New(isolate);
     ret->Set(context, gin::StringToSymbol(isolate, "name"),
              gin::StringToSymbol(isolate, event_name))
         .ToChecked();
     return ret.As<v8::Value>();
   };
 
-  auto test_hooks = base::MakeUnique<TestHooks>();
+  auto test_hooks = base::MakeUnique<APIBindingHooksTestDelegate>();
   test_hooks->SetCustomEvent(base::Bind(create_custom_event));
   APIBindingHooks* binding_hooks =
       bindings_system()->GetHooksForAPI(kAlphaAPIName);
   binding_hooks->SetDelegate(std::move(test_hooks));
 
   v8::Local<v8::Object> api = bindings_system()->CreateAPIInstance(
       kAlphaAPIName, context, isolate(), base::Bind(&AllowAllAPIs), nullptr);
 
   v8::Local<v8::Value> event =
       GetPropertyFromObject(api, context, "alphaEvent");
   ASSERT_TRUE(event->IsObject());
   EXPECT_EQ(
       "\"alpha.alphaEvent\"",
       GetStringPropertyFromObject(event.As<v8::Object>(), context, "name"));
   v8::Local<v8::Value> event2 =
       GetPropertyFromObject(api, context, "alphaEvent");
   EXPECT_EQ(event, event2);
 
   v8::Local<v8::Value> other_event =
       GetPropertyFromObject(api, context, "alphaOtherEvent");
   ASSERT_TRUE(other_event->IsObject());
   EXPECT_EQ("\"alpha.alphaOtherEvent\"",
             GetStringPropertyFromObject(other_event.As<v8::Object>(), context,
                                         "name"));
   EXPECT_NE(event, other_event);
 }
 
 }  // namespace extensions