[Extenisons Bindings] Support `unmanaged` property for events

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 58 matching lines @@
 }  // namespace
 
 // Tests adding, removing, and querying event listeners by calling the
 // associated methods on the JS object.
 TEST_F(APIEventHandlerTest, AddingRemovingAndQueryingEventListeners) {
   const char kEventName[] = "alpha";
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   v8::Local<v8::Object> event = handler()->CreateEventInstance(
-      kEventName, false, binding::kNoListenerMax, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   EXPECT_EQ(0u, handler()->GetNumEventListenersForTesting(kEventName, context));
 
   const char kListenerFunction[] = "(function() {})";
   v8::Local<v8::Function> listener_function =
       FunctionFromString(context, kListenerFunction);
   ASSERT_FALSE(listener_function.IsEmpty());
 
   const char kAddListenerFunction[] =
@@ skipping 78 matching lines @@
 }
 
 // Tests listening for and firing different events.
 TEST_F(APIEventHandlerTest, FiringEvents) {
   const char kAlphaName[] = "alpha";
   const char kBetaName[] = "beta";
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   v8::Local<v8::Object> alpha_event = handler()->CreateEventInstance(
-      kAlphaName, false, binding::kNoListenerMax, context);
+      kAlphaName, false, binding::kNoListenerMax, true, context);
   v8::Local<v8::Object> beta_event = handler()->CreateEventInstance(
-      kBetaName, false, binding::kNoListenerMax, context);
+      kBetaName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(alpha_event.IsEmpty());
   ASSERT_FALSE(beta_event.IsEmpty());
 
   const char kAlphaListenerFunction1[] =
       "(function() {\n"
       "  if (!this.alphaCount1) this.alphaCount1 = 0;\n"
       "  ++this.alphaCount1;\n"
       "});\n";
   v8::Local<v8::Function> alpha_listener1 =
       FunctionFromString(context, kAlphaListenerFunction1);
@@ skipping 75 matching lines @@
   EXPECT_EQ(1, get_fired_count("betaCount"));
 }
 
 // Tests firing events with arguments.
 TEST_F(APIEventHandlerTest, EventArguments) {
   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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   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[] =
@@ skipping 27 matching lines @@
 
   v8::Local<v8::Function> listener_a = FunctionFromString(
       context_a, "(function(arg) { this.eventArgs = arg + 'alpha'; })");
   ASSERT_FALSE(listener_a.IsEmpty());
   v8::Local<v8::Function> listener_b = FunctionFromString(
       context_b, "(function(arg) { this.eventArgs = arg + 'beta'; })");
   ASSERT_FALSE(listener_b.IsEmpty());
 
   // Create two instances of the same event in different contexts.
   v8::Local<v8::Object> event_a = handler()->CreateEventInstance(
-      kEventName, false, binding::kNoListenerMax, context_a);
+      kEventName, false, binding::kNoListenerMax, true, context_a);
   ASSERT_FALSE(event_a.IsEmpty());
   v8::Local<v8::Object> event_b = handler()->CreateEventInstance(
-      kEventName, false, binding::kNoListenerMax, context_b);
+      kEventName, false, binding::kNoListenerMax, true, context_b);
   ASSERT_FALSE(event_b.IsEmpty());
 
   // Add two separate listeners to the event, one in each context.
   const char kAddListenerFunction[] =
       "(function(event, listener) { event.addListener(listener); })";
   {
     v8::Local<v8::Function> add_listener_a =
         FunctionFromString(context_a, kAddListenerFunction);
     v8::Local<v8::Value> argv[] = {event_a, listener_a};
     RunFunction(add_listener_a, context_a, arraysize(argv), argv);
@@ skipping 50 matching lines @@
                                           "eventArgs"));
   }
 }
 
 TEST_F(APIEventHandlerTest, DifferentCallingMethods) {
   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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   const char kAddListenerOnNull[] =
       "(function(event) {\n"
       "  event.addListener.call(null, function() {});\n"
       "})";
   {
     v8::Local<v8::Value> args[] = {event};
     // TODO(devlin): This is the generic type error that gin throws. It's not
     // very descriptive, nor does it match the web (which would just say e.g.
@@ skipping 31 matching lines @@
                 context, 1, args);
   }
   EXPECT_EQ(2u, handler()->GetNumEventListenersForTesting(kEventName, context));
 }
 
 TEST_F(APIEventHandlerTest, TestDispatchFromJs) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   v8::Local<v8::Object> event = handler()->CreateEventInstance(
-      "alpha", false, binding::kNoListenerMax, context);
+      "alpha", false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   const char kListenerFunction[] =
       "(function() {\n"
       "  this.eventArgs = Array.from(arguments);\n"
       "});";
   v8::Local<v8::Function> listener =
       FunctionFromString(context, kListenerFunction);
 
   const char kAddListenerFunction[] =
@@ skipping 20 matching lines @@
                 context->Global(), context, "eventArgs"));
 }
 
 // Test listeners that remove themselves in their handling of the event.
 TEST_F(APIEventHandlerTest, RemovingListenersWhileHandlingEvent) {
   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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
   {
     // Cache the event object on the global in order to allow for easy removal.
     v8::Local<v8::Function> set_event_on_global =
         FunctionFromString(
             context,
            "(function(event) { this.testEvent = event; })");
     v8::Local<v8::Value> args[] = {event};
     RunFunctionOnGlobal(set_event_on_global, context, arraysize(args), args);
     EXPECT_EQ(event,
@@ skipping 54 matching lines @@
 
   SetHandler(base::MakeUnique<APIEventHandler>(
       base::Bind(run_js_and_expect_error),
       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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   bool did_throw = false;
   auto message_listener = [](v8::Local<v8::Message> message,
                              v8::Local<v8::Value> data) {
     ASSERT_FALSE(data.IsEmpty());
     ASSERT_TRUE(data->IsExternal());
     bool* did_throw = static_cast<bool*>(data.As<v8::External>()->Value());
     *did_throw = true;
     EXPECT_EQ("Uncaught Error: Event handler error",
@@ skipping 53 matching lines @@
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult), 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, context_a);
+      kEventName1, false, binding::kNoListenerMax, true, context_a);
   ASSERT_FALSE(event1_a.IsEmpty());
   v8::Local<v8::Object> event2_a = handler()->CreateEventInstance(
-      kEventName2, false, binding::kNoListenerMax, context_a);
+      kEventName2, false, binding::kNoListenerMax, true, context_a);
   ASSERT_FALSE(event2_a.IsEmpty());
   v8::Local<v8::Object> event1_b = handler()->CreateEventInstance(
-      kEventName1, false, binding::kNoListenerMax, context_b);
+      kEventName1, false, binding::kNoListenerMax, true, context_b);
   ASSERT_FALSE(event1_b.IsEmpty());
 
   const char kAddListenerFunction[] =
       "(function(event, listener) { event.addListener(listener); })";
   const char kRemoveListenerFunction[] =
       "(function(event, listener) { event.removeListener(listener); })";
 
   // Add a listener to the first event. The APIEventHandler should notify
   // since it's a change in state (no listeners -> listeners).
   v8::Local<v8::Function> add_listener =
@@ skipping 101 matching lines @@
   ::testing::Mock::VerifyAndClearExpectations(&change_handler);
 }
 
 // Test registering an argument massager for a given event.
 TEST_F(APIEventHandlerTest, TestArgumentMassagers) {
   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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   const char kArgumentMassager[] =
       "(function(originalArgs, dispatch) {\n"
       "  this.originalArgs = originalArgs;\n"
       "  dispatch(['primary', 'secondary']);\n"
       "});";
   v8::Local<v8::Function> massager =
       FunctionFromString(context, kArgumentMassager);
   handler()->RegisterArgumentMassager(context, "alpha", massager);
@@ skipping 28 matching lines @@
 }
 
 // Test registering an argument massager for a given event and dispatching
 // asynchronously.
 TEST_F(APIEventHandlerTest, TestArgumentMassagersAsyncDispatch) {
   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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   const char kArgumentMassager[] =
       "(function(originalArgs, dispatch) {\n"
       "  this.originalArgs = originalArgs;\n"
       "  this.dispatch = dispatch;\n"
       "});";
   v8::Local<v8::Function> massager =
       FunctionFromString(context, kArgumentMassager);
   handler()->RegisterArgumentMassager(context, "alpha", massager);
@@ skipping 43 matching lines @@
       GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
 }
 
 // Test registering an argument massager and never dispatching.
 TEST_F(APIEventHandlerTest, TestArgumentMassagersNeverDispatch) {
   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, context);
+      kEventName, false, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   // A massager that never dispatches.
   const char kArgumentMassager[] = "(function(originalArgs, dispatch) {})";
   v8::Local<v8::Function> massager =
       FunctionFromString(context, kArgumentMassager);
   handler()->RegisterArgumentMassager(context, "alpha", massager);
 
   const char kListenerFunction[] = "(function() {})";
   v8::Local<v8::Function> listener_function =
@@ skipping 79 matching lines @@
       "(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(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"
+      "});";
+  v8::Local<v8::Function> listener = FunctionFromString(context, kListener);
+
+  {
+    const char kAddListener[] =
+        "(function(event, listener) { event.addListener(listener); })";
+    v8::Local<v8::Value> args[] = {event, listener};
+    RunFunction(FunctionFromString(context, kAddListener), context,
+                arraysize(args), args);
+  }
+
+  EXPECT_EQ(1u, handler.GetNumEventListenersForTesting(kEventName, context));
+
+  handler.FireEventInContext(kEventName, context,
+                             *ListValueFromString("[1, 'foo']"),
+                             EventFilteringInfo());
+
+  EXPECT_EQ("[1,\"foo\"]", GetStringPropertyFromObject(context->Global(),
+                                                       context, "eventArgs"));
+
+  {
+    const char kRemoveListener[] =
+        "(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