[Extensions Binding] Allow for registering custom hooks

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_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 "gin/arguments.h"
 #include "gin/converter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 namespace {
 
 // Function spec; we use single quotes for readability and then replace them.
 const char kFunctions[] =
@@ skipping 162 matching lines @@
   arguments_.reset();
 }
 
 TEST_F(APIBindingUnittest, Test) {
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
-      &refs);
+      nullptr, &refs);
   EXPECT_TRUE(refs.empty());
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
 
@@ skipping 80 matching lines @@
 
   std::unique_ptr<base::ListValue> functions =
       ListValueFromString(kRefFunctions);
   ASSERT_TRUE(functions);
   std::unique_ptr<base::ListValue> types = ListValueFromString(kTypes);
   ASSERT_TRUE(types);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, types.get(), nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
-      &refs);
+      nullptr, &refs);
   EXPECT_EQ(2u, refs.size());
   EXPECT_TRUE(base::ContainsKey(refs, "refObj"));
   EXPECT_TRUE(base::ContainsKey(refs, "refEnum"));
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
@@ skipping 25 matching lines @@
       "  'name': 'restrictedTwo',"
       "  'parameters': []"
       "}]";
   std::unique_ptr<base::ListValue> functions =
       ListValueFromString(kRestrictedFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
-      &refs);
+      nullptr, &refs);
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   auto is_available = [](const std::string& name) {
     std::set<std::string> functions = {"test.allowedOne", "test.allowedTwo",
                                        "test.restrictedOne",
                                        "test.restrictedTwo"};
     EXPECT_TRUE(functions.count(name));
     return name == "test.allowedOne" || name == "test.allowedTwo";
@@ skipping 22 matching lines @@
 TEST_F(APIBindingUnittest, TestEventCreation) {
   const char kEvents[] = "[{'name': 'onFoo'}, {'name': 'onBar'}]";
   std::unique_ptr<base::ListValue> events = ListValueFromString(kEvents);
   ASSERT_TRUE(events);
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, events.get(),
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
-      &refs);
+      nullptr, &refs);
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
 
   // Event behavior is tested in the APIEventHandler unittests as well as the
@@ skipping 15 matching lines @@
   EXPECT_FALSE(has_on_baz.FromJust());
 }
 
 TEST_F(APIBindingUnittest, TestDisposedContext) {
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
       "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
-      &refs);
+      nullptr, &refs);
   EXPECT_TRUE(refs.empty());
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
 
   v8::Local<v8::Function> func =
       FunctionFromString(context, "(function(obj) { obj.oneString('foo'); })");
   v8::Local<v8::Value> argv[] = {binding_object};
   DisposeContext();
   RunFunction(func, context, arraysize(argv), argv);
   EXPECT_FALSE(HandlerWasInvoked());
   // This test passes if this does not crash, even under AddressSanitizer
   // builds.
 }
 
+// Tests adding custom hooks for an API method.
+TEST_F(APIBindingUnittest, TestCustomHooks) {
+  std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
+  ASSERT_TRUE(functions);
+  ArgumentSpec::RefMap refs;
+
+  // Register a hook for the test.oneString method.
+  auto hooks = base::MakeUnique<APIBindingHooks>();
+  bool did_call = false;
+  auto hook = [](bool* did_call, const binding::APISignature* signature,
+                 gin::Arguments* arguments) {
+    *did_call = true;
+    EXPECT_EQ(1, arguments->Length());
+    std::string argument;
+    EXPECT_TRUE(arguments->GetNext(&argument));
+    EXPECT_EQ("foo", argument);
+  };
+  hooks->RegisterHandleRequest("test.oneString", base::Bind(hook, &did_call));
+
+  APIBinding binding(
+      "test", *functions, nullptr, nullptr,
+      base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
+      std::move(hooks), &refs);
+  EXPECT_TRUE(refs.empty());
+
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = ContextLocal();
+
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
+  v8::Local<v8::Object> binding_object = binding.CreateInstance(
+      context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
+
+  // First try calling the oneString() method, which has a custom hook
+  // installed.
+  v8::Local<v8::Function> func =
+      FunctionFromString(context, "(function(obj) { obj.oneString('foo'); })");
+  v8::Local<v8::Value> args[] = {binding_object};
+  RunFunction(func, context, 1, args);
+  EXPECT_TRUE(did_call);
+
+  // Other methods, like stringAndInt(), should behave normally.
+  ExpectPass(binding_object, "obj.stringAndInt('foo', 42);", "['foo',42]");
+}
+
 }  // namespace extensions