Lazy initialization for ProcessesEventRouter.

chrome/browser/extensions/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 CHROME_BROWSER_EXTENSIONS_EVENT_ROUTER_H_
 #define CHROME_BROWSER_EXTENSIONS_EVENT_ROUTER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 29 matching lines @@
                     public EventListenerMap::Delegate {
  public:
   // These constants convey the state of our knowledge of whether we're in
   // a user-caused gesture as part of DispatchEvent.
   enum UserGestureState {
     USER_GESTURE_UNKNOWN = 0,
     USER_GESTURE_ENABLED = 1,
     USER_GESTURE_NOT_ENABLED = 2,
   };
 
+  // Observers register interest in events with a particular name and are
+  // notified when a listener is added or removed for that |event_name|.
+  class Observer {
+   public:
+    // Called when a listener is added.
+    virtual void OnListenerAdded(const std::string& event_name) {}
+    // Called when a listener is removed.
+    virtual void OnListenerRemoved(const std::string& event_name) {}
+  };
+
   // Sends an event via ipc_sender to the given extension. Can be called on any
   // thread.
   static void DispatchEvent(IPC::Sender* ipc_sender,
                             const std::string& extension_id,
                             const std::string& event_name,
                             scoped_ptr<base::ListValue> event_args,
                             const GURL& event_url,
                             UserGestureState user_gesture,
                             const EventFilteringInfo& info);
 
   EventRouter(Profile* profile, ExtensionPrefs* extension_prefs);
   virtual ~EventRouter();
 
   // Add or remove the process/extension pair as a listener for |event_name|.
   // 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);
 
   EventListenerMap& listeners() { return listeners_; }
 
+  // Registers an observer, interested in listeners that receive the event
+  // |event_name|, to be notified when such a listener is added or removed.
+  // There can currently be only one observer for each distinct |event_name|.
+  void RegisterObserver(Observer* observer,

[Aaron Boodman, 2012/11/07 04:08:20]

Do we not need an UnregisterObserver? And if so, I wonder if we need something
like base/observer_list.h but in map form so that we can remove during
iteration.

[Yoyo Zhou, 2012/11/07 22:53:36]

After thinking about this, I do think UnregisterObserver is a good idea. I'll
make it of the form UnregisterObserver(observer) to unregister from all events.

Actually, I originally wanted to only support the use case of starting up event
routers lazily, so that the observers would get removed once OnListenerAdded was
fired the first time, but that turns out not to be enough. But for that case,
the goop class should unregister itself.

And yeah, ObserverList doesn't fit because it's not a map.

+                        const std::string& event_name);
+
   // Add or remove the extension as having a lazy background page that listens
   // to the event. The difference from the above methods is that these will be
   // remembered even after the process goes away. We use this list to decide
   // which extension pages to load when dispatching an event.
   void AddLazyEventListener(const std::string& event_name,
                             const std::string& extension_id);
   void RemoveLazyEventListener(const std::string& event_name,
                                const std::string& extension_id);
 
   // If |add_lazy_listener| is true also add the lazy version of this listener.
@@ skipping 160 matching lines @@
   virtual void OnListenerRemoved(const EventListener* listener) OVERRIDE;
 
   Profile* profile_;
 
   content::NotificationRegistrar registrar_;
 
   scoped_refptr<ExtensionDevToolsManager> extension_devtools_manager_;
 
   EventListenerMap listeners_;
 
+  typedef std::map<std::string, Observer*> ObserverMap;
+  ObserverMap observers_;
+
   // True if we should dispatch the event signalling that Chrome was updated
   // upon loading an extension.
   bool dispatch_chrome_updated_event_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRouter);
 };
 
 struct Event {
   std::string event_name;
   scoped_ptr<base::ListValue> event_args;
@@ skipping 17 matching lines @@
         Profile* restrict_to_profile,
         EventRouter::UserGestureState user_gesture,
         const EventFilteringInfo& info);
 
   ~Event();
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EVENT_ROUTER_H_