[Extensions Bindings] Introduce a supportsLazyListeners property

extensions/renderer/bindings/api_event_listeners_unittest.cc

 // 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/bindings/api_event_listeners.h"
 
 #include "base/test/mock_callback.h"
 #include "base/values.h"
 #include "extensions/common/event_filter.h"
 #include "extensions/renderer/bindings/api_binding_test.h"
@@ skipping 18 matching lines @@
 const char kEvent[] = "event";
 
 }  // namespace
 
 // Test unfiltered listeners.
 TEST_F(APIEventListenersTest, UnfilteredListeners) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler handler;
-  UnfilteredEventListeners listeners(handler.Get(), binding::kNoListenerMax);
+  UnfilteredEventListeners listeners(handler.Get(), binding::kNoListenerMax,
+                                     true);
 
   // Starting out, there should be no listeners.
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   EXPECT_EQ(0u, listeners.GetNumListeners());
   EXPECT_FALSE(listeners.HasListener(function_a));
 
   std::string error;
   v8::Local<v8::Object> filter;
 
   // Adding a new listener should trigger the callback (0 -> 1).
@@ skipping 50 matching lines @@
   EXPECT_EQ(0u, listeners.GetNumListeners());
   EXPECT_TRUE(listeners.GetListeners(nullptr, context).empty());
 }
 
 // Tests the invalidation of unfiltered listeners.
 TEST_F(APIEventListenersTest, UnfilteredListenersInvalidation) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler handler;
-  UnfilteredEventListeners listeners(handler.Get(), binding::kNoListenerMax);
+  UnfilteredEventListeners listeners(handler.Get(), binding::kNoListenerMax,
+                                     true);
 
   listeners.Invalidate(context);
 
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   v8::Local<v8::Function> function_b = FunctionFromString(context, kFunction);
   std::string error;
   v8::Local<v8::Object> filter;
   EXPECT_CALL(handler, Run(binding::EventListenersChanged::HAS_LISTENERS,
                            nullptr, true, context));
   EXPECT_TRUE(listeners.AddListener(function_a, filter, context, &error));
   ::testing::Mock::VerifyAndClearExpectations(&handler);
   EXPECT_TRUE(listeners.AddListener(function_b, filter, context, &error));
 
   EXPECT_CALL(handler, Run(binding::EventListenersChanged::NO_LISTENERS,
                            nullptr, false, context));
   listeners.Invalidate(context);
   ::testing::Mock::VerifyAndClearExpectations(&handler);
 
   EXPECT_EQ(0u, listeners.GetNumListeners());
 }
 
 // Tests that unfiltered listeners ignore the filtering info.
 TEST_F(APIEventListenersTest, UnfilteredListenersIgnoreFilteringInfo) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   UnfilteredEventListeners listeners(base::Bind(&DoNothingOnUpdate),
-                                     binding::kNoListenerMax);
+                                     binding::kNoListenerMax, true);
   v8::Local<v8::Function> function = FunctionFromString(context, kFunction);
   std::string error;
   v8::Local<v8::Object> filter;
   EXPECT_TRUE(listeners.AddListener(function, filter, context, &error));
   EventFilteringInfo filtering_info;
   filtering_info.url = GURL("http://example.com/foo");
   EXPECT_THAT(listeners.GetListeners(&filtering_info, context),
               testing::UnorderedElementsAre(function));
 }
 
 TEST_F(APIEventListenersTest, UnfilteredListenersMaxListenersTest) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  UnfilteredEventListeners listeners(base::Bind(&DoNothingOnUpdate), 1);
+  UnfilteredEventListeners listeners(base::Bind(&DoNothingOnUpdate), 1, true);
 
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   EXPECT_EQ(0u, listeners.GetNumListeners());
 
   std::string error;
   v8::Local<v8::Object> filter;
   EXPECT_TRUE(listeners.AddListener(function_a, filter, context, &error));
   EXPECT_TRUE(listeners.HasListener(function_a));
   EXPECT_EQ(1u, listeners.GetNumListeners());
 
   v8::Local<v8::Function> function_b = FunctionFromString(context, kFunction);
   EXPECT_FALSE(listeners.AddListener(function_b, filter, context, &error));
   EXPECT_FALSE(error.empty());
   EXPECT_FALSE(listeners.HasListener(function_b));
   EXPECT_TRUE(listeners.HasListener(function_a));
   EXPECT_EQ(1u, listeners.GetNumListeners());
 }
 
+TEST_F(APIEventListenersTest, UnfilteredListenersLazyListeners) {
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = MainContext();
+
+  MockEventChangeHandler handler;
+  UnfilteredEventListeners listeners(handler.Get(), binding::kNoListenerMax,
+                                     false);
+
+  v8::Local<v8::Function> listener = FunctionFromString(context, kFunction);
+  std::string error;
+  EXPECT_CALL(handler, Run(binding::EventListenersChanged::HAS_LISTENERS,
+                           nullptr, false, context));
+  listeners.AddListener(listener, v8::Local<v8::Object>(), context, &error);
+  ::testing::Mock::VerifyAndClearExpectations(&handler);
+
+  EXPECT_CALL(handler, Run(binding::EventListenersChanged::NO_LISTENERS,
+                           nullptr, false, context));
+  listeners.RemoveListener(listener, context);
+  ::testing::Mock::VerifyAndClearExpectations(&handler);
+}
+
 // Tests filtered listeners.
 TEST_F(APIEventListenersTest, FilteredListeners) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler handler;
   EventFilter event_filter;
-  FilteredEventListeners listeners(handler.Get(), kEvent,
-                                   binding::kNoListenerMax, &event_filter);
+  FilteredEventListeners listeners(
+      handler.Get(), kEvent, binding::kNoListenerMax, true, &event_filter);
 
   // Starting out, there should be no listeners registered.
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   EXPECT_EQ(0u, listeners.GetNumListeners());
   EXPECT_EQ(0, event_filter.GetMatcherCountForEventForTesting(kEvent));
   EXPECT_FALSE(listeners.HasListener(function_a));
 
   v8::Local<v8::Object> empty_filter;
   std::string error;
 
@@ skipping 106 matching lines @@
 
 // Tests that adding multiple listeners with the same filter doesn't trigger
 // the update callback.
 TEST_F(APIEventListenersTest,
        UnfilteredListenersWithSameFilterDontTriggerUpdate) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler handler;
   EventFilter event_filter;
-  FilteredEventListeners listeners(handler.Get(), kEvent,
-                                   binding::kNoListenerMax, &event_filter);
+  FilteredEventListeners listeners(
+      handler.Get(), kEvent, binding::kNoListenerMax, true, &event_filter);
 
   auto get_filter = [context]() {
     return V8ValueFromScriptSource(context, "({url: [{pathContains: 'foo'}]})")
         .As<v8::Object>();
   };
 
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
 
   std::string error;
   EXPECT_CALL(handler, Run(binding::EventListenersChanged::HAS_LISTENERS,
@@ skipping 25 matching lines @@
   EXPECT_EQ(0, event_filter.GetMatcherCountForEventForTesting(kEvent));
 }
 
 // Tests that trying to add a listener with an invalid filter fails.
 TEST_F(APIEventListenersTest, UnfilteredListenersError) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   EventFilter event_filter;
   FilteredEventListeners listeners(base::Bind(&DoNothingOnUpdate), kEvent,
-                                   binding::kNoListenerMax, &event_filter);
+                                   binding::kNoListenerMax, true,
+                                   &event_filter);
 
   v8::Local<v8::Object> invalid_filter =
       V8ValueFromScriptSource(context, "({url: 'some string'})")
           .As<v8::Object>();
   v8::Local<v8::Function> function = FunctionFromString(context, kFunction);
   std::string error;
   EXPECT_FALSE(
       listeners.AddListener(function, invalid_filter, context, &error));
   EXPECT_FALSE(error.empty());
 }
 
 // Tests that adding listeners for multiple different events is correctly
 // recorded in the EventFilter.
 TEST_F(APIEventListenersTest, MultipleUnfilteredListenerEvents) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   const char kAlpha[] = "alpha";
   const char kBeta[] = "beta";
 
   EventFilter event_filter;
   FilteredEventListeners listeners_a(base::Bind(&DoNothingOnUpdate), kAlpha,
-                                     binding::kNoListenerMax, &event_filter);
+                                     binding::kNoListenerMax, true,
+                                     &event_filter);
   FilteredEventListeners listeners_b(base::Bind(&DoNothingOnUpdate), kBeta,
-                                     binding::kNoListenerMax, &event_filter);
+                                     binding::kNoListenerMax, true,
+                                     &event_filter);
 
   EXPECT_EQ(0, event_filter.GetMatcherCountForEventForTesting(kAlpha));
   EXPECT_EQ(0, event_filter.GetMatcherCountForEventForTesting(kBeta));
 
   std::string error;
   v8::Local<v8::Object> filter;
 
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   EXPECT_TRUE(listeners_a.AddListener(function_a, filter, context, &error));
   EXPECT_EQ(1, event_filter.GetMatcherCountForEventForTesting(kAlpha));
@@ skipping 13 matching lines @@
   EXPECT_EQ(0, event_filter.GetMatcherCountForEventForTesting(kBeta));
 }
 
 // Tests the invalidation of filtered listeners.
 TEST_F(APIEventListenersTest, FilteredListenersInvalidation) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   MockEventChangeHandler handler;
   EventFilter event_filter;
-  FilteredEventListeners listeners(handler.Get(), kEvent,
-                                   binding::kNoListenerMax, &event_filter);
+  FilteredEventListeners listeners(
+      handler.Get(), kEvent, binding::kNoListenerMax, true, &event_filter);
   listeners.Invalidate(context);
 
   v8::Local<v8::Object> empty_filter;
   v8::Local<v8::Object> filter =
       V8ValueFromScriptSource(context, "({url: [{pathContains: 'foo'}]})")
           .As<v8::Object>();
   std::string error;
 
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   v8::Local<v8::Function> function_b = FunctionFromString(context, kFunction);
@@ skipping 20 matching lines @@
   EXPECT_EQ(0u, listeners.GetNumListeners());
   EXPECT_EQ(0, event_filter.GetMatcherCountForEventForTesting(kEvent));
 }
 
 TEST_F(APIEventListenersTest, FilteredListenersMaxListenersTest) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   EventFilter event_filter;
   FilteredEventListeners listeners(base::Bind(&DoNothingOnUpdate), kEvent, 1,
-                                   &event_filter);
+                                   true, &event_filter);
 
   v8::Local<v8::Function> function_a = FunctionFromString(context, kFunction);
   EXPECT_EQ(0u, listeners.GetNumListeners());
 
   std::string error;
   v8::Local<v8::Object> filter;
   EXPECT_TRUE(listeners.AddListener(function_a, filter, context, &error));
   EXPECT_TRUE(listeners.HasListener(function_a));
   EXPECT_EQ(1u, listeners.GetNumListeners());
 
   v8::Local<v8::Function> function_b = FunctionFromString(context, kFunction);
   EXPECT_FALSE(listeners.AddListener(function_b, filter, context, &error));
   EXPECT_FALSE(error.empty());
   EXPECT_FALSE(listeners.HasListener(function_b));
   EXPECT_TRUE(listeners.HasListener(function_a));
   EXPECT_EQ(1u, listeners.GetNumListeners());
 }
 
+TEST_F(APIEventListenersTest, FilteredListenersLazyListeners) {
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = MainContext();
+
+  MockEventChangeHandler handler;
+  EventFilter event_filter;
+  FilteredEventListeners listeners(
+      handler.Get(), kEvent, binding::kNoListenerMax, false, &event_filter);
+
+  v8::Local<v8::Function> listener = FunctionFromString(context, kFunction);
+  std::string error;
+  EXPECT_CALL(handler, Run(binding::EventListenersChanged::HAS_LISTENERS,
+                           testing::NotNull(), false, context));
+  listeners.AddListener(listener, v8::Local<v8::Object>(), context, &error);
+  ::testing::Mock::VerifyAndClearExpectations(&handler);
+
+  EXPECT_CALL(handler, Run(binding::EventListenersChanged::NO_LISTENERS,
+                           testing::NotNull(), false, context));
+  listeners.RemoveListener(listener, context);
+  ::testing::Mock::VerifyAndClearExpectations(&handler);
+}
+
 }  // namespace extensions