Lazy creating of background pages --enable-lazy-background-pages)

chrome/browser/extensions/extension_event_router.h

 // Copyright (c) 2011 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>
 #include <string>
 
+#include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
 #include "ipc/ipc_message.h"
 
 class GURL;
 class Extension;
 class ExtensionDevToolsManager;
 class Profile;
 class RenderProcessHost;
@@ skipping 35 matching lines @@
   // normal profile only works if extension is allowed incognito access). If
   // |event_url| is not empty, the event is only sent to extension with host
   // permissions for this url.
   void DispatchEventToRenderers(
       const std::string& event_name,
       const std::string& event_args,
       Profile* restrict_to_profile,
       const GURL& event_url);
 
   // Same as above, except only send the event to the given extension.
-  void DispatchEventToExtension(
+  virtual void DispatchEventToExtension(
       const std::string& extension_id,
       const std::string& event_name,
       const std::string& event_args,
       Profile* restrict_to_profile,
       const GURL& event_url);
 
   // Send different versions of an event to extensions in different profiles.
   // This is used in the case of sending one event to extensions that have
   // incognito access, and another event to extensions that don't (here),
   // in order to avoid sending 2 events to "spanning" extensions.
   // If |cross_incognito_profile| is non-NULL and different from
   // restrict_to_profile, send the event with cross_incognito_args to the
   // extensions in that profile that can't cross incognito.
   void DispatchEventsToRenderersAcrossIncognito(
       const std::string& event_name,
       const std::string& event_args,
       Profile* restrict_to_profile,
       const std::string& cross_incognito_args,
       const GURL& event_url);
 
  protected:
+  // The details of an event to be dispatched.
+  struct ExtensionEvent;
+
   // Shared by DispatchEvent*. If |extension_id| is empty, the event is
   // broadcast.
-  virtual void DispatchEventImpl(
-      const std::string& extension_id,
-      const std::string& event_name,
-      const std::string& event_args,
-      Profile* restrict_to_profile,
-      const std::string& cross_incognito_args,
-      const GURL& event_url);
+  // An event that just came off the pending list may not be delayed again.
+  void DispatchEventImpl(const linked_ptr<ExtensionEvent>& event,
+                         bool was_pending);
+
+  // Dispatch may be delayed if the extension has a lazy background page.
+  bool CanDispatchEventNow(const std::string& extension_id);
+
+  // 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 DispatchPendingEvents(const std::string& extension_id);
 
  private:
   // An extension listening to an event.
   struct EventListener;
 
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   Profile* profile_;
 
   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_;
 
+  // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionEventRouter);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_