WIP: diff which plumbs through the event URL.

extensions/browser/event_router.cc

Index: extensions/browser/event_router.cc
diff --git a/extensions/browser/event_router.cc b/extensions/browser/event_router.cc
index d9b801e63df21766e519a7b0863865855cdc6ffa..e61f80b4eac1a8a55fd26d0d933962af0a13e757 100644
--- a/extensions/browser/event_router.cc
+++ b/extensions/browser/event_router.cc
@@ -188,14 +188,43 @@ EventRouter::~EventRouter() {}
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
-  listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
-      event_name, extension_id, process, scoped_ptr<DictionaryValue>())));
+  listeners_.AddListener(scoped_ptr<EventListener>(
+      new EventListener(event_name,
+                        extension_id,
+                        GURL(),  // listener_url
+                        process,
+                        scoped_ptr<DictionaryValue>())));
 }
 
 void EventRouter::RemoveEventListener(const std::string& event_name,
                                       content::RenderProcessHost* process,
                                       const std::string& extension_id) {
-  EventListener listener(event_name, extension_id, process,
+  EventListener listener(event_name,
+                         extension_id,
+                         GURL(),  // listener_url
+                         process,
+                         scoped_ptr<DictionaryValue>());
+  listeners_.RemoveListener(&listener);
+}
+
+void EventRouter::AddEventListenerForURL(const std::string& event_name,
+                                         content::RenderProcessHost* process,
+                                         const GURL& listener_url) {
+  listeners_.AddListener(scoped_ptr<EventListener>(
+      new EventListener(event_name,
+                        "",  // extension_id
+                        listener_url,
+                        process,
+                        scoped_ptr<DictionaryValue>())));
+}
+
+void EventRouter::RemoveEventListenerForURL(const std::string& event_name,
+                                            content::RenderProcessHost* process,
+                                            const GURL& listener_url) {
+  EventListener listener(event_name,
+                         "",  // extension_id
+                         listener_url,
+                         process,
                          scoped_ptr<DictionaryValue>());
   listeners_.RemoveListener(&listener);
 }
@@ -221,6 +250,7 @@ void EventRouter::UnregisterObserver(Observer* observer) {
 void EventRouter::OnListenerAdded(const EventListener* listener) {
   const EventListenerInfo details(listener->event_name(),
                                   listener->extension_id(),
+                                  listener->listener_url(),
                                   listener->GetBrowserContext());
   std::string base_event_name = GetBaseEventName(listener->event_name());
   ObserverMap::iterator observer = observers_.find(base_event_name);
@@ -231,6 +261,7 @@ void EventRouter::OnListenerAdded(const EventListener* listener) {
 void EventRouter::OnListenerRemoved(const EventListener* listener) {
   const EventListenerInfo details(listener->event_name(),
                                   listener->extension_id(),
+                                  listener->listener_url(),
                                   listener->GetBrowserContext());
   std::string base_event_name = GetBaseEventName(listener->event_name());
   ObserverMap::iterator observer = observers_.find(base_event_name);
@@ -241,7 +272,7 @@ void EventRouter::OnListenerRemoved(const EventListener* listener) {
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   scoped_ptr<EventListener> listener(new EventListener(
-      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
+      event_name, extension_id, GURL(), NULL, scoped_ptr<DictionaryValue>()));
   bool is_new = listeners_.AddListener(listener.Pass());
 
   if (is_new) {
@@ -254,8 +285,8 @@ void EventRouter::AddLazyEventListener(const std::string& event_name,
 
 void EventRouter::RemoveLazyEventListener(const std::string& event_name,
                                           const std::string& extension_id) {
-  EventListener listener(event_name, extension_id, NULL,
-                         scoped_ptr<DictionaryValue>());
+  EventListener listener(
+      event_name, extension_id, GURL(), NULL, scoped_ptr<DictionaryValue>());
   bool did_exist = listeners_.RemoveListener(&listener);
 
   if (did_exist) {
@@ -272,13 +303,19 @@ void EventRouter::AddFilteredEventListener(const std::string& event_name,
                                            const base::DictionaryValue& filter,
                                            bool add_lazy_listener) {
   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
-      event_name, extension_id, process,
+      event_name,
+      extension_id,
+      GURL(),  // TODO(kalman): pass through URL from filtered events
+      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()))));
+        new EventListener(event_name,
+                          extension_id,
+                          GURL(),  // URL is irrelevant for lazy listeners.
+                          NULL,
+                          scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 
     if (added)
       AddFilterToEvent(event_name, extension_id, &filter);
@@ -291,7 +328,10 @@ void EventRouter::RemoveFilteredEventListener(
     const std::string& extension_id,
     const base::DictionaryValue& filter,
     bool remove_lazy_listener) {
-  EventListener listener(event_name, extension_id, process,
+  EventListener listener(event_name,
+                         extension_id,
+                         GURL(),  // TODO(kalman): URLs for filtered events
+                         process,
                          scoped_ptr<DictionaryValue>(filter.DeepCopy()));
 
   listeners_.RemoveListener(&listener);
@@ -471,8 +511,10 @@ void EventRouter::DispatchEventImpl(const std::string& restrict_to_extension_id,
         EventDispatchIdentifier dispatch_id(listener->GetBrowserContext(),
                                             listener->extension_id());
         if (!ContainsKey(already_dispatched, dispatch_id)) {
-          DispatchEventToProcess(
-              listener->extension_id(), listener->process(), event);
+          DispatchEventToProcess(listener->extension_id(),
+                                 listener->listener_url(),
+                                 listener->process(),
+                                 event);
         }
       }
     }
@@ -511,6 +553,7 @@ void EventRouter::DispatchLazyEvent(
 }
 
 void EventRouter::DispatchEventToProcess(const std::string& extension_id,
+                                         const GURL& listener_url,
                                          content::RenderProcessHost* process,
                                          const linked_ptr<Event>& event) {
   BrowserContext* listener_context = process->GetBrowserContext();
@@ -556,7 +599,7 @@ void EventRouter::DispatchEventToProcess(const std::string& extension_id,
                  ->HasWebUIBindings(process->GetID())) {
     // Dispatching event to WebUI.
     if (!ExtensionAPI::GetSharedInstance()->IsAvailableToWebUI(
-            event->event_name)) {
+            event->event_name, listener_url)) {
       return;
     }
   } else {
@@ -690,8 +733,8 @@ void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
 
   if (listeners_.HasProcessListener(host->render_process_host(),
                                     host->extension()->id())) {
-    DispatchEventToProcess(host->extension()->id(),
-                           host->render_process_host(), event);
+    DispatchEventToProcess(
+        host->extension()->id(), GURL(), host->render_process_host(), event);
   }
 }
 
@@ -799,9 +842,12 @@ Event* Event::DeepCopy() {
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id,
+                                     const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
-      browser_context(browser_context) {}
+      listener_url(listener_url),
+      browser_context(browser_context) {
+}
 
 }  // namespace extensions