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>
@@ skipping 71 matching lines @@
   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:
   // Shared by DispatchEvent*. If |extension_id| is empty, the event is
   // broadcast.
+  // Eventually DispatchEventImpl will be called, but it may be delayed
+  // sif the extension has a lazy background page.
+  void MaybeDispatchEventImpl(
+      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);
   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);
 
+  // Store the event and dispatch it when the background page is done loading.
+  void EnqueueEvent(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);
+  void DispatchPendingEvents(const std::string& extension_id);
+  void ClearPendingEvents(const std::string& extension_id);
+
  private:
   // An extension listening to an event.
   struct EventListener;
 
+  // An event that is waiting to be dispatched.
+  struct PendingEvent;
+
   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<PendingEvent> PendingEventsQueue;

[Aaron Boodman, 2011/08/18 19:25:55]

You can use std::queue.

[Tessa MacDuff, 2011/08/18 20:49:39]

Yeah, I just thought it was overkill since I never actually pop things off the
queue (I just iterate through it all at once and then delete the whole thing). 
I'm happy to update the rest of the code so that I don't act like it's a queue
(i.e. AppendEvent() instead of EnqueueEvent()).

[Aaron Boodman, 2011/08/18 21:19:23]

ok.

[Tessa MacDuff, 2011/08/23 18:18:42]

Done.

+  std::map<std::string, PendingEventsQueue> pending_events_;

[Aaron Boodman, 2011/08/18 19:25:55]

Nit: this is a bit inefficient because as these maps and vectors resize there
will be a lot of copying.

You can use base/linked_ptr.h, and make it like:

std::vector<linked_ptr<PendingEvent> >
std::map<std::string, linked_ptr<PendingEventsQueue> >

The linked_ptr will manage the lifetime automatically. There's other examples in
Chrome of this usage you can look for examples.

[Tessa MacDuff, 2011/08/23 18:18:42]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(ExtensionEventRouter);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_