WIP: diff which plumbs through the event URL.

extensions/browser/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 "extensions/browser/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 170 matching lines @@
                  content::Source<BrowserContext>(browser_context_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<BrowserContext>(browser_context_));
 }
 
 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);
+}
 
 void EventRouter::RegisterObserver(Observer* observer,
                                    const std::string& event_name) {
   // Observing sub-event names like "foo.onBar/123" is not allowed.
   DCHECK(event_name.find('/') == std::string::npos);
   observers_[event_name] = observer;
 }
 
 void EventRouter::UnregisterObserver(Observer* observer) {
   std::vector<ObserverMap::iterator> iters_to_remove;
   for (ObserverMap::iterator iter = observers_.begin();
        iter != observers_.end(); ++iter) {
     if (iter->second == observer)
       iters_to_remove.push_back(iter);
   }
   for (size_t i = 0; i < iters_to_remove.size(); ++i)
     observers_.erase(iters_to_remove[i]);
 }
 
 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);
   if (observer != observers_.end())
     observer->second->OnListenerAdded(details);
 }
 
 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);
   if (observer != observers_.end())
     observer->second->OnListenerRemoved(details);
 }
 
 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) {
     std::set<std::string> events = GetRegisteredEvents(extension_id);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       SetRegisteredEvents(extension_id, events);
   }
 }
 
 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) {
     std::set<std::string> events = GetRegisteredEvents(extension_id);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::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,
+      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);
   }
 }
 
 void EventRouter::RemoveFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     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);
 
   if (remove_lazy_listener) {
     listener.MakeLazy();
     bool removed = listeners_.RemoveListener(&listener);
 
     if (removed)
       RemoveFilterFromEvent(event_name, extension_id, &filter);
@@ skipping 159 matching lines @@
 
   for (std::set<const EventListener*>::iterator it = listeners.begin();
        it != listeners.end(); it++) {
     const EventListener* listener = *it;
     if (restrict_to_extension_id.empty() ||
         restrict_to_extension_id == listener->extension_id()) {
       if (listener->process()) {
         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);
         }
       }
     }
   }
 }
 
 void EventRouter::DispatchLazyEvent(
     const std::string& extension_id,
     const linked_ptr<Event>& event,
     std::set<EventDispatchIdentifier>* already_dispatched) {
@@ skipping 18 matching lines @@
         browser_client->GetOffTheRecordContext(browser_context_);
     if (MaybeLoadLazyBackgroundPageToDispatchEvent(
             incognito_context, extension, event)) {
       already_dispatched->insert(
           std::make_pair(incognito_context, extension_id));
     }
   }
 }
 
 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();
   ProcessMap* process_map = ProcessMap::Get(listener_context);
 
   const Extension* extension =
       ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
           extension_id);
   // NOTE: |extension| being NULL does not necessarily imply that this event
   // shouldn't be dispatched. Events can be dispatched to WebUI as well.
@@ skipping 25 matching lines @@
       return;
     }
 
     if (!CanDispatchEventToBrowserContext(listener_context, extension, event)) {
       return;
     }
   } else if (content::ChildProcessSecurityPolicy::GetInstance()
                  ->HasWebUIBindings(process->GetID())) {
     // Dispatching event to WebUI.
     if (!ExtensionAPI::GetSharedInstance()->IsAvailableToWebUI(
-            event->event_name)) {
+            event->event_name, listener_url)) {
       return;
     }
   } else {
     // Dispatching event to a webpage - however, all such events (e.g.
     // messaging) don't go through EventRouter so this should be impossible.
     return;
   }
 
   if (!event->will_dispatch_callback.is_null()) {
     event->will_dispatch_callback.Run(
@@ skipping 113 matching lines @@
     pm->DecrementLazyKeepaliveCount(host->extension());
 }
 
 void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
                                        ExtensionHost* host) {
   if (!host)
     return;
 
   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);
   }
 }
 
 void EventRouter::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 =
@@ skipping 87 matching lines @@
                           restrict_to_browser_context,
                           event_url,
                           user_gesture,
                           filter_info);
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 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