[Reland][Extensions Bindings] Add support for filtered events

extensions/renderer/native_extension_bindings_system_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/native_extension_bindings_system.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/crx_file/id_util.h"
@@ skipping 50 matching lines @@
 
   return ExtensionBuilder()
       .SetManifest(manifest.Build())
       .SetLocation(Manifest::INTERNAL)
       .SetID(crx_file::id_util::GenerateId(name))
       .Build();
 }
 
 class EventChangeHandler {
  public:
-  MOCK_METHOD3(OnChange,
+  MOCK_METHOD4(OnChange,
                void(binding::EventListenersChanged,
                     ScriptContext*,
-                    const std::string& event_name));
+                    const std::string& event_name,
+                    const base::DictionaryValue* filter));
 };
 
 }  // namespace
 
 class NativeExtensionBindingsSystemUnittest : public APIBindingTest {
  public:
   NativeExtensionBindingsSystemUnittest() {}
   ~NativeExtensionBindingsSystemUnittest() override {}
 
  protected:
@@ skipping 38 matching lines @@
     last_params_.source_url = params.source_url;
     last_params_.request_id = params.request_id;
     last_params_.has_callback = params.has_callback;
     last_params_.user_gesture = params.user_gesture;
     last_params_.worker_thread_id = params.worker_thread_id;
     last_params_.service_worker_version_id = params.service_worker_version_id;
   }
 
   void MockSendListenerIPC(binding::EventListenersChanged changed,
                            ScriptContext* context,
-                           const std::string& event_name) {
+                           const std::string& event_name,
+                           const base::DictionaryValue* filter) {
     if (event_change_handler_)
-      event_change_handler_->OnChange(changed, context, event_name);
+      event_change_handler_->OnChange(changed, context, event_name, filter);
   }
 
   ScriptContext* CreateScriptContext(v8::Local<v8::Context> v8_context,
                                      Extension* extension,
                                      Feature::Context context_type) {
     auto script_context = base::MakeUnique<ScriptContext>(
         v8_context, nullptr, extension, context_type, extension, context_type);
     script_context->set_module_system(
         base::MakeUnique<ModuleSystem>(script_context.get(), source_map()));
     ScriptContext* raw_script_context = script_context.get();
@@ skipping 414 matching lines @@
   // Add a new event listener. We should be notified of the change.
   const char kEventName[] = "idle.onStateChanged";
   v8::Local<v8::Function> listener =
       FunctionFromString(context, "(function() {})");
   const char kAddListener[] =
       "(function(listener) {\n"
       "  chrome.idle.onStateChanged.addListener(listener);\n"
       "});";
   v8::Local<v8::Function> add_listener =
       FunctionFromString(context, kAddListener);
-  EXPECT_CALL(
-      *event_change_handler(),
-      OnChange(binding::EventListenersChanged::HAS_LISTENERS,
-               script_context,
-               kEventName)).Times(1);
+  EXPECT_CALL(*event_change_handler(),
+              OnChange(binding::EventListenersChanged::HAS_LISTENERS,
+                       script_context, kEventName, nullptr))
+      .Times(1);
   v8::Local<v8::Value> argv[] = {listener};
   RunFunction(add_listener, context, arraysize(argv), argv);
   ::testing::Mock::VerifyAndClearExpectations(event_change_handler());
 
   // Remove the event listener. We should be notified again.
   const char kRemoveListener[] =
       "(function(listener) {\n"
       "  chrome.idle.onStateChanged.removeListener(listener);\n"
       "});";
-  EXPECT_CALL(
-      *event_change_handler(),
-      OnChange(binding::EventListenersChanged::NO_LISTENERS,
-               script_context,
-               kEventName)).Times(1);
+  EXPECT_CALL(*event_change_handler(),
+              OnChange(binding::EventListenersChanged::NO_LISTENERS,
+                       script_context, kEventName, nullptr))
+      .Times(1);
   v8::Local<v8::Function> remove_listener =
       FunctionFromString(context, kRemoveListener);
   RunFunction(remove_listener, context, arraysize(argv), argv);
   ::testing::Mock::VerifyAndClearExpectations(event_change_handler());
 }
 
 TEST_F(NativeExtensionBindingsSystemUnittest,
        TestPrefixedApiEventsAndAppBinding) {
   InitEventChangeHandler();
   scoped_refptr<Extension> app = CreateExtension("foo", ItemType::PLATFORM_APP,
@@ skipping 21 matching lines @@
             gin::V8ToString(app_binding_keys));
 
   const char kUseAppRuntime[] =
       "(function() {\n"
       "  chrome.app.runtime.onLaunched.addListener(function() {});\n"
       "});";
   v8::Local<v8::Function> use_app_runtime =
       FunctionFromString(context, kUseAppRuntime);
   EXPECT_CALL(*event_change_handler(),
               OnChange(binding::EventListenersChanged::HAS_LISTENERS,
-                       script_context, "app.runtime.onLaunched"))
+                       script_context, "app.runtime.onLaunched", nullptr))
       .Times(1);
   RunFunctionOnGlobal(use_app_runtime, context, 0, nullptr);
   ::testing::Mock::VerifyAndClearExpectations(event_change_handler());
 }
 
 TEST_F(NativeExtensionBindingsSystemUnittest,
        TestPrefixedApiMethodsAndSystemBinding) {
   scoped_refptr<Extension> extension =
       CreateExtension("foo", ItemType::EXTENSION, {"system.cpu"});
   RegisterExtension(extension->id());
@@ skipping 140 matching lines @@
     EXPECT_FALSE(value_b.IsEmpty()) << property;
     EXPECT_NE(value_a, value_b) << property;
   };
 
   check_properties_inequal(context_a, context_b, "chrome");
   check_properties_inequal(context_a, context_b, "chrome.idle");
   check_properties_inequal(context_a, context_b, "chrome.idle.onStateChanged");
 }
 
 }  // namespace extensions