[Extensions Bindings] Notify of event unregistration on invalidation

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/test/mock_callback.h"
@@ skipping 111 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_FALSE(has_listeners);
   }
+
+  handler.InvalidateContext(context);
 }
 
 // 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 = ContextLocal();
 
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
@@ skipping 78 matching lines @@
 
   handler.FireEventInContext(kAlphaName, context, base::ListValue());
   EXPECT_EQ(2, get_fired_count("alphaCount1"));
   EXPECT_EQ(2, get_fired_count("alphaCount2"));
   EXPECT_EQ(0, get_fired_count("betaCount"));
 
   handler.FireEventInContext(kBetaName, context, base::ListValue());
   EXPECT_EQ(2, get_fired_count("alphaCount1"));
   EXPECT_EQ(2, get_fired_count("alphaCount2"));
   EXPECT_EQ(1, get_fired_count("betaCount"));
+
+  handler.InvalidateContext(context);
 }
 
 // Tests firing events with arguments.
 TEST_F(APIEventHandlerTest, EventArguments) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   const char kEventName[] = "alpha";
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
                           base::Bind(&DoNothingOnEventListenersChanged));
@@ skipping 17 matching lines @@
   }
 
   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);
 
   EXPECT_EQ(
       ReplaceSingleQuotes(kArguments),
       GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
+
+  handler.InvalidateContext(context);
 }
 
 // Test dispatching events to multiple contexts.
 TEST_F(APIEventHandlerTest, MultipleContexts) {
   v8::HandleScope handle_scope(isolate());
 
   v8::Local<v8::Context> context_a = ContextLocal();
   v8::Local<v8::Context> context_b = v8::Context::New(isolate());
   gin::ContextHolder holder_b(isolate());
   holder_b.SetContext(context_b);
@@ skipping 65 matching lines @@
   {
     EXPECT_EQ("\"result_a:alpha\"",
               GetStringPropertyFromObject(context_a->Global(), context_a,
                                           "eventArgs"));
   }
   {
     EXPECT_EQ("\"result_b:beta\"",
               GetStringPropertyFromObject(context_b->Global(), context_b,
                                           "eventArgs"));
   }
+
+  handler.InvalidateContext(context_a);
+  handler.InvalidateContext(context_b);
 }
 
 TEST_F(APIEventHandlerTest, DifferentCallingMethods) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   const char kEventName[] = "alpha";
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
                           base::Bind(&DoNothingOnEventListenersChanged));
   v8::Local<v8::Object> event =
@@ skipping 35 matching lines @@
       "  event.addListener(function listener() {\n"
       "    event.hasListener(listener);\n"
       "  });\n"
       "})";
   {
     v8::Local<v8::Value> args[] = {event};
     RunFunction(FunctionFromString(context, kAddListenerOnEventWithCapture),
                 context, 1, args);
   }
   EXPECT_EQ(2u, handler.GetNumEventListenersForTesting(kEventName, context));
+
+  handler.InvalidateContext(context);
 }
 
 TEST_F(APIEventHandlerTest, TestDispatchFromJs) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
                           base::Bind(&DoNothingOnEventListenersChanged));
   v8::Local<v8::Object> event = handler.CreateEventInstance("alpha", context);
   ASSERT_FALSE(event.IsEmpty());
@@ skipping 20 matching lines @@
           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"));
+
+  handler.InvalidateContext(context);
 }
 
 // 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 = ContextLocal();
 
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
                           base::Bind(&DoNothingOnEventListenersChanged));
   const char kEventName[] = "alpha";
@@ skipping 36 matching lines @@
     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,
             handler.GetNumEventListenersForTesting(kEventName, context));
   handler.FireEventInContext(kEventName, context, base::ListValue());
   EXPECT_EQ(0u, handler.GetNumEventListenersForTesting(kEventName, context));
 
+  handler.InvalidateContext(context);
   // TODO(devlin): Another possible test: register listener a and listener b,
   // where a removes b and b removes a. Theoretically, only one should be
   // notified. Investigate what we currently do in JS-style bindings.
 }
 
 // Test an event listener throwing an exception.
 TEST_F(APIEventHandlerTest, TestEventListenersThrowingExceptions) {
   // The default test util methods (RunFunction*) assume no errors will ever
   // be encountered. Instead, use an implementation that allows errors.
   auto run_js_and_expect_error = [](v8::Local<v8::Function> function,
@@ skipping 64 matching lines @@
   ASSERT_TRUE(event_args);
   handler.FireEventInContext(kEventName, context, *event_args);
 
   // An exception should have been thrown by the first listener and the second
   // listener should have recorded the event arguments.
   EXPECT_EQ("true", GetStringPropertyFromObject(context->Global(), context,
                                                 "didThrow"));
   EXPECT_EQ("[42]", GetStringPropertyFromObject(context->Global(), context,
                                                 "eventArgs"));
   EXPECT_TRUE(did_throw);
+
+  handler.InvalidateContext(context);
 }
 
 // Tests being notified as listeners are added or removed from events.
 TEST_F(APIEventHandlerTest, CallbackNotifications) {
   v8::HandleScope handle_scope(isolate());
 
   v8::Local<v8::Context> context_a = ContextLocal();
   v8::Local<v8::Context> context_b = v8::Context::New(isolate());
   gin::ContextHolder holder_b(isolate());
   holder_b.SetContext(context_b);
@@ skipping 102 matching lines @@
     v8::Local<v8::Function> add_listener =
         FunctionFromString(context_b, kAddListenerFunction);
     v8::Local<v8::Function> listener =
         FunctionFromString(context_b, "(function() {})");
     v8::Local<v8::Value> argv[] = {event1_b, listener};
     RunFunction(add_listener, context_b, arraysize(argv), argv);
     ::testing::Mock::VerifyAndClearExpectations(&change_handler);
   }
   EXPECT_EQ(1u,
             handler.GetNumEventListenersForTesting(kEventName1, context_b));
+
+  // When the contexts are invalidated, we should receive listener removed
+  // notifications.
+  EXPECT_CALL(
+      change_handler,
+      Run(kEventName1, binding::EventListenersChanged::NO_LISTENERS, context_a))
+      .Times(1);
+  EXPECT_CALL(
+      change_handler,
+      Run(kEventName2, binding::EventListenersChanged::NO_LISTENERS, context_a))
+      .Times(1);
+  handler.InvalidateContext(context_a);
+  ::testing::Mock::VerifyAndClearExpectations(&change_handler);
+
+  EXPECT_CALL(
+      change_handler,
+      Run(kEventName1, binding::EventListenersChanged::NO_LISTENERS, context_b))
+      .Times(1);
+  handler.InvalidateContext(context_b);
+  ::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 = ContextLocal();
 
   const char kEventName[] = "alpha";
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
                           base::Bind(&DoNothingOnEventListenersChanged));
@@ skipping 29 matching lines @@
   std::unique_ptr<base::ListValue> event_args = ListValueFromString(kArguments);
   ASSERT_TRUE(event_args);
   handler.FireEventInContext(kEventName, context, *event_args);
 
   EXPECT_EQ(
       "[\"first\",\"second\"]",
       GetStringPropertyFromObject(context->Global(), context, "originalArgs"));
   EXPECT_EQ(
       "[\"primary\",\"secondary\"]",
       GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
+
+  handler.InvalidateContext(context);
 }
 
 // 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 = ContextLocal();
 
   const char kEventName[] = "alpha";
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
@@ skipping 46 matching lines @@
   ASSERT_TRUE(dispatch_value->IsFunction());
   v8::Local<v8::Value> dispatch_args[] = {
       V8ValueFromScriptSource(context, "['primary', 'secondary']"),
   };
   RunFunction(dispatch_value.As<v8::Function>(), context,
               arraysize(dispatch_args), dispatch_args);
 
   EXPECT_EQ(
       "[\"primary\",\"secondary\"]",
       GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
+
+  handler.InvalidateContext(context);
 }
 
 // Test registering an argument massager and never dispatching.
 TEST_F(APIEventHandlerTest, TestArgumentMassagersNeverDispatch) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   const char kEventName[] = "alpha";
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
                           base::Bind(&DoNothingOnEventListenersChanged));
@@ skipping 17 matching lines @@
   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());
 
   // 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
   // that we don't crash.)
+
+  handler.InvalidateContext(context);
 }
 
 }  // namespace extensions