[Extensions Bindings] Return result from event dispatch

extensions/renderer/event_emitter_unittest.cc

Index: extensions/renderer/event_emitter_unittest.cc
diff --git a/extensions/renderer/event_emitter_unittest.cc b/extensions/renderer/event_emitter_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d9c6a4c4d51b85d24abaa50a2b980d8c6362f83f
--- /dev/null
+++ b/extensions/renderer/event_emitter_unittest.cc
@@ -0,0 +1,86 @@
+// Copyright 2017 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/event_emitter.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/values.h"
+#include "extensions/renderer/api_binding_test.h"
+#include "extensions/renderer/api_binding_test_util.h"
+#include "extensions/renderer/api_event_listeners.h"
+#include "gin/handle.h"
+
+namespace extensions {
+namespace {
+
+void DoNothingOnListenerChange(binding::EventListenersChanged changed,
+                               const base::DictionaryValue* filter,
+                               bool was_manual,
+                               v8::Local<v8::Context> context) {}
+
+}  // namespace
+
+using EventEmitterUnittest = APIBindingTest;
+
+TEST_F(EventEmitterUnittest, TestDispatchMethod) {
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = MainContext();
+
+  auto listeners = base::MakeUnique<UnfilteredEventListeners>(
+      base::Bind(&DoNothingOnListenerChange), binding::kNoListenerMax);
+
+  gin::Handle<EventEmitter> event = gin::CreateHandle(
+      isolate(),
+      new EventEmitter(false, std::move(listeners),
+                       base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+                       base::Bind(&RunFunctionOnGlobalAndReturnHandle)));
+
+  v8::Local<v8::Value> v8_event = event.ToV8();
+
+  const char kAddListener[] =
+      "(function(event, listener) { event.addListener(listener); })";
+  v8::Local<v8::Function> add_listener_function =
+      FunctionFromString(context, kAddListener);
+
+  auto add_listener = [context, v8_event,
+                       add_listener_function](base::StringPiece listener) {
+    v8::Local<v8::Function> listener_function =
+        FunctionFromString(context, listener);
+    v8::Local<v8::Value> args[] = {v8_event, listener_function};
+    RunFunction(add_listener_function, context, arraysize(args), args);
+  };
+
+  const char kListener1[] =
+      "(function() {\n"
+      "  this.eventArgs1 = Array.from(arguments);\n"
+      "  return 'listener1';\n"
+      "})";
+  add_listener(kListener1);
+  const char kListener2[] =
+      "(function() {\n"
+      "  this.eventArgs2 = Array.from(arguments);\n"
+      "  return {listener: 'listener2'};\n"
+      "})";
+  add_listener(kListener2);
+
+  const char kDispatch[] =
+      "(function(event) {\n"
+      "  return event.dispatch('arg1', 2);\n"
+      "})";
+  v8::Local<v8::Value> dispatch_args[] = {v8_event};
+  v8::Local<v8::Value> dispatch_result =
+      RunFunctionOnGlobal(FunctionFromString(context, kDispatch), context,
+                          arraysize(dispatch_args), dispatch_args);
+
+  const char kExpectedEventArgs[] = "[\"arg1\",2]";
+  EXPECT_EQ(kExpectedEventArgs, GetStringPropertyFromObject(
+                                    context->Global(), context, "eventArgs1"));
+  EXPECT_EQ(kExpectedEventArgs, GetStringPropertyFromObject(
+                                    context->Global(), context, "eventArgs2"));
+  EXPECT_EQ("{\"results\":[\"listener1\",{\"listener\":\"listener2\"}]}",
+            V8ToString(dispatch_result, context));
+}
+
+}  // namespace extensions