Unrevert again r119770 - "Event pages: remember events that the page registered for,""

chrome/browser/extensions/extension_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_EXTENSION_EVENT_ROUTER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 32 matching lines @@
   // 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 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);
+
   // Returns true if there is at least one listener for the given event.
   bool HasEventListener(const std::string& event_name);
 
   // Returns true if the extension is listening to the given event.
   bool ExtensionHasEventListener(const std::string& extension_id,
                                  const std::string& event_name);
 
   // Send an event to every registered extension renderer. If
   // |restrict_to_profile| is non-NULL, then the event will not be sent to other
   // profiles unless the extension has permission (e.g. incognito tab update ->
@@ skipping 35 matching lines @@
   // the renderer.
   bool HasInFlightEvents(const std::string& extension_id);
 
  protected:
   // The details of an event to be dispatched.
   struct ExtensionEvent;
 
   // Shared by DispatchEvent*. If |extension_id| is empty, the event is
   // broadcast.
   // An event that just came off the pending list may not be delayed again.
-  void DispatchEventImpl(const linked_ptr<ExtensionEvent>& event,
+  void DispatchEventImpl(const std::string& extension_id,
+                         const linked_ptr<ExtensionEvent>& event,
                          bool was_pending);
 
+  // Ensures that all non-persistent background pages that are interested in the
+  // given event are loaded, and queues the event if the page is not ready yet.
+  // If |extension_id| is non-empty, we load only that extension's page
+  // (assuming it is interested in the event).
+  void LoadLazyBackgroundPagesForEvent(
+      const std::string& extension_id,
+      const linked_ptr<ExtensionEvent>& event);
+
   // Dispatch may be delayed if the extension has a lazy background page.
-  bool CanDispatchEventNow(const std::string& extension_id);
+  bool CanDispatchEventNow(const Extension* extension);
 
   // Store the event so that it can be dispatched (in order received)
   // when the background page is done loading.
-  void AppendEvent(const linked_ptr<ExtensionEvent>& event);
+  void AppendEvent(const std::string& extension_id,
+                   const linked_ptr<ExtensionEvent>& event);
   void DispatchPendingEvents(const std::string& extension_id);
 
  private:
   // An extension listening to an event.
   struct EventListener;
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   Profile* profile_;
 
   content::NotificationRegistrar registrar_;
 
   scoped_refptr<ExtensionDevToolsManager> extension_devtools_manager_;
 
   // A map between an event name and a set of extensions that are listening
   // to that event.
   typedef std::map<std::string, std::set<EventListener> > ListenerMap;
   ListenerMap listeners_;
 
+  // Keeps track of all the non-persistent background pages that are listening
+  // to events.
+  // TODO(mpcomplete): save to disk.
+  ListenerMap lazy_listeners_;
+
   // A map between an extension id and the queue of events pending
   // the load of it's background page.
   typedef std::vector<linked_ptr<ExtensionEvent> > PendingEventsList;
   typedef std::map<std::string,
                    linked_ptr<PendingEventsList> > PendingEventsPerExtMap;
   PendingEventsPerExtMap pending_events_;
 
   // Track of the number of dispatched events that have not yet sent an
   // ACK from the renderer.
   void IncrementInFlightEvents(const Extension* extension);
   std::map<std::string, int> in_flight_events_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionEventRouter);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_