Remove DeferBackgroundExtensionCreation field trial and supporting code

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 157 matching lines @@
     BrowserContext* original_context =
         ExtensionsBrowserClient::Get()->GetOriginalContext(context);
     return new IncognitoProcessManager(context, original_context);
   }
   return new ProcessManager(context, context);
 }
 
 ProcessManager::ProcessManager(BrowserContext* context,
                                BrowserContext* original_context)
   : site_instance_(SiteInstance::Create(context)),
-    defer_background_host_creation_(false),
     startup_background_hosts_created_(false),
     devtools_callback_(base::Bind(
         &ProcessManager::OnDevToolsStateChanged,
         base::Unretained(this))),
     weak_ptr_factory_(this) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
@@ skipping 340 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::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 ProcessManager::OnBrowserWindowReady() {
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   // On Chrome OS, a login screen is implemented as a browser.
   // This browser has no extension service.  In this case,
   // service will be NULL.
   if (!service || !service->is_ready())
     return;
 
   CreateBackgroundHostsForProfileStartup();
 }
 
 content::BrowserContext* ProcessManager::GetBrowserContext() const {
   return site_instance_->GetBrowserContext();
 }
 
 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();
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       BrowserContext* context = content::Source<BrowserContext>(source).ptr();
       ExtensionService* service =
           ExtensionSystem::GetForBrowserContext(context)->extension_service();
       if (service->is_ready()) {
         const Extension* extension =
@@ skipping 111 matching lines @@
     IncrementLazyKeepaliveCount(extension);
   } else {
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ProcessManager::CreateBackgroundHostsForProfileStartup() {
   if (startup_background_hosts_created_)
     return;
 
-  // 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 = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   DCHECK(service);
   for (ExtensionSet::const_iterator extension = service->extensions()->begin();
        extension != service->extensions()->end(); ++extension) {
     CreateBackgroundHostForExtensionLoad(this, extension->get());
 
     RuntimeEventRouter::DispatchOnStartupEvent(GetBrowserContext(),
                                                (*extension)->id());
   }
@@ skipping 79 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 ProcessManager::DeferLoadingBackgroundHosts() const {
-  // Don't load background hosts now if the loading should be deferred.
-  if (defer_background_host_creation_)
-    return true;
-
   // The extensions embedder may have special rules about background hosts.
   return ExtensionsBrowserClient::Get()->DeferLoadingBackgroundHosts(
       GetBrowserContext());
 }
 
 //
 // IncognitoProcessManager
 //
 
 IncognitoProcessManager::IncognitoProcessManager(
@@ skipping 40 matching lines @@
 }
 
 bool IncognitoProcessManager::IsIncognitoEnabled(const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   return extension_util::IsIncognitoEnabled(extension->id(), service);
 }
 
 }  // namespace extensions