Reland: 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 15 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/process_manager_delegate.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/one_shot_event.h"
 #include "extensions/common/switches.h"
 
@@ skipping 52 matching lines @@
       content::Details<RenderViewHost>(render_view_host));
 }
 
 // Incognito profiles use this process manager. It is mostly a shim that decides
 // whether to fall back on the original profile's ProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoProcessManager : public ProcessManager {
  public:
   IncognitoProcessManager(BrowserContext* incognito_context,
                           BrowserContext* original_context,
-                          ProcessManager* original_manager);
+                          ProcessManager* original_manager,
+                          ExtensionRegistry* extension_registry);
   virtual ~IncognitoProcessManager() {}
   virtual bool CreateBackgroundHost(const Extension* extension,
                                     const GURL& url) OVERRIDE;
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 
  private:
   ProcessManager* original_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(IncognitoProcessManager);
 };
@@ skipping 64 matching lines @@
         is_closing(false),
         close_sequence_id(0) {}
 };
 
 //
 // ProcessManager
 //
 
 // static
 ProcessManager* ProcessManager::Create(BrowserContext* context) {
+  ExtensionRegistry* extension_registry = ExtensionRegistry::Get(context);
   ExtensionsBrowserClient* client = ExtensionsBrowserClient::Get();
   if (client->IsGuestSession(context)) {
     // In the guest session, there is a single off-the-record context.  Unlike
     // a regular incognito mode, background pages of extensions must be
     // created regardless of whether extensions use "spanning" or "split"
     // incognito behavior.
     BrowserContext* original_context = client->GetOriginalContext(context);
-    return new ProcessManager(context, original_context);
+    return new ProcessManager(context, original_context, extension_registry);
   }
 
   if (context->IsOffTheRecord()) {
     BrowserContext* original_context = client->GetOriginalContext(context);
     ProcessManager* original_manager =
         ExtensionSystem::Get(original_context)->process_manager();
     return new IncognitoProcessManager(
-        context, original_context, original_manager);
+        context, original_context, original_manager, extension_registry);
   }
 
-  return new ProcessManager(context, context);
+  return new ProcessManager(context, context, extension_registry);
+}
+
+// static
+ProcessManager* ProcessManager::CreateForTesting(
+    BrowserContext* context,
+    ExtensionRegistry* extension_registry) {
+  DCHECK(!context->IsOffTheRecord());
+  return new ProcessManager(context, context, extension_registry);
 }
 
 // static
 ProcessManager* ProcessManager::CreateIncognitoForTesting(
     BrowserContext* incognito_context,
     BrowserContext* original_context,
-    ProcessManager* original_manager) {
+    ProcessManager* original_manager,
+    ExtensionRegistry* extension_registry) {
   DCHECK(incognito_context->IsOffTheRecord());
   DCHECK(!original_context->IsOffTheRecord());
-  return new IncognitoProcessManager(
-      incognito_context, original_context, original_manager);
+  return new IncognitoProcessManager(incognito_context,
+                                     original_context,
+                                     original_manager,
+                                     extension_registry);
 }
 
 ProcessManager::ProcessManager(BrowserContext* context,
-                               BrowserContext* original_context)
+                               BrowserContext* original_context,
+                               ExtensionRegistry* extension_registry)
     : site_instance_(SiteInstance::Create(context)),
+      extension_registry_(extension_registry),
       startup_background_hosts_created_(false),
       devtools_callback_(base::Bind(&ProcessManager::OnDevToolsStateChanged,
                                     base::Unretained(this))),
       last_background_close_sequence_id_(0),
       weak_ptr_factory_(this) {
+  // ExtensionRegistry is shared between incognito and regular contexts.
+  DCHECK_EQ(original_context, extension_registry_->browser_context());
   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,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllSources());
-  registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
-                 content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::Source<BrowserContext>(context));
   if (context->IsOffTheRecord()) {
     registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::Source<BrowserContext>(original_context));
   }
 
   // Note: event_page_idle_time_ must be sufficiently larger (e.g. 2x) than
   // kKeepaliveThrottleIntervalInSeconds in ppapi/proxy/plugin_globals.
   event_page_idle_time_ = base::TimeDelta::FromSeconds(10);
@@ skipping 40 matching lines @@
 }
 
 void ProcessManager::RemoveObserver(ProcessManagerObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 bool ProcessManager::CreateBackgroundHost(const Extension* extension,
                                           const GURL& url) {
   // Hosted apps are taken care of from BackgroundContentsService. Ignore them
   // here.
-  if (extension->is_hosted_app() ||
-      !ExtensionsBrowserClient::Get()->
-          IsBackgroundPageAllowed(GetBrowserContext())) {
+  if (extension->is_hosted_app())
     return false;
-  }
+
+  // Don't create hosts if the embedder doesn't allow it.
+  ProcessManagerDelegate* delegate =
+      ExtensionsBrowserClient::Get()->GetProcessManagerDelegate();
+  if (delegate && !delegate->IsBackgroundPageAllowed(GetBrowserContext()))
+    return false;
 
   // Don't create multiple background hosts for an extension.
   if (GetBackgroundHostForExtension(extension->id()))
     return true;  // TODO(kalman): return false here? It might break things...
 
   ExtensionHost* host =
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url,
                         VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   host->CreateRenderViewSoon();
   OnBackgroundHostCreated(host);
@@ skipping 28 matching lines @@
   }
 
   return result;
 }
 
 const Extension* ProcessManager::GetExtensionForRenderViewHost(
     RenderViewHost* render_view_host) {
   if (!render_view_host->GetSiteInstance())
     return NULL;
 
-  ExtensionRegistry* registry = ExtensionRegistry::Get(GetBrowserContext());
-  if (!registry)
-    return NULL;
-
-  return registry->enabled_extensions().GetByID(
+  return extension_registry_->enabled_extensions().GetByID(
       GetExtensionID(render_view_host));
 }
 
 void ProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
@@ skipping 55 matching lines @@
 void ProcessManager::DecrementLazyKeepaliveCount(const Extension* extension) {
   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return;
   DecrementLazyKeepaliveCount(extension->id());
 }
 
 void ProcessManager::DecrementLazyKeepaliveCount(
     const std::string& extension_id) {
   int& count = background_page_data_[extension_id].lazy_keepalive_count;
   DCHECK(count > 0 ||
-         !ExtensionRegistry::Get(GetBrowserContext())
-              ->enabled_extensions()
-              .Contains(extension_id));
+         !extension_registry_->enabled_extensions().Contains(extension_id));
 
   // If we reach a zero keepalive count when the lazy background page is about
   // to be closed, incrementing close_sequence_id will cancel the close
   // sequence and cause the background page to linger. So check is_closing
   // before initiating another close sequence.
   if (--count == 0 && !background_page_data_[extension_id].is_closing) {
     background_page_data_[extension_id].close_sequence_id =
         ++last_background_close_sequence_id_;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
@@ skipping 157 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 ProcessManager::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();
-}
-
 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;
-
-      CreateBackgroundHostsForProfileStartup();
+    case chrome::NOTIFICATION_EXTENSIONS_READY: {
+      // TODO(jamescook): Convert this to use ExtensionSystem::ready() instead
+      // of a notification.
+      MaybeCreateStartupBackgroundHosts();
       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 107 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::MaybeCreateStartupBackgroundHosts() {
+  if (startup_background_hosts_created_)
     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());
+  // The embedder might disallow background pages entirely.
+  ProcessManagerDelegate* delegate =
+      ExtensionsBrowserClient::Get()->GetProcessManagerDelegate();
+  if (delegate && !delegate->IsBackgroundPageAllowed(GetBrowserContext()))
+    return;
 
-    FOR_EACH_OBSERVER(ProcessManagerObserver,
-                      observer_list_,
-                      OnBackgroundHostStartup(*extension));
-  }
+  // 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 when a browser window opens.
+  if (delegate &&
+      delegate->DeferCreatingStartupBackgroundHosts(GetBrowserContext()))
+    return;
+
+  CreateStartupBackgroundHosts();
   startup_background_hosts_created_ = true;
 
   // Background pages should only be loaded once. To prevent any further loads
   // occurring, we remove the notification listeners.
   BrowserContext* original_context =
       ExtensionsBrowserClient::Get()->GetOriginalContext(GetBrowserContext());
   if (registrar_.IsRegistered(
           this,
-          chrome::NOTIFICATION_PROFILE_CREATED,
-          content::Source<BrowserContext>(original_context))) {
-    registrar_.Remove(this,
-                      chrome::NOTIFICATION_PROFILE_CREATED,
-                      content::Source<BrowserContext>(original_context));
-  }
-  if (registrar_.IsRegistered(
-          this,
           chrome::NOTIFICATION_EXTENSIONS_READY,
           content::Source<BrowserContext>(original_context))) {
     registrar_.Remove(this,
                       chrome::NOTIFICATION_EXTENSIONS_READY,
                       content::Source<BrowserContext>(original_context));
   }
 }
 
+void ProcessManager::CreateStartupBackgroundHosts() {
+  DCHECK(!startup_background_hosts_created_);
+  const ExtensionSet& enabled_extensions =
+      extension_registry_->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_,
+                      OnBackgroundHostStartup(*extension));
+  }
+}
+
 void ProcessManager::OnBackgroundHostCreated(ExtensionHost* host) {
   DCHECK_EQ(GetBrowserContext(), host->browser_context());
   background_hosts_.insert(host);
 
   if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
     linked_ptr<base::ElapsedTimer> since_suspended(
         background_page_data_[host->extension()->id()].
             since_suspended.release());
     if (since_suspended.get()) {
       UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
@@ skipping 44 matching lines @@
   // Re-register all RenderViews for this extension. We do this to restore
   // 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 ProcessManager::DeferLoadingBackgroundHosts() const {
-  // The extensions embedder may have special rules about background hosts.
-  return ExtensionsBrowserClient::Get()->DeferLoadingBackgroundHosts(
-      GetBrowserContext());
-}
-
 //
 // IncognitoProcessManager
 //
 
 IncognitoProcessManager::IncognitoProcessManager(
     BrowserContext* incognito_context,
     BrowserContext* original_context,
-    ProcessManager* original_manager)
-    : ProcessManager(incognito_context, original_context),
+    ProcessManager* original_manager,
+    ExtensionRegistry* extension_registry)
+    : ProcessManager(incognito_context, original_context, extension_registry),
       original_manager_(original_manager) {
   DCHECK(incognito_context->IsOffTheRecord());
 
   // The original profile will have its own ProcessManager to
   // load the background pages of the spanning extensions. This process
   // manager need only worry about the split mode extensions, which is handled
   // in the NOTIFICATION_BROWSER_WINDOW_READY notification handler.
   registrar_.Remove(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                     content::Source<BrowserContext>(original_context));
-  registrar_.Remove(this, chrome::NOTIFICATION_PROFILE_CREATED,
-                    content::Source<BrowserContext>(original_context));
 }
 
 bool IncognitoProcessManager::CreateBackgroundHost(const Extension* extension,
                                                    const GURL& url) {
   if (IncognitoInfo::IsSplitMode(extension)) {
     if (ExtensionsBrowserClient::Get()->IsExtensionIncognitoEnabled(
             extension->id(), GetBrowserContext()))
       return ProcessManager::CreateBackgroundHost(extension, url);
   } else {
     // Do nothing. If an extension is spanning, then its original-profile
     // background page is shared with incognito, so we don't create another.
   }
   return false;
 }
 
 SiteInstance* IncognitoProcessManager::GetSiteInstanceForURL(const GURL& url) {
-  ExtensionRegistry* registry = ExtensionRegistry::Get(GetBrowserContext());
-  if (registry) {
-    const Extension* extension =
-        registry->enabled_extensions().GetExtensionOrAppByURL(url);
-    if (extension && !IncognitoInfo::IsSplitMode(extension)) {
-      return original_manager_->GetSiteInstanceForURL(url);
-    }
-  }
+  const Extension* extension =
+      extension_registry_->enabled_extensions().GetExtensionOrAppByURL(url);
+  if (extension && !IncognitoInfo::IsSplitMode(extension))
+    return original_manager_->GetSiteInstanceForURL(url);
+
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions