Filtered events.

chrome/browser/extensions/extension_event_router.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/extension_event_router.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 47 matching lines @@
 
   bool operator<(const ListenerProcess& that) const {
     if (process < that.process)
       return true;
     if (process == that.process && extension_id < that.extension_id)
       return true;
     return false;
   }
 };
 
-struct ExtensionEventRouter::ExtensionEvent {
-  std::string event_name;
-  std::string event_args;
-  GURL event_url;
-  Profile* restrict_to_profile;
-  std::string cross_incognito_args;
-  UserGestureState user_gesture;
-
-  ExtensionEvent(const std::string& event_name,
-                 const std::string& event_args,
-                 const GURL& event_url,
-                 Profile* restrict_to_profile,
-                 const std::string& cross_incognito_args,
-                 UserGestureState user_gesture)
-    : event_name(event_name),
-      event_args(event_args),
-      event_url(event_url),
-      restrict_to_profile(restrict_to_profile),
-      cross_incognito_args(cross_incognito_args),
-      user_gesture(user_gesture) {}
-};
-
 // static
-void ExtensionEventRouter::DispatchEvent(IPC::Message::Sender* ipc_sender,
-                                         const std::string& extension_id,
-                                         const std::string& event_name,
-                                         const std::string& event_args,
-                                         const GURL& event_url,
-                                         UserGestureState user_gesture) {
+void ExtensionEventRouter::DispatchEvent(
+    IPC::Message::Sender* ipc_sender,
+    const std::string& extension_id,
+    const std::string& event_name,
+    const std::string& event_args,
+    const GURL& event_url,
+    UserGestureState user_gesture,
+    const extensions::EventFilteringInfo& info) {
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
   args.Set(1, Value::CreateStringValue(event_args));
+  args.Set(2, Value::CreateStringValue(info.AsJSONString()));

[Aaron Boodman, 2012/06/15 07:34:51]

Can you juts pass this through as a Value? Serializing all the way to string is
kinda lame.

[koz (OOO until 15th September), 2012/06/18 23:27:27]

Done.

[Matt Perry, 2012/06/19 00:02:55]

Doesn't look like it :)

[koz (OOO until 15th September), 2012/06/19 00:11:36]

Oops, I think I forgot to upload this patch. I'm rebasing it right now and
there's a few conflicts with gdk's change along these lines, too.

Thanks for checking!

   ipc_sender->Send(new ExtensionMsg_MessageInvoke(MSG_ROUTING_CONTROL,
       extension_id, kDispatchEvent, args, event_url,
       user_gesture == USER_GESTURE_ENABLED));
 }
 
 ExtensionEventRouter::ExtensionEventRouter(Profile* profile)
     : profile_(profile),
       extension_devtools_manager_(
-          ExtensionSystem::Get(profile)->devtools_manager()) {
+          ExtensionSystem::Get(profile)->devtools_manager()),
+      listeners_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_));
 }
 
 ExtensionEventRouter::~ExtensionEventRouter() {}
 
 void ExtensionEventRouter::AddEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const std::string& extension_id) {
-  ListenerProcess listener(process, extension_id);
-  DCHECK_EQ(listeners_[event_name].count(listener), 0u) << event_name;
-  listeners_[event_name].insert(listener);
+  listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
+      event_name, extension_id, process, scoped_ptr<DictionaryValue>())));
+}
+
+void ExtensionEventRouter::RemoveEventListener(
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    const std::string& extension_id) {
+  scoped_ptr<EventListener> listener(new EventListener(
+      event_name, extension_id, process, scoped_ptr<DictionaryValue>()));
+  listeners_.RemoveListener(listener.get());
+}
+
+void ExtensionEventRouter::OnListenerAdded(const EventListener* listener) {

[Aaron Boodman, 2012/06/15 07:34:51]

Instead of the delegate interface can you just look at the return value from
AddListener()?

[koz (OOO until 15th September), 2012/06/18 23:27:27]

The delegate interface was requested by Matt, and I think it's good because it's
symmetrical with the OnListenerRemoved() code, which is called from a variety of
situations (eg: listener explicitly being removed, or a process dying).

That said, I do like the simplicity of return values over listeners, and it
would enforce an architecture that I agree with, namely ExtensionEventRouter
controls all info that goes into and out of EventListenerMap, which means that
EventListenerMap would never listen to notifications itself.

I'd probably rather stick with the delegate though. I'll change it if you still
think it's better as return values.

+  // We don't care about lazy events being added.
+  if (!listener->process)
+    return;
 
   if (extension_devtools_manager_.get())
-    extension_devtools_manager_->AddEventListener(event_name,
-                                                  process->GetID());
+    extension_devtools_manager_->AddEventListener(listener->event_name,
+                                                  listener->process->GetID());
 
   // We lazily tell the TaskManager to start updating when listeners to the
   // processes.onUpdated or processes.onUpdatedWithMemory events arrive.
+  const std::string& event_name = listener->event_name;
   if (event_name.compare(extension_processes_api_constants::kOnUpdated) == 0 ||
       event_name.compare(
           extension_processes_api_constants::kOnUpdatedWithMemory) == 0)
     ExtensionProcessesEventRouter::GetInstance()->ListenerAdded();
 }
 
-void ExtensionEventRouter::RemoveEventListener(
-    const std::string& event_name,
-    content::RenderProcessHost* process,
-    const std::string& extension_id) {
-  ListenerProcess listener(process, extension_id);
-  DCHECK_EQ(listeners_[event_name].count(listener), 1u) <<
-      " PID=" << process->GetID() << " extension=" << extension_id <<
-      " event=" << event_name;
-  listeners_[event_name].erase(listener);
-  // Note: extension_id may point to data in the now-deleted listeners_ object.
-  // Do not use.
+void ExtensionEventRouter::OnListenerRemoved(const EventListener* listener) {
+  // We don't care about lazy events being removed.
+  if (!listener->process)
+    return;
 
+  const std::string& event_name = listener->event_name;
   if (extension_devtools_manager_.get())
-    extension_devtools_manager_->RemoveEventListener(event_name,
-                                                     process->GetID());
+    extension_devtools_manager_->RemoveEventListener(
+        event_name, listener->process->GetID());
 
   // If a processes.onUpdated or processes.onUpdatedWithMemory event listener
   // is removed (or a process with one exits), then we let the extension API
   // know that it has one fewer listener.
   if (event_name.compare(extension_processes_api_constants::kOnUpdated) == 0 ||
       event_name.compare(
           extension_processes_api_constants::kOnUpdatedWithMemory) == 0)
     ExtensionProcessesEventRouter::GetInstance()->ListenerRemoved();
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &NotifyEventListenerRemovedOnIOThread,
-          profile_, listener.extension_id, event_name));
+          profile_, listener->extension_id, listener->event_name));
 }
 
 void ExtensionEventRouter::AddLazyEventListener(
     const std::string& event_name,
     const std::string& extension_id) {
-  ListenerProcess lazy_listener(NULL, extension_id);
-  bool is_new = lazy_listeners_[event_name].insert(lazy_listener).second;
+  scoped_ptr<EventListener> listener(new EventListener(
+      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
+  bool is_new = listeners_.AddListener(listener.Pass());
+
   if (is_new) {
     ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
     std::set<std::string> events = prefs->GetRegisteredEvents(extension_id);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       prefs->SetRegisteredEvents(extension_id, events);
   }
 }
 
 void ExtensionEventRouter::RemoveLazyEventListener(
     const std::string& event_name,
     const std::string& extension_id) {
-  ListenerProcess lazy_listener(NULL, extension_id);
-  bool did_exist = lazy_listeners_[event_name].erase(lazy_listener) > 0;
+  scoped_ptr<EventListener> listener(new EventListener(
+      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
+  bool did_exist = listeners_.RemoveListener(listener.get());
+
   if (did_exist) {
     ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
     std::set<std::string> events = prefs->GetRegisteredEvents(extension_id);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     prefs->SetRegisteredEvents(extension_id, events);
   }
 }
 
+void ExtensionEventRouter::AddFilteredEventListener(
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    const std::string& extension_id,
+    const base::DictionaryValue& filter,
+    bool add_lazy_listener) {
+  listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
+      event_name, extension_id, process,
+      scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
+
+  if (add_lazy_listener) {
+    bool added = listeners_.AddListener(scoped_ptr<EventListener>(
+        new EventListener(event_name, extension_id, NULL,
+        scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
+
+    if (added) {
+      ExtensionPrefs* prefs =
+          profile_->GetExtensionService()->extension_prefs();
+      prefs->AddFilterToEvent(event_name, extension_id, &filter);
+    }
+  }
+}
+
+void ExtensionEventRouter::RemoveFilteredEventListener(
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    const std::string& extension_id,
+    const base::DictionaryValue& filter,
+    bool remove_lazy_listener) {
+  scoped_ptr<EventListener> listener(new EventListener(
+        event_name, extension_id, process,
+        scoped_ptr<DictionaryValue>(filter.DeepCopy())));
+
+  listeners_.RemoveListener(listener.get());
+
+  if (remove_lazy_listener) {
+    listener->process = NULL;
+    bool removed = listeners_.RemoveListener(listener.get());
+
+    if (removed) {
+      ExtensionPrefs* prefs =
+          profile_->GetExtensionService()->extension_prefs();
+      prefs->RemoveFilterFromEvent(event_name, extension_id, &filter);
+    }
+  }
+}
+
 bool ExtensionEventRouter::HasEventListener(const std::string& event_name) {
-  return (HasEventListenerImpl(listeners_, "", event_name) ||
-          HasEventListenerImpl(lazy_listeners_, "", event_name));
+  return listeners_.HasListenerForEvent(event_name);
 }
 
 bool ExtensionEventRouter::ExtensionHasEventListener(
     const std::string& extension_id, const std::string& event_name) {
-  return (HasEventListenerImpl(listeners_, extension_id, event_name) ||
-          HasEventListenerImpl(lazy_listeners_, extension_id, event_name));
+  return listeners_.HasListenerForExtension(extension_id, event_name);
 }
 
 bool ExtensionEventRouter::HasEventListenerImpl(
     const ListenerMap& listener_map,
     const std::string& extension_id,
     const std::string& event_name) {
   ListenerMap::const_iterator it = listener_map.find(event_name);
   if (it == listener_map.end())
     return false;
 
   const std::set<ListenerProcess>& listeners = it->second;
   if (extension_id.empty())
     return !listeners.empty();
 
   for (std::set<ListenerProcess>::const_iterator listener = listeners.begin();
        listener != listeners.end(); ++listener) {
     if (listener->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 void ExtensionEventRouter::DispatchEventToRenderers(
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
-    const GURL& event_url) {
+    const GURL& event_url,
+    extensions::EventFilteringInfo info) {
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
-                         restrict_to_profile, "", USER_GESTURE_UNKNOWN));
+                         restrict_to_profile, "", USER_GESTURE_UNKNOWN, info));
   DispatchEventImpl("", event);
 }
 
 void ExtensionEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
     const GURL& event_url) {
   DCHECK(!extension_id.empty());
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
-                         restrict_to_profile, "", USER_GESTURE_UNKNOWN));
+                         restrict_to_profile, "", USER_GESTURE_UNKNOWN,
+                         EventFilteringInfo()));
   DispatchEventImpl(extension_id, event);
 }
 
 void ExtensionEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
     const GURL& event_url,
     UserGestureState user_gesture) {
   DCHECK(!extension_id.empty());
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
-                         restrict_to_profile, "", user_gesture));
+                         restrict_to_profile, "", user_gesture,
+                         EventFilteringInfo()));
   DispatchEventImpl(extension_id, event);
 }
 
 void ExtensionEventRouter::DispatchEventsToRenderersAcrossIncognito(
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
     const std::string& cross_incognito_args,
     const GURL& event_url) {
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
                          restrict_to_profile, cross_incognito_args,
-                         USER_GESTURE_UNKNOWN));
+                         USER_GESTURE_UNKNOWN, EventFilteringInfo()));
   DispatchEventImpl("", event);
 }
 
 void ExtensionEventRouter::DispatchEventImpl(
-    const std::string& extension_id,
+    const std::string& restrict_to_extension_id,
     const linked_ptr<ExtensionEvent>& event) {
   // We don't expect to get events from a completely different profile.
   DCHECK(!event->restrict_to_profile ||
          profile_->IsSameProfile(event->restrict_to_profile));
 
-  LoadLazyBackgroundPagesForEvent(extension_id, event);
-
-  ListenerMap::iterator it = listeners_.find(event->event_name);
-  if (it == listeners_.end())
-    return;
-
-  std::set<ListenerProcess>& listeners = it->second;
-  for (std::set<ListenerProcess>::iterator listener = listeners.begin();
-       listener != listeners.end(); ++listener) {
-    if (!extension_id.empty() && extension_id != listener->extension_id)
-      continue;
-
-    DispatchEventToListener(*listener, event);
+  std::set<const EventListener*> listeners(listeners_.GetEventTargets(*event));
+  for (std::set<const EventListener*>::iterator it = listeners.begin();
+       it != listeners.end(); it++) {
+    const EventListener* listener = *it;
+    if (listener->process) {
+      if (restrict_to_extension_id.empty() ||
+          restrict_to_extension_id == listener->extension_id)
+        DispatchEventToProcess(listener->extension_id, listener->process,
+                               event);
+    } else {
+      DispatchLazyEvent(listener->extension_id, event);
+    }
   }
 }
 
-void ExtensionEventRouter::DispatchEventToListener(
-    const ListenerProcess& listener,
+void ExtensionEventRouter::DispatchLazyEvent(
+    const std::string& extension_id,
+    const linked_ptr<ExtensionEvent>& event) {
+  ExtensionService* service = profile_->GetExtensionService();
+  // Check both the original and the incognito profile to see if we
+  // should load a lazy bg page to handle the event. The latter case
+  // occurs in the case of split-mode extensions.
+  const Extension* extension = service->extensions()->GetByID(extension_id);
+  if (extension) {
+    MaybeLoadLazyBackgroundPage(profile_, extension, event, extension_id);
+    if (profile_->HasOffTheRecordProfile() &&
+        extension->incognito_split_mode()) {
+      MaybeLoadLazyBackgroundPage(
+          profile_->GetOffTheRecordProfile(), extension, event, extension_id);
+    }
+  }
+}
+
+void ExtensionEventRouter::DispatchEventToProcess(
+    const std::string& extension_id,
+    content::RenderProcessHost* process,
     const linked_ptr<ExtensionEvent>& event) {
   ExtensionService* service = profile_->GetExtensionService();
   const Extension* extension = service->extensions()->GetByID(
-      listener.extension_id);
+      extension_id);
 
   // The extension could have been removed, but we do not unregister it until
   // the extension process is unloaded.
   if (!extension)
     return;
 
   Profile* listener_profile = Profile::FromBrowserContext(
-      listener.process->GetBrowserContext());
+      process->GetBrowserContext());
   extensions::ProcessMap* process_map =
       listener_profile->GetExtensionService()->process_map();
   // If the event is privileged, only send to extension processes. Otherwise,
   // it's OK to send to normal renderers (e.g., for content scripts).
   if (ExtensionAPI::GetSharedInstance()->IsPrivileged(event->event_name) &&
-      !process_map->Contains(extension->id(), listener.process->GetID())) {
+      !process_map->Contains(extension->id(), process->GetID())) {
     return;
   }
 
   const std::string* event_args;
   if (!CanDispatchEventToProfile(listener_profile, extension,
                                  event, &event_args))
     return;
 
-  DispatchEvent(listener.process, listener.extension_id,
+  DispatchEvent(process, extension_id,
                 event->event_name, *event_args,
-                event->event_url, event->user_gesture);
+                event->event_url, event->user_gesture,
+                event->info);
   IncrementInFlightEvents(listener_profile, extension);
 }
 
 bool ExtensionEventRouter::CanDispatchEventToProfile(
     Profile* profile,
     const Extension* extension,
     const linked_ptr<ExtensionEvent>& event,
     const std::string** event_args) {
   *event_args = &event->event_args;
 
   // Is this event from a different profile than the renderer (ie, an
   // incognito tab event sent to a normal process, or vice versa).
   bool cross_incognito = event->restrict_to_profile &&
       profile != event->restrict_to_profile;
   if (cross_incognito &&
       !profile->GetExtensionService()->CanCrossIncognito(extension)) {
     if (event->cross_incognito_args.empty())
       return false;
     // Send the event with different arguments to extensions that can't
     // cross incognito.
     *event_args = &event->cross_incognito_args;
   }
 
   return true;
 }
 
-void ExtensionEventRouter::LoadLazyBackgroundPagesForEvent(
-    const std::string& extension_id,
-    const linked_ptr<ExtensionEvent>& event) {
-  ExtensionService* service = profile_->GetExtensionService();
-
-  ListenerMap::iterator it = lazy_listeners_.find(event->event_name);
-  if (it == lazy_listeners_.end())
-    return;
-
-  std::set<ListenerProcess>& listeners = it->second;
-  for (std::set<ListenerProcess>::iterator listener = listeners.begin();
-       listener != listeners.end(); ++listener) {
-    if (!extension_id.empty() && extension_id != listener->extension_id)
-      continue;
-
-    // Check both the original and the incognito profile to see if we
-    // should load a lazy bg page to handle the event. The latter case
-    // occurs in the case of split-mode extensions.
-    const Extension* extension = service->extensions()->GetByID(
-        listener->extension_id);
-    if (extension) {
-      MaybeLoadLazyBackgroundPage(profile_, extension, event);
-      if (profile_->HasOffTheRecordProfile() &&
-          extension->incognito_split_mode()) {
-        MaybeLoadLazyBackgroundPage(
-            profile_->GetOffTheRecordProfile(), extension, event);
-      }
-    }
-  }
-}
-
 void ExtensionEventRouter::MaybeLoadLazyBackgroundPage(
     Profile* profile,
     const Extension* extension,
-    const linked_ptr<ExtensionEvent>& event) {
+    const linked_ptr<ExtensionEvent>& event,
+    const std::string& extension_id) {
   const std::string* event_args;
   if (!CanDispatchEventToProfile(profile, extension, event, &event_args))
     return;
 
   extensions::LazyBackgroundTaskQueue* queue =
       ExtensionSystem::Get(profile)->lazy_background_task_queue();
   if (queue->ShouldEnqueueTask(profile, extension)) {
     queue->AddPendingTask(
         profile, extension->id(),
         base::Bind(&ExtensionEventRouter::DispatchPendingEvent,
@@ skipping 20 matching lines @@
       ExtensionSystem::Get(profile)->process_manager();
   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id);
   // The event ACK is routed to the background host, so this should never be
   // NULL.
   CHECK(host);
   CHECK(host->extension()->has_lazy_background_page());
   pm->DecrementLazyKeepaliveCount(host->extension());
 }
 
 void ExtensionEventRouter::DispatchPendingEvent(
-    const linked_ptr<ExtensionEvent>& event, ExtensionHost* host) {
+    const linked_ptr<ExtensionEvent>& event,
+    ExtensionHost* host) {
   if (!host)
     return;
 
-  ListenerProcess listener(host->render_process_host(),
-                           host->extension()->id());
-  if (listeners_[event->event_name].count(listener) > 0u)
-    DispatchEventToListener(listener, event);
+  if (listeners_.HasProcessListener(host->render_process_host(),
+                                    host->extension()->id()))
+    DispatchEventToProcess(host->extension()->id(),
+                           host->render_process_host(), event);
 }
 
 void ExtensionEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       content::RenderProcessHost* renderer =
           content::Source<content::RenderProcessHost>(source).ptr();
       // Remove all event listeners associated with this renderer.
-      for (ListenerMap::iterator it = listeners_.begin();
-           it != listeners_.end(); ) {
-        ListenerMap::iterator current_it = it++;
-        for (std::set<ListenerProcess>::iterator jt =
-                 current_it->second.begin();
-             jt != current_it->second.end(); ) {
-          std::set<ListenerProcess>::iterator current_jt = jt++;
-          if (current_jt->process == renderer) {
-            RemoveEventListener(current_it->first,
-                                current_jt->process,
-                                current_jt->extension_id);
-          }
-        }
-      }
+      listeners_.RemoveListenersForProcess(renderer);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
+      ExtensionPrefs* prefs =
+          profile_->GetExtensionService()->extension_prefs();
       std::set<std::string> registered_events =
-          profile_->GetExtensionService()->extension_prefs()->
-              GetRegisteredEvents(extension->id());
-      ListenerProcess lazy_listener(NULL, extension->id());
-      for (std::set<std::string>::iterator it = registered_events.begin();
-           it != registered_events.end(); ++it) {
-        lazy_listeners_[*it].insert(lazy_listener);
-      }
+          prefs->GetRegisteredEvents(extension->id());
+      const DictionaryValue* filtered_events =
+          prefs->GetFilteredEvents(extension->id());
+      if (filtered_events)
+        listeners_.AddLazyListenersFromPreferences(extension->id(),
+                                                   registered_events,
+                                                   *filtered_events);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       // Remove all registered lazy listeners from our cache.
       extensions::UnloadedExtensionInfo* unloaded =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
-      ListenerProcess lazy_listener(NULL, unloaded->extension->id());
-      for (ListenerMap::iterator it = lazy_listeners_.begin();
-           it != lazy_listeners_.end(); ++it) {
-        it->second.erase(lazy_listener);
-      }
+      listeners_.RemoveLazyListenersFor(unloaded->extension->id());
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       // Dispatch the onInstalled event.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(&extensions::RuntimeEventRouter::DispatchOnInstalledEvent,
                      profile_, extension->id()));
       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }
+
+ExtensionEvent::ExtensionEvent(
+    const std::string& event_name,
+    const std::string& event_args,
+    const GURL& event_url,
+    Profile* restrict_to_profile,
+    const std::string& cross_incognito_args,
+    ExtensionEventRouter::UserGestureState user_gesture,
+    const extensions::EventFilteringInfo& info)
+    : event_name(event_name),
+      event_args(event_args),
+      event_url(event_url),
+      restrict_to_profile(restrict_to_profile),
+      cross_incognito_args(cross_incognito_args),
+      user_gesture(user_gesture),
+      info(info) {
+}
+
+ExtensionEvent::~ExtensionEvent() {
+}