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 "base/task.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 34 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 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 ExtensionEvent& pending_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_;
 
+  ScopedRunnableMethodFactory<ExtensionEventRouter> task_factory_;

[Matt Perry, 2011/08/26 00:13:00]

You don't need a task factory in this case. The purpose of the task factory is
to delete all tasks when it goes out of scope (i.e. the ExtensionEventRouter is
deleted). But since your tasks are owned and run manually by the event router
itself, there is no danger of them running after the event router is deleted.

[Matt Perry, 2011/08/26 00:13:00]

And actually, since you're only using the Tasks for a single purpose, it might
be cleaner just to keep a list of pending ExtensionEvents instead of generic
Tasks.

I know Aaron suggested using Tasks so it can be a generic "thing to do when bg
page is ready", but if we want to do that, I think the pending task list belongs
on the ExtensionProcessManager instead. Then different consumers can schedule
different tasks. The event router will only ever schedule pending events.

(Note if you go that route, you will need the task_factory again, since the EPM
will own the tasks and could outlive the event router)

[Tessa MacDuff, 2011/08/26 01:12:53]

Thanks for explaining task factories.

I think adding a task list to ExtensionProcessManager would be borderline
over-engineering since we don't actually have a use case yet.  I'll just change
this to use ExtensionEvents and leave a comment about perhaps doing something
more general with a task list in ExtensionProcessManager.  Unless Aaron objects?

+
   // 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 tasks pending
+  // the load of it's background page.
+  typedef std::vector<linked_ptr<Task> > PendingTasksList;
+  typedef std::map<std::string,
+                   linked_ptr<PendingTasksList> > PendingTasksPerExtMap;
+  PendingTasksPerExtMap pending_tasks_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionEventRouter);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_