[Extensions Binding] Allow for registering custom hooks

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/extension_api.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_binding_types.h"
+#include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/try_catch.h"
 
 namespace extensions {
 
 namespace {
 
 // Fake API for testing.
 const char kAlphaAPIName[] = "alpha";
 const char kAlphaAPISpec[] =
@@ skipping 255 matching lines @@
   {
     // Test a call -> response on the second API.
     const char kTestCall[] = "obj.simpleFunc(2)";
     CallFunctionOnObject(context, beta_api, kTestCall);
     ValidateLastRequest("beta.simpleFunc", "[2]");
     EXPECT_EQ(-1, last_request()->request_id);
     reset_last_request();
   }
 }
 
+// Tests adding a custom hook to an API.
+TEST_F(APIBindingsSystemTest, TestCustomHooks) {
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = ContextLocal();
+
+  bool did_call = false;
+  auto hook = [](bool* did_call, const binding::APISignature* signature,
+                 gin::Arguments* arguments) {
+    *did_call = true;
+    std::string argument;
+    EXPECT_EQ(2, arguments->Length());
+    EXPECT_TRUE(arguments->GetNext(&argument));
+    EXPECT_EQ("foo", argument);
+    v8::Local<v8::Function> function;
+    ASSERT_TRUE(arguments->GetNext(&function));
+    v8::Local<v8::String> response =
+        gin::StringToV8(arguments->isolate(), "bar");
+    v8::Local<v8::Value> response_args[] = {response};
+    RunFunctionOnGlobal(function, arguments->isolate()->GetCurrentContext(),
+                        1, response_args);
+  };
+
+  APIBindingHooks* hooks = bindings_system()->GetHooksForAPI(kAlphaAPIName);
+  ASSERT_TRUE(hooks);
+  hooks->RegisterHandleRequest(
+      "alpha.functionWithCallback",
+      base::Bind(hook, &did_call));
+
+  v8::Local<v8::Object> alpha_api = bindings_system()->CreateAPIInstance(
+      kAlphaAPIName, context, isolate(), base::Bind(&AllowAllAPIs));
+  ASSERT_FALSE(alpha_api.IsEmpty());
+
+  {
+    // Test a simple call -> response.
+    const char kTestCall[] =
+        "obj.functionWithCallback('foo', function() {\n"
+        "  this.callbackArguments = Array.from(arguments);\n"
+        "});";
+    CallFunctionOnObject(context, alpha_api, kTestCall);
+    EXPECT_TRUE(did_call);
+
+    std::unique_ptr<base::Value> result = GetBaseValuePropertyFromObject(
+        context->Global(), context, "callbackArguments");
+    ASSERT_TRUE(result);
+    EXPECT_EQ("[\"bar\"]", ValueToString(*result));
+  }
+}
+
 // An implementation using real API schemas.
 class APIBindingsSystemTestWithRealAPI : public APIBindingsSystemTestBase {
  protected:
   APIBindingsSystemTestWithRealAPI() {}
 
   // Executes the given |script_source| in |context|, expecting no exceptions.
   void ExecuteScript(v8::Local<v8::Context> context,
                      const std::string& script_source);
 
   // Executes the given |script_source| in |context| and compares a caught
@@ skipping 132 matching lines @@
                                           *ListValueFromString("['active']"));
 
     std::unique_ptr<base::Value> result =
         GetBaseValuePropertyFromObject(context->Global(), context, "idleState");
     ASSERT_TRUE(result);
     EXPECT_EQ("\"active\"", ValueToString(*result));
   }
 }
 
 }  // namespace extensions