Force-load a lazy background page whenever an extension is enabled.

chrome/browser/extensions/event_router.cc

 // 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.
 
 #include "chrome/browser/extensions/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 47 matching lines @@
     const std::string& extension_id,
     const Version& old_version,
     bool chrome_updated) {
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return;
 
   RuntimeEventRouter::DispatchOnInstalledEvent(profile, extension_id,
                                                old_version, chrome_updated);
 }
 
+void DoNothing(extensions::ExtensionHost* host) {}
+
 }  // namespace
 
 struct EventRouter::ListenerProcess {
   content::RenderProcessHost* process;
   std::string extension_id;
 
   ListenerProcess(content::RenderProcessHost* process,
                   const std::string& extension_id)
       : process(process), extension_id(extension_id) {}
 
@@ skipping 43 matching lines @@
 EventRouter::EventRouter(Profile* profile, ExtensionPrefs* extension_prefs)
     : profile_(profile),
       listeners_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       dispatch_chrome_updated_event_(false) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<Profile>(profile_));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
+                 content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_));
 
   // NULL in unit_tests.
   if (extension_prefs) {
     // Check if registered events are up-to-date. We need to do this before
@@ skipping 458 matching lines @@
           content::Source<content::RenderProcessHost>(source).ptr();
       // Remove all event listeners associated with this renderer.
       listeners_.RemoveListenersForProcess(renderer);
       break;
     }
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       // We're done restarting Chrome after an update.
       dispatch_chrome_updated_event_ = false;
       break;
     }
+    case chrome::NOTIFICATION_EXTENSION_ENABLED: {
+      // If the extension has a lazy background page, make sure it gets loaded
+      // to register the events the extension is interested in.
+      const Extension* extension =
+          content::Details<const Extension>(details).ptr();
+      if (extension->has_lazy_background_page()) {
+        LazyBackgroundTaskQueue* queue =
+            ExtensionSystem::Get(profile_)->lazy_background_task_queue();
+        queue->AddPendingTask(profile_, extension->id(),
+                              base::Bind(&DoNothing));
+      }
+    }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       ExtensionPrefs* prefs =
           profile_->GetExtensionService()->extension_prefs();
       std::set<std::string> registered_events =
           prefs->GetRegisteredEvents(extension->id());
       listeners_.LoadUnfilteredLazyListeners(extension->id(),
                                              registered_events);
@@ skipping 70 matching lines @@
       info(info) {}
 
 Event::~Event() {}
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions