[Extensions Bindings] Add a registerEventArgumentMassager

extensions/renderer/api_event_handler_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_event_handler.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/mock_callback.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding_test.h"
 #include "extensions/renderer/api_binding_test_util.h"
+#include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/public/context_holder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace extensions {
 
 namespace {
 
 using MockEventChangeHandler = ::testing::StrictMock<
     base::MockCallback<APIEventHandler::EventListenersChangedMethod>>;
@@ skipping 676 matching lines @@
     v8::Local<v8::Function> listener =
         FunctionFromString(context_b, "(function() {})");
     v8::Local<v8::Value> argv[] = {event1_b, listener};
     RunFunction(add_listener, context_b, arraysize(argv), argv);
     ::testing::Mock::VerifyAndClearExpectations(&change_handler);
   }
   EXPECT_EQ(1u,
             handler.GetNumEventListenersForTesting(kEventName1, context_b));
 }
 
+// Test registering an argument massager for a given event.
+TEST_F(APIEventHandlerTest, TestArgumentMassagers) {
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = ContextLocal();
+
+  const char kEventName[] = "alpha";
+  APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+                          base::Bind(&DoNothingOnEventListenersChanged));
+  v8::Local<v8::Object> event =
+      handler.CreateEventInstance(kEventName, context);
+  ASSERT_FALSE(event.IsEmpty());
+
+  // Verifies the passed in arguments and dispatches the event with new
+  // arguments, 'primary' and 'secondary'.
+  auto argument_massager = [](const v8::FunctionCallbackInfo<v8::Value>& info) {

[jbroman, 2017/03/01 22:33:35]

This works, but elsewhere you usually use a function implemented in JS. Any
reason to deviate from that? (Using JS seems nicer because it's how it would
actually be used, so we test something closer to the real path.)

[Devlin, 2017/03/02 17:19:26]

Translated to JS.

+    gin::Arguments args(info);
+    v8::HandleScope handle_scope(args.isolate());
+    v8::Local<v8::Context> context = args.isolate()->GetCurrentContext();
+    std::vector<v8::Local<v8::Value>> event_args;
+    ASSERT_TRUE(args.GetNext(&event_args));
+    ASSERT_EQ(2u, event_args.size());
+    EXPECT_EQ("first", gin::V8ToString(event_args[0]));
+    EXPECT_EQ("second", gin::V8ToString(event_args[1]));
+
+    v8::Local<v8::Function> dispatch;
+    ASSERT_TRUE(args.GetNext(&dispatch));
+    v8::Local<v8::Array> massaged_args = v8::Array::New(args.isolate());
+    massaged_args->Set(context, 0, gin::StringToV8(args.isolate(), "primary"))
+        .ToChecked();
+    massaged_args->Set(context, 1, gin::StringToV8(args.isolate(), "secondary"))
+        .ToChecked();
+    v8::Local<v8::Value> function_args[] = {massaged_args};
+    RunFunctionOnGlobal(dispatch, context, arraysize(function_args),

[jbroman, 2017/03/01 22:33:35]

Since you mention that the dispatch function can be called asynchronously, we
probably ought to have at least one test for that.

[Devlin, 2017/03/02 17:19:26]

Added a second unit test for this.

+                        function_args);
+  };
+  v8::Local<v8::FunctionTemplate> massager_template =
+      v8::FunctionTemplate::New(isolate(), argument_massager);
+  v8::Local<v8::Function> massager =
+      massager_template->GetFunction(context).ToLocalChecked();

[jbroman, 2017/03/01 22:33:35]

nit: Otherwise, might as well use v8::Function::New here as well, not that it
really matters given this is a unit test.

[Devlin, 2017/03/02 17:19:26]

Ack, but moot. :)

+
+  handler.RegisterArgumentMassager(context, "alpha", massager);
+
+  const char kListenerFunction[] =
+      "(function() { this.eventArgs = Array.from(arguments); })";
+  v8::Local<v8::Function> listener_function =
+      FunctionFromString(context, kListenerFunction);
+  ASSERT_FALSE(listener_function.IsEmpty());
+
+  {
+    const char kAddListenerFunction[] =
+        "(function(event, listener) { event.addListener(listener); })";
+    v8::Local<v8::Function> add_listener_function =
+        FunctionFromString(context, kAddListenerFunction);
+    v8::Local<v8::Value> argv[] = {event, listener_function};
+    RunFunction(add_listener_function, context, arraysize(argv), argv);
+  }
+
+  const char kArguments[] = "['first','second']";
+  std::unique_ptr<base::ListValue> event_args = ListValueFromString(kArguments);
+  ASSERT_TRUE(event_args);
+  handler.FireEventInContext(kEventName, context, *event_args);
+
+  EXPECT_EQ(
+      "[\"primary\",\"secondary\"]",
+      GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
+}
+
 }  // namespace extensions