[Extensions Bindings] Return result from event dispatch

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/optional.h"
@@ skipping 22 matching lines @@
 
 class APIEventHandlerTest : public APIBindingTest {
  protected:
   APIEventHandlerTest() {}
   ~APIEventHandlerTest() override {}
 
   void SetUp() override {
     APIBindingTest::SetUp();
     handler_ = base::MakeUnique<APIEventHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+        base::Bind(&RunFunctionOnGlobalAndReturnHandle),
         base::Bind(&DoNothingOnEventListenersChanged));
   }
 
   void TearDown() override {
     DisposeAllContexts();
     handler_.reset();
     APIBindingTest::TearDown();
   }
 
   void OnWillDisposeContext(v8::Local<v8::Context> context) override {
@@ skipping 496 matching lines @@
     v8::MaybeLocal<v8::Value> maybe_result =
         function->Call(context, context->Global(), argc, argv);
     v8::Global<v8::Value> result;
     v8::Local<v8::Value> local;
     if (maybe_result.ToLocal(&local))
       result.Reset(context->GetIsolate(), local);
   };
 
   SetHandler(base::MakeUnique<APIEventHandler>(
       base::Bind(run_js_and_expect_error),
+      base::Bind(&RunFunctionOnGlobalAndReturnHandle),
       base::Bind(&DoNothingOnEventListenersChanged)));
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   const char kEventName[] = "alpha";
   v8::Local<v8::Object> event = handler()->CreateEventInstance(
       kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
@@ skipping 51 matching lines @@
                                                 "didThrow"));
   EXPECT_EQ("[42]", GetStringPropertyFromObject(context->Global(), context,
                                                 "eventArgs"));
   EXPECT_TRUE(did_throw);
 }
 
 // Tests being notified as listeners are added or removed from events.
 TEST_F(APIEventHandlerTest, CallbackNotifications) {
   MockEventChangeHandler change_handler;
   SetHandler(base::MakeUnique<APIEventHandler>(
-      base::Bind(&RunFunctionOnGlobalAndIgnoreResult), change_handler.Get()));
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+      base::Bind(&RunFunctionOnGlobalAndReturnHandle), change_handler.Get()));
 
   v8::HandleScope handle_scope(isolate());
 
   v8::Local<v8::Context> context_a = MainContext();
   v8::Local<v8::Context> context_b = AddContext();
 
   const char kEventName1[] = "onFoo";
   const char kEventName2[] = "onBar";
   v8::Local<v8::Object> event1_a = handler()->CreateEventInstance(
       kEventName1, false, binding::kNoListenerMax, true, context_a);
@@ skipping 266 matching lines @@
   // that we don't crash.)
 }
 
 // Test creating a custom event, as is done by a few of our custom bindings.
 TEST_F(APIEventHandlerTest, TestCreateCustomEvent) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler change_handler;
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+                          base::Bind(&RunFunctionOnGlobalAndReturnHandle),
                           change_handler.Get());
 
   v8::Local<v8::Object> event = handler.CreateAnonymousEventInstance(context);
   ASSERT_FALSE(event.IsEmpty());
 
   const char kAddListenerFunction[] =
       "(function(event) {\n"
       "  event.addListener(function() {\n"
       "    this.eventArgs = Array.from(arguments);\n"
       "  });\n"
@@ skipping 28 matching lines @@
                                                      "eventArgs"));
 }
 
 // Test adding a custom event with a cyclic dependency. Nothing should leak.
 TEST_F(APIEventHandlerTest, TestCreateCustomEventWithCyclicDependency) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler change_handler;
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+                          base::Bind(&RunFunctionOnGlobalAndReturnHandle),
                           change_handler.Get());
 
   v8::Local<v8::Object> event = handler.CreateAnonymousEventInstance(context);
   ASSERT_FALSE(event.IsEmpty());
 
   const char kAddListenerFunction[] =
       "(function(event) {\n"
       "  event.addListener(function() {}.bind(null, event));\n"
       "})";
   v8::Local<v8::Value> add_listener_argv[] = {event};
   RunFunction(FunctionFromString(context, kAddListenerFunction), context,
               arraysize(add_listener_argv), add_listener_argv);
 
   DisposeContext(context);
 }
 
 TEST_F(APIEventHandlerTest, TestUnmanagedEvents) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   auto fail_on_notified =
       [](const std::string& event_name, binding::EventListenersChanged changed,
          const base::DictionaryValue* filter, bool was_manual,
          v8::Local<v8::Context> context) { ADD_FAILURE(); };
 
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+                          base::Bind(&RunFunctionOnGlobalAndReturnHandle),
                           base::Bind(fail_on_notified));
 
   const char kEventName[] = "alpha";
   v8::Local<v8::Object> event = handler.CreateEventInstance(
       kEventName, false, binding::kNoListenerMax, false, context);
 
   const char kListener[] =
       "(function() {\n"
       "  this.eventArgs = Array.from(arguments);\n"
       "});";
@@ skipping 21 matching lines @@
         "(function(event, listener) { event.removeListener(listener); })";
     v8::Local<v8::Value> args[] = {event, listener};
     RunFunction(FunctionFromString(context, kRemoveListener), context,
                 arraysize(args), args);
   }
 
   EXPECT_EQ(0u, handler.GetNumEventListenersForTesting(kEventName, context));
 }
 
 }  // namespace extensions