[Extensions] Pass EventFilteringInfo directly in DispatchEvent message

extensions/renderer/dispatcher.cc

 // Copyright 2014 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/dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 643 matching lines @@
   // |frame_helper| and |render_frame| might be dead by now.
 }
 
 void Dispatcher::OnExtensionResponse(int request_id,
                                      bool success,
                                      const base::ListValue& response,
                                      const std::string& error) {
   bindings_system_->HandleResponse(request_id, success, response, error);
 }
 
-void Dispatcher::DispatchEvent(
-    const std::string& extension_id,
-    const std::string& event_name,
-    const base::ListValue& event_args,
-    const base::DictionaryValue& filtering_info) const {
+void Dispatcher::DispatchEvent(const std::string& extension_id,
+                               const std::string& event_name,
+                               const base::ListValue& event_args,
+                               const EventFilteringInfo& filtering_info) const {
   script_context_set_->ForEach(
       extension_id, nullptr,
       base::Bind(&ExtensionBindingsSystem::DispatchEventInContext,
                  base::Unretained(bindings_system_.get()), event_name,
                  &event_args, &filtering_info));
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch.
   // TODO(devlin): It's likely this is totally wrong. See
   // https://groups.google.com/a/chromium.org/forum/#!msg/scheduler-dev/iTRVbcmmpAs/pfqyUyEeAAAJ
@@ skipping 320 matching lines @@
                                      extension_id);
   }
 
   InitOriginPermissions(extension);
 
   UpdateActiveExtensions();
 }
 
 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   DispatchEvent(extension_id, kOnSuspendCanceledEvent, base::ListValue(),
-                base::DictionaryValue());
+                EventFilteringInfo());
 }
 
 void Dispatcher::OnDeliverMessage(const PortId& target_port_id,
                                   const Message& message) {
   MessagingBindings::DeliverMessage(*script_context_set_, target_port_id,
                                     message,
                                     NULL);  // All render frames.
 }
 
 void Dispatcher::OnDispatchOnConnect(
@@ skipping 128 matching lines @@
       new ExtensionHostMsg_ShouldSuspendAck(extension_id, sequence_id));
 }
 
 void Dispatcher::OnSuspend(const std::string& extension_id) {
   // Dispatch the suspend event. This doesn't go through the standard event
   // dispatch machinery because it requires special handling. We need to let
   // the browser know when we are starting and stopping the event dispatch, so
   // that it still considers the extension idle despite any activity the suspend
   // event creates.
   DispatchEvent(extension_id, kOnSuspendEvent, base::ListValue(),
-                base::DictionaryValue());
+                EventFilteringInfo());
   RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id));
 }
 
 void Dispatcher::OnTransferBlobs(const std::vector<std::string>& blob_uuids) {
   RenderThread::Get()->Send(new ExtensionHostMsg_TransferBlobsAck(blob_uuids));
 }
 
 void Dispatcher::OnUnloaded(const std::string& id) {
   // See comment in OnLoaded for why it would be nice, but perhaps incorrect,
   // to CHECK here rather than guarding.
@@ skipping 322 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions