Refactor code that defers extension background page loading

extensions/browser/process_manager.cc

 // Copyright 2013 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 "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 209 matching lines @@
 }
 
 ProcessManager::ProcessManager(BrowserContext* context,
                                BrowserContext* original_context)
   : site_instance_(SiteInstance::Create(context)),
     startup_background_hosts_created_(false),
     devtools_callback_(base::Bind(
         &ProcessManager::OnDevToolsStateChanged,
         base::Unretained(this))),
     weak_ptr_factory_(this) {
+  LOG(ERROR) << "JAMES new ProcessManager";
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
@@ skipping 368 matching lines @@
     // 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 ProcessManager::OnBrowserWindowReady() {
+  LOG(ERROR) << "JAMES OnBrowserWindowReady";
   // If the extension system isn't ready yet the background hosts will be
   // created via NOTIFICATION_EXTENSIONS_READY below.
   ExtensionSystem* system = ExtensionSystem::Get(GetBrowserContext());
   if (!system->ready().is_signaled())
     return;
 
-  CreateBackgroundHostsForProfileStartup();
+  MaybeCreateBackgroundHostsForStartup();
 }
 
 content::BrowserContext* ProcessManager::GetBrowserContext() const {
   return site_instance_->GetBrowserContext();
 }
 
 void ProcessManager::SetKeepaliveImpulseCallbackForTesting(
     const ImpulseCallbackForTesting& callback) {
   keepalive_impulse_callback_for_testing_ = callback;
 }
 
 void ProcessManager::SetKeepaliveImpulseDecrementCallbackForTesting(
     const ImpulseCallbackForTesting& callback) {
   keepalive_impulse_decrement_callback_for_testing_ = callback;
 }
 
 void ProcessManager::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     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;
+      if (type == chrome::NOTIFICATION_EXTENSIONS_READY)
+        LOG(ERROR) << "JAMES got extensions_ready";
+      else
+        LOG(ERROR) << "JAMES got profile_created";
 
-      CreateBackgroundHostsForProfileStartup();
+      MaybeCreateBackgroundHostsForStartup();
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
       BrowserContext* context = content::Source<BrowserContext>(source).ptr();
       ExtensionSystem* system = ExtensionSystem::Get(context);
       if (system->ready().is_signaled()) {
         // The extension system is ready, so create the background host.
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
@@ skipping 71 matching lines @@
       // RegisterRenderViewHost is called too early (before the process is
       // available), so we need to wait until now to notify.
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
           content::Source<BrowserContext>(GetBrowserContext()),
           content::Details<RenderViewHost>(contents->GetRenderViewHost()));
       break;
     }
 
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
+      LOG(ERROR) << "JAMES got profile_destroyed";
       // Close background hosts when the last browser is closed so that they
       // have time to shutdown various objects on different threads. Our
       // destructor is called too late in the shutdown sequence.
       CloseBackgroundHosts();
       break;
     }
 
     default:
       NOTREACHED();
   }
@@ skipping 16 matching lines @@
     return;
   if (attached) {
     // Keep the lazy background page alive while it's being inspected.
     CancelSuspend(extension);
     IncrementLazyKeepaliveCount(extension);
   } else {
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
-void ProcessManager::CreateBackgroundHostsForProfileStartup() {
-  if (startup_background_hosts_created_ ||
-      !ExtensionsBrowserClient::Get()->
-          IsBackgroundPageAllowed(GetBrowserContext())) {
+void ProcessManager::MaybeCreateBackgroundHostsForStartup() {
+  if (startup_background_hosts_created_)
     return;
-  }
+
+  // The embedder might want to defer background page loading. For example,
+  // Chrome defers background page loading when it is launched to show the app
+  // list, then triggers a load later via OnBrowserWindowReady().
+  if (ExtensionsBrowserClient::Get()->DeferLoadingBackgroundHosts(
+          GetBrowserContext()))
+    return;
 
   const ExtensionSet& enabled_extensions =
       ExtensionRegistry::Get(GetBrowserContext())->enabled_extensions();
   for (ExtensionSet::const_iterator extension = enabled_extensions.begin();
        extension != enabled_extensions.end();
        ++extension) {
     CreateBackgroundHostForExtensionLoad(this, extension->get());
 
     FOR_EACH_OBSERVER(ProcessManagerObserver,
                       observer_list_,
@@ skipping 134 matching lines @@
     const Extension* extension =
         registry->enabled_extensions().GetExtensionOrAppByURL(url);
     if (extension && !IncognitoInfo::IsSplitMode(extension)) {
       return original_manager_->GetSiteInstanceForURL(url);
     }
   }
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions