[Reland][Extensions Bindings] Add support for filtered 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"
 #include "base/test/mock_callback.h"
 #include "base/values.h"
+#include "extensions/common/event_filtering_info.h"
 #include "extensions/renderer/api_binding_test.h"
 #include "extensions/renderer/api_binding_test_util.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 {
 
 using MockEventChangeHandler = ::testing::StrictMock<
     base::MockCallback<APIEventHandler::EventListenersChangedMethod>>;
 
 void DoNothingOnEventListenersChanged(const std::string& event_name,
                                       binding::EventListenersChanged change,
+                                      const base::DictionaryValue* value,
                                       v8::Local<v8::Context> context) {}
 
 class APIEventHandlerTest : public APIBindingTest {
  protected:
   APIEventHandlerTest() {}
   ~APIEventHandlerTest() override {}
 
   void SetUp() override {
     APIBindingTest::SetUp();
     handler_ = base::MakeUnique<APIEventHandler>(
@@ skipping 27 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, context);
+      handler()->CreateEventInstance(kEventName, false, 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, context);
+      handler()->CreateEventInstance(kAlphaName, false, context);
   v8::Local<v8::Object> beta_event =
-      handler()->CreateEventInstance(kBetaName, context);
+      handler()->CreateEventInstance(kBetaName, false, 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 46 matching lines @@
     EXPECT_TRUE(
         gin::Converter<int32_t>::FromV8(context->GetIsolate(), res, &count))
         << name;
     return count;
   };
 
   EXPECT_EQ(0, get_fired_count("alphaCount1"));
   EXPECT_EQ(0, get_fired_count("alphaCount2"));
   EXPECT_EQ(0, get_fired_count("betaCount"));
 
-  handler()->FireEventInContext(kAlphaName, context, base::ListValue());
+  handler()->FireEventInContext(kAlphaName, context, base::ListValue(),
+                                EventFilteringInfo());
   EXPECT_EQ(2u, handler()->GetNumEventListenersForTesting(kAlphaName, context));
   EXPECT_EQ(1u, handler()->GetNumEventListenersForTesting(kBetaName, context));
 
   EXPECT_EQ(1, get_fired_count("alphaCount1"));
   EXPECT_EQ(1, get_fired_count("alphaCount2"));
   EXPECT_EQ(0, get_fired_count("betaCount"));
 
-  handler()->FireEventInContext(kAlphaName, context, base::ListValue());
+  handler()->FireEventInContext(kAlphaName, context, base::ListValue(),
+                                EventFilteringInfo());
   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());
+  handler()->FireEventInContext(kBetaName, context, base::ListValue(),
+                                EventFilteringInfo());
   EXPECT_EQ(2, get_fired_count("alphaCount1"));
   EXPECT_EQ(2, get_fired_count("alphaCount2"));
   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, context);
+      handler()->CreateEventInstance(kEventName, false, 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);
+  handler()->FireEventInContext(kEventName, context, *event_args,
+                                EventFilteringInfo());
 
   EXPECT_EQ(
       ReplaceSingleQuotes(kArguments),
       GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
 }
 
 // Test dispatching events to multiple contexts.
 TEST_F(APIEventHandlerTest, MultipleContexts) {
   v8::HandleScope handle_scope(isolate());
 
   v8::Local<v8::Context> context_a = MainContext();
   v8::Local<v8::Context> context_b = AddContext();
 
   const char kEventName[] = "onFoo";
 
 
   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, context_a);
+      handler()->CreateEventInstance(kEventName, false, context_a);
   ASSERT_FALSE(event_a.IsEmpty());
   v8::Local<v8::Object> event_b =
-      handler()->CreateEventInstance(kEventName, context_b);
+      handler()->CreateEventInstance(kEventName, false, 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 13 matching lines @@
             handler()->GetNumEventListenersForTesting(kEventName, context_a));
   EXPECT_EQ(1u,
             handler()->GetNumEventListenersForTesting(kEventName, context_b));
 
   // Dispatch the event in context_a - the listener in context_b should not be
   // notified.
   std::unique_ptr<base::ListValue> arguments_a =
       ListValueFromString("['result_a:']");
   ASSERT_TRUE(arguments_a);
 
-  handler()->FireEventInContext(kEventName, context_a, *arguments_a);
+  handler()->FireEventInContext(kEventName, context_a, *arguments_a,
+                                EventFilteringInfo());
   {
     EXPECT_EQ("\"result_a:alpha\"",
               GetStringPropertyFromObject(context_a->Global(), context_a,
                                           "eventArgs"));
   }
   {
     EXPECT_EQ("undefined", GetStringPropertyFromObject(context_b->Global(),
                                                        context_b, "eventArgs"));
   }
 
   // Dispatch the event in context_b - the listener in context_a should not be
   // notified.
   std::unique_ptr<base::ListValue> arguments_b =
       ListValueFromString("['result_b:']");
   ASSERT_TRUE(arguments_b);
-  handler()->FireEventInContext(kEventName, context_b, *arguments_b);
+  handler()->FireEventInContext(kEventName, context_b, *arguments_b,
+                                EventFilteringInfo());
   {
     EXPECT_EQ("\"result_a:alpha\"",
               GetStringPropertyFromObject(context_a->Global(), context_a,
                                           "eventArgs"));
   }
   {
     EXPECT_EQ("\"result_b:beta\"",
               GetStringPropertyFromObject(context_b->Global(), context_b,
                                           "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, context);
+      handler()->CreateEventInstance(kEventName, false, 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", context);
+      handler()->CreateEventInstance("alpha", false, 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, context);
+      handler()->CreateEventInstance(kEventName, false, 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 21 matching lines @@
       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,
             handler()->GetNumEventListenersForTesting(kEventName, context));
-  handler()->FireEventInContext(kEventName, context, base::ListValue());
+  handler()->FireEventInContext(kEventName, context, base::ListValue(),
+                                EventFilteringInfo());
   EXPECT_EQ(0u, handler()->GetNumEventListenersForTesting(kEventName, 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
@@ skipping 11 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, context);
+      handler()->CreateEventInstance(kEventName, false, 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 27 matching lines @@
   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));
 
   std::unique_ptr<base::ListValue> event_args = ListValueFromString("[42]");
   ASSERT_TRUE(event_args);
-  handler()->FireEventInContext(kEventName, context, *event_args);
+  handler()->FireEventInContext(kEventName, context, *event_args,
+                                EventFilteringInfo());
 
   // 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);
 }
 
 // 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()));
 
   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, context_a);
+      handler()->CreateEventInstance(kEventName1, false, context_a);
   ASSERT_FALSE(event1_a.IsEmpty());
   v8::Local<v8::Object> event2_a =
-      handler()->CreateEventInstance(kEventName2, context_a);
+      handler()->CreateEventInstance(kEventName2, false, context_a);
   ASSERT_FALSE(event2_a.IsEmpty());
   v8::Local<v8::Object> event1_b =
-      handler()->CreateEventInstance(kEventName1, context_b);
+      handler()->CreateEventInstance(kEventName1, false, 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,
-                    context_a))
+                    nullptr, context_a))
         .Times(1);
     v8::Local<v8::Value> argv[] = {event1_a, listener1};
     RunFunction(add_listener, context_a, arraysize(argv), argv);
     ::testing::Mock::VerifyAndClearExpectations(&change_handler);
   }
   EXPECT_EQ(1u,
             handler()->GetNumEventListenersForTesting(kEventName1, context_a));
 
   // Add a second listener to the same event. We should not be notified, since
   // the event already had listeners.
@@ skipping 16 matching lines @@
   }
 
   EXPECT_EQ(1u,
             handler()->GetNumEventListenersForTesting(kEventName1, context_a));
 
   // Remove the final listener from the event. We should be notified that the
   // event no longer has listeners.
   {
     EXPECT_CALL(change_handler,
                 Run(kEventName1, binding::EventListenersChanged::NO_LISTENERS,
-                    context_a))
+                    nullptr, context_a))
         .Times(1);
     v8::Local<v8::Value> argv[] = {event1_a, listener2};
     RunFunction(remove_listener, context_a, arraysize(argv), argv);
     ::testing::Mock::VerifyAndClearExpectations(&change_handler);
   }
   EXPECT_EQ(0u,
             handler()->GetNumEventListenersForTesting(kEventName1, context_a));
 
   // Add a listener to a separate event to ensure we receive the right
   // notifications.
   v8::Local<v8::Function> listener3 =
       FunctionFromString(context_a, "(function() {})");
   {
     EXPECT_CALL(change_handler,
                 Run(kEventName2, binding::EventListenersChanged::HAS_LISTENERS,
-                    context_a))
+                    nullptr, context_a))
         .Times(1);
     v8::Local<v8::Value> argv[] = {event2_a, listener3};
     RunFunction(add_listener, context_a, arraysize(argv), argv);
     ::testing::Mock::VerifyAndClearExpectations(&change_handler);
   }
   EXPECT_EQ(1u,
             handler()->GetNumEventListenersForTesting(kEventName2, context_a));
 
   {
     EXPECT_CALL(change_handler,
                 Run(kEventName1, binding::EventListenersChanged::HAS_LISTENERS,
-                    context_b))
+                    nullptr, context_b))
         .Times(1);
     // And add a listener to an event in a different context to make sure the
     // associated context is correct.
     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))
+  EXPECT_CALL(change_handler,
+              Run(kEventName2, binding::EventListenersChanged::NO_LISTENERS,
+                  nullptr, context_a))
       .Times(1);
   DisposeContext(context_a);
   ::testing::Mock::VerifyAndClearExpectations(&change_handler);
 
-  EXPECT_CALL(
-      change_handler,
-      Run(kEventName1, binding::EventListenersChanged::NO_LISTENERS, context_b))
+  EXPECT_CALL(change_handler,
+              Run(kEventName1, binding::EventListenersChanged::NO_LISTENERS,
+                  nullptr, context_b))
       .Times(1);
   DisposeContext(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 = MainContext();
 
   const char kEventName[] = "alpha";
   v8::Local<v8::Object> event =
-      handler()->CreateEventInstance(kEventName, context);
+      handler()->CreateEventInstance(kEventName, false, 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);
+  handler()->FireEventInContext(kEventName, context, *event_args,
+                                EventFilteringInfo());
 
   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, context);
+      handler()->CreateEventInstance(kEventName, false, 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);
+  handler()->FireEventInContext(kEventName, context, *event_args,
+                                EventFilteringInfo());
 
   // The massager should have been triggered, but since it doesn't call
   // dispatch(), the listener shouldn't have been notified.
   EXPECT_EQ(
       "[\"first\",\"second\"]",
       GetStringPropertyFromObject(context->Global(), context, "originalArgs"));
   EXPECT_EQ("undefined", GetStringPropertyFromObject(context->Global(), context,
                                                      "eventArgs"));
 
   // Dispatch the event.
@@ skipping 12 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, context);
+      handler()->CreateEventInstance(kEventName, false, 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());
+  handler()->FireEventInContext(kEventName, context, base::ListValue(),
+                                EventFilteringInfo());
 
   // 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.)
 }
 
 // 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();
@@ skipping 58 matching lines @@
       "  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);
 }
 
 }  // namespace extensions