[Extensions Bindings] Introduce a supportsLazyListeners property

extensions/renderer/bindings/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/bindings/api_event_handler.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/test/mock_callback.h"
 #include "base/values.h"
 #include "extensions/common/event_filtering_info.h"
 #include "extensions/renderer/bindings/api_binding_test.h"
 #include "extensions/renderer/bindings/api_binding_test_util.h"
 #include "extensions/renderer/bindings/exception_handler.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 {
 
+const char kAddListenerFunction[] =
+    "(function(event, listener) { event.addListener(listener); })";
+const char kRemoveListenerFunction[] =
+    "(function(event, listener) { event.removeListener(listener); })";
+
 using MockEventChangeHandler = ::testing::StrictMock<
     base::MockCallback<APIEventHandler::EventListenersChangedMethod>>;
 
 void DoNothingOnEventListenersChanged(const std::string& event_name,
                                       binding::EventListenersChanged change,
                                       const base::DictionaryValue* value,
                                       bool was_manual,
                                       v8::Local<v8::Context> context) {}
 
 class APIEventHandlerTest : public APIBindingTest {
@@ skipping 35 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, true, context);
+      kEventName, false, true, 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[] =
-      "(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);
   }
   // There should only be one listener on the event.
   EXPECT_EQ(1u, handler()->GetNumEventListenersForTesting(kEventName, context));
 
@@ skipping 38 matching lines @@
   {
     v8::Local<v8::Value> argv[] = {event};
     v8::Local<v8::Value> result =
         RunFunction(has_listeners_function, context, arraysize(argv), argv);
     bool has_listeners = false;
     EXPECT_TRUE(
         gin::Converter<bool>::FromV8(isolate(), result, &has_listeners));
     EXPECT_TRUE(has_listeners);
   }
 
-  const char kRemoveListenerFunction[] =
-      "(function(event, listener) { event.removeListener(listener); })";
   v8::Local<v8::Function> remove_listener_function =
       FunctionFromString(context, kRemoveListenerFunction);
   {
     v8::Local<v8::Value> argv[] = {event, listener_function};
     RunFunction(remove_listener_function, context, arraysize(argv), argv);
   }
   EXPECT_EQ(0u, handler()->GetNumEventListenersForTesting(kEventName, context));
 
   {
     v8::Local<v8::Value> argv[] = {event};
     v8::Local<v8::Value> result =
         RunFunction(has_listeners_function, context, arraysize(argv), argv);
     bool has_listeners = false;
     EXPECT_TRUE(
         gin::Converter<bool>::FromV8(isolate(), result, &has_listeners));
     EXPECT_FALSE(has_listeners);
   }
 }
 
 // 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, true, context);
+      kAlphaName, false, true, binding::kNoListenerMax, true, context);
   v8::Local<v8::Object> beta_event = handler()->CreateEventInstance(
-      kBetaName, false, binding::kNoListenerMax, true, context);
+      kBetaName, false, true, 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);
   const char kAlphaListenerFunction2[] =
       "(function() {\n"
       "  if (!this.alphaCount2) this.alphaCount2 = 0;\n"
       "  ++this.alphaCount2;\n"
       "});\n";
   v8::Local<v8::Function> alpha_listener2 =
       FunctionFromString(context, kAlphaListenerFunction2);
   const char kBetaListenerFunction[] =
       "(function() {\n"
       "  if (!this.betaCount) this.betaCount = 0;\n"
       "  ++this.betaCount;\n"
       "});\n";
   v8::Local<v8::Function> beta_listener =
       FunctionFromString(context, kBetaListenerFunction);
   ASSERT_FALSE(alpha_listener1.IsEmpty());
   ASSERT_FALSE(alpha_listener2.IsEmpty());
   ASSERT_FALSE(beta_listener.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[] = {alpha_event, alpha_listener1};
       RunFunction(add_listener_function, context, arraysize(argv), argv);
     }
     {
       v8::Local<v8::Value> argv[] = {alpha_event, alpha_listener2};
       RunFunction(add_listener_function, context, arraysize(argv), argv);
     }
@@ skipping 43 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, true, context);
+      kEventName, false, true, 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[] =
-        "(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[] = "['foo',1,{'prop1':'bar'}]";
   std::unique_ptr<base::ListValue> event_args = ListValueFromString(kArguments);
   ASSERT_TRUE(event_args);
   handler()->FireEventInContext(kEventName, context, *event_args, nullptr);
@@ skipping 15 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, true, context_a);
+      kEventName, false, true, binding::kNoListenerMax, true, context_a);
   ASSERT_FALSE(event_a.IsEmpty());
   v8::Local<v8::Object> event_b = handler()->CreateEventInstance(
-      kEventName, false, binding::kNoListenerMax, true, context_b);
+      kEventName, false, true, 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);
   }
   EXPECT_EQ(1u,
             handler()->GetNumEventListenersForTesting(kEventName, context_a));
   EXPECT_EQ(0u,
             handler()->GetNumEventListenersForTesting(kEventName, context_b));
@@ skipping 43 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, true, context);
+      kEventName, false, true, 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, true, context);
+      "alpha", false, true, 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[] =
-      "(function(event, listener) { event.addListener(listener); })";
   v8::Local<v8::Function> add_listener_function =
       FunctionFromString(context, kAddListenerFunction);
 
   {
     v8::Local<v8::Value> argv[] = {event, listener};
     RunFunctionOnGlobal(add_listener_function, context, arraysize(argv), argv);
   }
 
   v8::Local<v8::Function> fire_event_function =
       FunctionFromString(
           context,
           "(function(event) { event.dispatch(42, 'foo', {bar: 'baz'}); })");
   {
     v8::Local<v8::Value> argv[] = {event};
     RunFunctionOnGlobal(fire_event_function, context, arraysize(argv), argv);
   }
 
   EXPECT_EQ("[42,\"foo\",{\"bar\":\"baz\"}]",
             GetStringPropertyFromObject(
                 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, true, context);
+      kEventName, false, true, 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,
               GetPropertyFromObject(context->Global(), context, "testEvent"));
   }
 
   // A listener function that removes itself as a listener.
   const char kListenerFunction[] =
       "(function() {\n"
       "  return function listener() {\n"
       "    this.testEvent.removeListener(listener);\n"
       "  };\n"
       "})();";
 
   // Create and add a bunch of listeners.
   std::vector<v8::Local<v8::Function>> listeners;
   const size_t kNumListeners = 20u;
   listeners.reserve(kNumListeners);
   for (size_t i = 0; i < kNumListeners; ++i)
     listeners.push_back(FunctionFromString(context, kListenerFunction));
 
-  const char kAddListenerFunction[] =
-      "(function(event, listener) { event.addListener(listener); })";
   v8::Local<v8::Function> add_listener_function =
       FunctionFromString(context, kAddListenerFunction);
 
   for (const auto& listener : listeners) {
     v8::Local<v8::Value> argv[] = {event, listener};
     RunFunctionOnGlobal(add_listener_function, context, arraysize(argv), argv);
   }
 
   // Fire the event. All listeners should be removed (and we shouldn't crash).
   EXPECT_EQ(kNumListeners,
@@ skipping 33 matching lines @@
   SetHandler(base::MakeUnique<APIEventHandler>(
       base::Bind(run_js_and_expect_error),
       base::Bind(&RunFunctionOnGlobalAndReturnHandle),
       base::Bind(&DoNothingOnEventListenersChanged), &exception_handler));
 
   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);
+      kEventName, false, true, binding::kNoListenerMax, true, context);
   ASSERT_FALSE(event.IsEmpty());
 
   // A listener that will throw an exception. We guarantee that we throw the
   // exception first so that we don't rely on event listener ordering.
   const char kListenerFunction[] =
       "(function() {\n"
       "  if (!this.didThrow) {\n"
       "    this.didThrow = true;\n"
       "    throw new Error('Event handler error');\n"
       "  }\n"
       "  this.eventArgs = Array.from(arguments);\n"
       "});";
 
-  const char kAddListenerFunction[] =
-      "(function(event, listener) { event.addListener(listener); })";
   v8::Local<v8::Function> add_listener_function =
       FunctionFromString(context, kAddListenerFunction);
 
   for (int i = 0; i < 2; ++i) {
     v8::Local<v8::Function> listener =
         FunctionFromString(context, kListenerFunction);
     v8::Local<v8::Value> argv[] = {event, listener};
     RunFunctionOnGlobal(add_listener_function, context, arraysize(argv), argv);
   }
   EXPECT_EQ(2u, handler()->GetNumEventListenersForTesting(kEventName, context));
@@ skipping 22 matching lines @@
       nullptr));
 
   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);
+      kEventName1, false, true, binding::kNoListenerMax, true, context_a);
   ASSERT_FALSE(event1_a.IsEmpty());
   v8::Local<v8::Object> event2_a = handler()->CreateEventInstance(
-      kEventName2, false, binding::kNoListenerMax, true, context_a);
+      kEventName2, false, true, binding::kNoListenerMax, true, context_a);
   ASSERT_FALSE(event2_a.IsEmpty());
   v8::Local<v8::Object> event1_b = handler()->CreateEventInstance(
-      kEventName1, false, binding::kNoListenerMax, true, context_b);
+      kEventName1, false, true, 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 =
       FunctionFromString(context_a, kAddListenerFunction);
   v8::Local<v8::Function> listener1 =
       FunctionFromString(context_a, "(function() {})");
   {
     EXPECT_CALL(change_handler,
                 Run(kEventName1, binding::EventListenersChanged::HAS_LISTENERS,
                     nullptr, true, context_a))
@@ skipping 94 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, true, context);
+      kEventName, false, true, 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);
 
   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, nullptr);
 
   EXPECT_EQ(
       "[\"first\",\"second\"]",
       GetStringPropertyFromObject(context->Global(), context, "originalArgs"));
   EXPECT_EQ(
       "[\"primary\",\"secondary\"]",
       GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
 }
 
 // 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, true, context);
+      kEventName, false, true, 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);
 
   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, nullptr);
@@ skipping 22 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, true, context);
+      kEventName, false, true, 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 =
       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);
 
   handler()->FireEventInContext(kEventName, context, base::ListValue(),
                                 nullptr);
 
   // Nothing should blow up. (We tested in the previous test that the event
   // isn't notified without calling dispatch, so all there is to test here is
@@ skipping 81 matching lines @@
       [](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), nullptr);
 
   const char kEventName[] = "alpha";
   v8::Local<v8::Object> event = handler.CreateEventInstance(
-      kEventName, false, binding::kNoListenerMax, false, context);
+      kEventName, false, true, 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); })";
@@ skipping 14 matching lines @@
     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));
 }
 
+// Test callback notifications for events that don't support lazy listeners.
+TEST_F(APIEventHandlerTest, TestEventsWithoutLazyListeners) {
+  MockEventChangeHandler change_handler;
+  APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
+                          base::Bind(&RunFunctionOnGlobalAndReturnHandle),
+                          change_handler.Get(), nullptr);
+
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = MainContext();
+
+  const char kLazyListenersSupported[] = "supportsLazyListeners";
+  const char kLazyListenersNotSupported[] = "noLazyListeners";
+  v8::Local<v8::Object> lazy_listeners_supported =
+      handler.CreateEventInstance(kLazyListenersSupported, false, true,
+                                  binding::kNoListenerMax, true, context);
+  v8::Local<v8::Object> lazy_listeners_not_supported =
+      handler.CreateEventInstance(kLazyListenersNotSupported, false, false,
+                                  binding::kNoListenerMax, true, context);
+  ASSERT_FALSE(lazy_listeners_not_supported.IsEmpty());
+
+  v8::Local<v8::Function> add_listener =
+      FunctionFromString(context, kAddListenerFunction);
+  v8::Local<v8::Function> listener =
+      FunctionFromString(context, "(function() {})");
+  {
+    EXPECT_CALL(change_handler,
+                Run(kLazyListenersSupported,
+                    binding::EventListenersChanged::HAS_LISTENERS, nullptr,
+                    true, context))
+        .Times(1);
+    v8::Local<v8::Value> argv[] = {lazy_listeners_supported, listener};
+    RunFunction(add_listener, context, arraysize(argv), argv);
+    ::testing::Mock::VerifyAndClearExpectations(&change_handler);
+  }
+
+  {
+    EXPECT_CALL(change_handler,
+                Run(kLazyListenersNotSupported,
+                    binding::EventListenersChanged::HAS_LISTENERS, nullptr,
+                    false, context))
+        .Times(1);
+    v8::Local<v8::Value> argv[] = {lazy_listeners_not_supported, listener};
+    RunFunction(add_listener, context, arraysize(argv), argv);
+    ::testing::Mock::VerifyAndClearExpectations(&change_handler);
+  }
+
+  v8::Local<v8::Function> remove_listener =
+      FunctionFromString(context, kRemoveListenerFunction);
+  {
+    EXPECT_CALL(change_handler,
+                Run(kLazyListenersSupported,
+                    binding::EventListenersChanged::NO_LISTENERS, nullptr, true,
+                    context))
+        .Times(1);
+    v8::Local<v8::Value> argv[] = {lazy_listeners_supported, listener};
+    RunFunction(remove_listener, context, arraysize(argv), argv);
+    ::testing::Mock::VerifyAndClearExpectations(&change_handler);
+  }
+
+  {
+    EXPECT_CALL(change_handler,
+                Run(kLazyListenersNotSupported,
+                    binding::EventListenersChanged::NO_LISTENERS, nullptr,
+                    false, context))
+        .Times(1);
+    v8::Local<v8::Value> argv[] = {lazy_listeners_not_supported, listener};
+    RunFunction(remove_listener, context, arraysize(argv), argv);
+    ::testing::Mock::VerifyAndClearExpectations(&change_handler);
+  }
+
+  DisposeContext(context);
+}
+
 }  // namespace extensions