WIP: diff which plumbs through the event URL.

extensions/browser/event_router.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 #define EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 75 matching lines @@
                             scoped_ptr<base::ListValue> event_args,
                             UserGestureState user_gesture,
                             const EventFilteringInfo& info);
 
   // An EventRouter is shared between |browser_context| and its associated
   // incognito context. |extension_prefs| may be NULL in tests.
   EventRouter(content::BrowserContext* browser_context,
               ExtensionPrefs* extension_prefs);
   virtual ~EventRouter();
 
-  // Add or remove the process/extension pair as a listener for |event_name|.
+  // Add or remove a listener for |event_name| given the listener's
+  // |extension_id| and/or |listener_url|.
+  //
   // Note that multiple extensions can share a process due to process
   // collapsing. Also, a single extension can have 2 processes if it is a split
   // mode extension.
   void AddEventListener(const std::string& event_name,
                         content::RenderProcessHost* process,
                         const std::string& extension_id);
   void RemoveEventListener(const std::string& event_name,
                            content::RenderProcessHost* process,
                            const std::string& extension_id);
 
+  // Add or remove a listener for |event_name| given the listener's
+  // URL. TODO better comment.
+  void AddEventListenerForURL(const std::string& event_name,
+                              content::RenderProcessHost* process,
+                              const GURL& listener_url);
+  void RemoveEventListenerForURL(const std::string& event_name,
+                                 content::RenderProcessHost* process,
+                                 const GURL& listener_url);
+
   EventListenerMap& listeners() { return listeners_; }
 
   // Registers an observer to be notified when an event listener for
   // |event_name| is added or removed. There can currently be only one observer
   // for each distinct |event_name|.
   void RegisterObserver(Observer* observer,
                         const std::string& event_name);
 
   // Unregisters an observer from all events.
   void UnregisterObserver(Observer* observer);
@@ skipping 99 matching lines @@
   // Ensures that all lazy background pages that are interested in the given
   // event are loaded, and queues the event if the page is not ready yet.
   // Inserts an EventDispatchIdentifier into |already_dispatched| for each lazy
   // event dispatch that is queued.
   void DispatchLazyEvent(const std::string& extension_id,
                          const linked_ptr<Event>& event,
                          std::set<EventDispatchIdentifier>* already_dispatched);
 
   // Dispatches the event to the specified extension running in |process|.
   void DispatchEventToProcess(const std::string& extension_id,
+                              const GURL& listener_url,
                               content::RenderProcessHost* process,
                               const linked_ptr<Event>& event);
 
   // Returns false when the event is scoped to a context and the listening
   // extension does not have access to events from that context. Also fills
   // |event_args| with the proper arguments to send, which may differ if
   // the event crosses the incognito boundary.
   bool CanDispatchEventToBrowserContext(content::BrowserContext* context,
                                         const Extension* extension,
                                         const linked_ptr<Event>& event);
@@ skipping 114 matching lines @@
   ~Event();
 
   // Makes a deep copy of this instance. Ownership is transferred to the
   // caller.
   Event* DeepCopy();
 };
 
 struct EventListenerInfo {
   EventListenerInfo(const std::string& event_name,
                     const std::string& extension_id,
+                    const GURL& listener_url,
                     content::BrowserContext* browser_context);
   // The event name including any sub-event, e.g. "runtime.onStartup" or
   // "webRequest.onCompleted/123".
   const std::string event_name;
 
   const std::string extension_id;
+  const GURL listener_url;
   content::BrowserContext* browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_