This defers starting background extension page RenderViews

chrome/browser/extensions/extension_process_manager.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/extension_process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 119 matching lines @@
 
 // static
 ExtensionProcessManager* ExtensionProcessManager::Create(Profile* profile) {
   return (profile->IsOffTheRecord()) ?
       new IncognitoExtensionProcessManager(profile) :
       new ExtensionProcessManager(profile);
 }
 
 ExtensionProcessManager::ExtensionProcessManager(Profile* profile)
   : site_instance_(SiteInstance::Create(profile)),
+    defer_background_host_creation_(false),
     weak_ptr_factory_(this),
     devtools_callback_(base::Bind(
         &ExtensionProcessManager::OnDevToolsStateChanged,
         base::Unretained(this))) {
   Profile* original_profile = profile->GetOriginalProfile();
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<Profile>(original_profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
@@ skipping 387 matching lines @@
         new ExtensionMsg_CancelSuspend(extension->id()));
     // This increment / decrement is to simulate an instantaneous event. This
     // has the effect of invalidating close_sequence_id, preventing any in
     // progress closes from completing and starting a new close process if
     // necessary.
     IncrementLazyKeepaliveCount(extension);
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
+void ExtensionProcessManager::DeferBackgroundHostCreation(bool defer) {
+  bool previous = defer_background_host_creation_;
+  defer_background_host_creation_ = defer;
+
+  // If we were deferred, and we switch to non-deferred, then create the
+  // background hosts.
+  if (previous && !defer_background_host_creation_)
+    CreateBackgroundHostsForProfileStartup();
+}
+
 void ExtensionProcessManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
       // If a window for this profile, or this profile's incognito profile,
       // has been opened, make sure this profile's background hosts have
       // been loaded.
       Browser* browser = content::Source<Browser>(source).ptr();
       if (browser->profile() != GetProfile() &&
           !(GetProfile()->HasOffTheRecordProfile() &&
             browser->profile() == GetProfile()->GetOffTheRecordProfile()))
         break;
 
       ExtensionService* service = GetProfile()->GetExtensionService();
       if (!service || !service->is_ready())
         break;
 
       CreateBackgroundHostsForProfileStartup();
       break;
     }
     case chrome::NOTIFICATION_EXTENSIONS_READY:
     case chrome::NOTIFICATION_PROFILE_CREATED: {
-      // Don't load background hosts now if the loading should be deferred.
-      // Instead they will be loaded when a browser window for this profile
-      // (or an incognito profile from this profile) is ready.
-      if (DeferLoadingBackgroundHosts())
-        break;
-
       CreateBackgroundHostsForProfileStartup();
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       ExtensionService* service =
           extensions::ExtensionSystem::Get(profile)->extension_service();
       if (service->is_ready()) {
         const Extension* extension =
@@ skipping 105 matching lines @@
   if (attached) {
     // Keep the lazy background page alive while it's being inspected.
     CancelSuspend(extension);
     IncrementLazyKeepaliveCount(extension);
   } else {
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::CreateBackgroundHostsForProfileStartup() {
+  // Don't load background hosts now if the loading should be deferred.
+  // Instead they will be loaded when a browser window for this profile
+  // (or an incognito profile from this profile) is ready, or when
+  // DeferBackgroundHostCreation is called with false.
+  if (DeferLoadingBackgroundHosts())
+    return;
+
   ExtensionService* service = GetProfile()->GetExtensionService();
   for (ExtensionSet::const_iterator extension = service->extensions()->begin();
        extension != service->extensions()->end(); ++extension) {
     CreateBackgroundHostForExtensionLoad(this, extension->get());
 
     extensions::RuntimeEventRouter::DispatchOnStartupEvent(
         GetProfile(), (*extension)->id());
   }
 
   // Background pages should only be loaded once. To prevent any further loads
@@ skipping 57 matching lines @@
   // the lazy_keepalive_count (if any) to properly reflect the number of open
   // views.
   for (ExtensionRenderViews::const_iterator it = all_extension_views_.begin();
        it != all_extension_views_.end(); ++it) {
     if (GetExtensionID(it->first) == extension_id)
       IncrementLazyKeepaliveCountForView(it->first);
   }
 }
 
 bool ExtensionProcessManager::DeferLoadingBackgroundHosts() const {
+  // Don't load background hosts now if the loading should be deferred.
+  if (defer_background_host_creation_)
+    return true;
+
   // The profile may not be valid yet if it is still being initialized.
   // In that case, defer loading, since it depends on an initialized profile.
   // http://crbug.com/222473
   if (!g_browser_process->profile_manager()->IsValidProfile(GetProfile()))
     return true;
 
 #if defined(OS_ANDROID)
   return false;
 #else
   return chrome::GetTotalBrowserCountForProfile(GetProfile()) == 0 &&
@@ skipping 104 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup();
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }