Reland: Convert ExtensionProcessManager to BrowserContext, part 1

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"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/browser_finder.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #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 "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/view_type_utils.h"
+#include "extensions/common/switches.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
 #endif
 
+using content::BrowserContext;
 using content::RenderViewHost;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::BackgroundInfo;
 using extensions::BackgroundManifestHandler;
 using extensions::Extension;
 using extensions::ExtensionHost;
+using extensions::ExtensionsBrowserClient;
+using extensions::ExtensionSystem;
 
 class RenderViewHostDestructionObserver;
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(RenderViewHostDestructionObserver);
 
 namespace {
 
 std::string GetExtensionID(RenderViewHost* render_view_host) {
   // This works for both apps and extensions because the site has been
   // normalized to the extension URL for apps.
   if (!render_view_host->GetSiteInstance())
     return std::string();
 
   return render_view_host->GetSiteInstance()->GetSiteURL().host();
 }
 
-void OnRenderViewHostUnregistered(Profile* profile,
+void OnRenderViewHostUnregistered(BrowserContext* context,
                                   RenderViewHost* render_view_host) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
-      content::Source<Profile>(profile),
+      content::Source<BrowserContext>(context),
       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 ExtensionProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoExtensionProcessManager : public ExtensionProcessManager {
  public:
-  explicit IncognitoExtensionProcessManager(Profile* profile);
+  IncognitoExtensionProcessManager(BrowserContext* incognito_context,
+                                   BrowserContext* original_context);
   virtual ~IncognitoExtensionProcessManager();
   virtual ExtensionHost* CreateViewHost(
       const Extension* extension,
       const GURL& url,
       Browser* browser,
       extensions::ViewType view_type) OVERRIDE;
   virtual ExtensionHost* CreateBackgroundHost(const Extension* extension,
                                               const GURL& url) OVERRIDE;
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 
  private:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Returns true if the extension is allowed to run in incognito mode.
   bool IsIncognitoEnabled(const Extension* extension);
 
   ExtensionProcessManager* original_manager_;
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ExtensionProcessManager* manager, const Extension* extension) {
+  DVLOG(1) << "CreateBackgroundHostForExtensionLoad";
   if (BackgroundInfo::HasPersistentBackgroundPage(extension))
     manager->CreateBackgroundHost(extension,
                                   BackgroundInfo::GetBackgroundURL(extension));
 }
 
 }  // namespace
 
 class RenderViewHostDestructionObserver
     : public content::WebContentsObserver,
       public content::WebContentsUserData<RenderViewHostDestructionObserver> {
@@ skipping 40 matching lines @@
 
   BackgroundPageData()
       : lazy_keepalive_count(0), close_sequence_id(0), is_closing(false) {}
 };
 
 //
 // ExtensionProcessManager
 //
 
 // static
-ExtensionProcessManager* ExtensionProcessManager::Create(Profile* profile) {
-  return (profile->IsOffTheRecord()) ?
-      new IncognitoExtensionProcessManager(profile) :
-      new ExtensionProcessManager(profile);
+ExtensionProcessManager* ExtensionProcessManager::Create(
+    BrowserContext* context) {
+  if (context->IsOffTheRecord()) {
+    BrowserContext* original_context =
+        ExtensionsBrowserClient::Get()->GetOriginalContext(context);
+    return new IncognitoExtensionProcessManager(context, original_context);
+  }
+  return new ExtensionProcessManager(context, context);
 }
 
-ExtensionProcessManager::ExtensionProcessManager(Profile* profile)
-  : site_instance_(SiteInstance::Create(profile)),
+ExtensionProcessManager::ExtensionProcessManager(
+    BrowserContext* context,
+    BrowserContext* original_context)
+  : site_instance_(SiteInstance::Create(context)),
     defer_background_host_creation_(false),
-    weak_ptr_factory_(this),
     devtools_callback_(base::Bind(
         &ExtensionProcessManager::OnDevToolsStateChanged,
-        base::Unretained(this))) {
-  Profile* original_profile = profile->GetOriginalProfile();
+        base::Unretained(this))),
+    weak_ptr_factory_(this) {
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
-                 content::Source<Profile>(original_profile));
+                 content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                 content::Source<Profile>(original_profile));
+                 content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(original_profile));
+                 content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
-                 content::Source<Profile>(profile));
+                 content::Source<BrowserContext>(context));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
-                 content::Source<Profile>(profile));
+                 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<Profile>(original_profile));
+                 content::Source<BrowserContext>(original_context));
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
-                 content::Source<Profile>(profile));
-  if (profile->IsOffTheRecord()) {
+                 content::Source<BrowserContext>(context));
+  if (context->IsOffTheRecord()) {
     registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
-                   content::Source<Profile>(original_profile));
+                   content::Source<BrowserContext>(original_context));
   }
 
   event_page_idle_time_ = base::TimeDelta::FromSeconds(10);
   unsigned idle_time_sec = 0;
   if (base::StringToUint(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kEventPageIdleTime), &idle_time_sec)) {
+          extensions::switches::kEventPageIdleTime), &idle_time_sec)) {
     event_page_idle_time_ = base::TimeDelta::FromSeconds(idle_time_sec);
   }
   event_page_suspending_time_ = base::TimeDelta::FromSeconds(5);
   unsigned suspending_time_sec = 0;
   if (base::StringToUint(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kEventPageSuspendingTime), &suspending_time_sec)) {
-    event_page_suspending_time_ = base::TimeDelta::FromSeconds(
-        suspending_time_sec);
+                             extensions::switches::kEventPageSuspendingTime),
+                         &suspending_time_sec)) {
+    event_page_suspending_time_ =
+        base::TimeDelta::FromSeconds(suspending_time_sec);
   }
 
   content::DevToolsManager::GetInstance()->AddAgentStateCallback(
       devtools_callback_);
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
   content::DevToolsManager::GetInstance()->RemoveAgentStateCallback(
       devtools_callback_);
 }
 
 const ExtensionProcessManager::ViewSet
 ExtensionProcessManager::GetAllViews() const {
   ViewSet result;
   for (ExtensionRenderViews::const_iterator iter =
            all_extension_views_.begin();
        iter != all_extension_views_.end(); ++iter) {
     result.insert(iter->first);
   }
   return result;
 }
 
 void ExtensionProcessManager::EnsureBrowserWhenRequired(
     Browser* browser,
     extensions::ViewType view_type) {
   if (!browser) {
-#if defined (OS_CHROMEOS)
-  // On ChromeOS we'll only use ExtensionView, which
-  // does not use the browser parameter.
-  // TODO(rkc): Remove all this once we create a new host for
-  // screensaver extensions (crosbug.com/28211).
-  DCHECK(view_type == extensions::VIEW_TYPE_EXTENSION_POPUP ||
-         view_type == extensions::VIEW_TYPE_EXTENSION_DIALOG);
-#else
-  // A NULL browser may only be given for pop-up views.
-  DCHECK(view_type == extensions::VIEW_TYPE_EXTENSION_POPUP);
-#endif
+    // A NULL browser may only be given for pop-up views and dialogs.
+    DCHECK(view_type == extensions::VIEW_TYPE_EXTENSION_POPUP ||
+           view_type == extensions::VIEW_TYPE_EXTENSION_DIALOG);
   }
 }
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
     extensions::ViewType view_type) {
+  DVLOG(1) << "CreateViewHost";
   DCHECK(extension);
   EnsureBrowserWhenRequired(browser, view_type);
   ExtensionHost* host =
 #if defined(OS_MACOSX)
       new extensions::ExtensionHostMac(
           extension, GetSiteInstanceForURL(url), url, view_type);
 #else
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url, view_type);
 #endif
   host->CreateView(browser);
   OnExtensionHostCreated(host, false);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
     const GURL& url, Browser* browser, extensions::ViewType view_type) {
   EnsureBrowserWhenRequired(browser, view_type);
-  ExtensionService* service = GetProfile()->GetExtensionService();
+  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+      GetBrowserContext())->extension_service();
   if (service) {
     std::string extension_id = url.host();
     if (url.SchemeIs(chrome::kChromeUIScheme) &&
         url.host() == chrome::kChromeUIExtensionInfoHost)
       extension_id = url.path().substr(1);
     const Extension* extension =
         service->extensions()->GetByID(extension_id);
     if (extension)
       return CreateViewHost(extension, url, browser, view_type);
   }
@@ skipping 21 matching lines @@
       extension, url, browser, extensions::VIEW_TYPE_EXTENSION_INFOBAR);
 }
 
 ExtensionHost* ExtensionProcessManager::CreateInfobarHost(
     const GURL& url, Browser* browser) {
   return CreateViewHost(url, browser, extensions::VIEW_TYPE_EXTENSION_INFOBAR);
 }
 
 ExtensionHost* ExtensionProcessManager::CreateBackgroundHost(
     const Extension* extension, const GURL& url) {
+  DVLOG(1) << "CreateBackgroundHost " << url.spec();
   // Hosted apps are taken care of from BackgroundContentsService. Ignore them
   // here.
   if (extension->is_hosted_app())
     return NULL;
 
   // Don't create multiple background hosts for an extension.
   if (ExtensionHost* host = GetBackgroundHostForExtension(extension->id()))
     return host;  // TODO(kalman): return NULL here? It might break things...
 
   ExtensionHost* host =
@@ skipping 40 matching lines @@
   }
 
   return result;
 }
 
 const Extension* ExtensionProcessManager::GetExtensionForRenderViewHost(
     RenderViewHost* render_view_host) {
   if (!render_view_host->GetSiteInstance())
     return NULL;
 
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(GetProfile())->extension_service();
+  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+      GetBrowserContext())->extension_service();
   if (!service)
     return NULL;
 
   return service->extensions()->GetByID(GetExtensionID(render_view_host));
 }
 
 void ExtensionProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
-  OnRenderViewHostUnregistered(GetProfile(), render_view_host);
+  OnRenderViewHostUnregistered(GetBrowserContext(), render_view_host);
   extensions::ViewType view_type = view->second;
   all_extension_views_.erase(view);
 
   // Keepalive count, balanced in RegisterRenderViewHost.
   if (view_type != extensions::VIEW_TYPE_INVALID &&
       view_type != extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
       DecrementLazyKeepaliveCount(extension);
@@ skipping 190 matching lines @@
     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();
+      ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+          GetBrowserContext())->extension_service();
       if (!service || !service->is_ready())
         break;
 
       CreateBackgroundHostsForProfileStartup();
       break;
     }
     case chrome::NOTIFICATION_EXTENSIONS_READY:
     case chrome::NOTIFICATION_PROFILE_CREATED: {
       CreateBackgroundHostsForProfileStartup();
       break;
@@ skipping 46 matching lines @@
       break;
     }
 
     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
       // We get this notification both for new WebContents and when one
       // has its RenderViewHost replaced (e.g. when a user does a cross-site
       // navigation away from an extension URL). For the replaced case, we must
       // unregister the old RVH so it doesn't count as an active view that would
       // keep the event page alive.
       WebContents* contents = content::Source<WebContents>(source).ptr();
-      if (contents->GetBrowserContext() != GetProfile())
+      if (contents->GetBrowserContext() != GetBrowserContext())
         break;
 
       typedef std::pair<RenderViewHost*, RenderViewHost*> RVHPair;
       RVHPair* switched_details = content::Details<RVHPair>(details).ptr();
       if (switched_details->first)
         UnregisterRenderViewHost(switched_details->first);
 
       // The above will unregister a RVH when it gets swapped out with a new
       // one. However we need to watch the WebContents to know when a RVH is
       // deleted because the WebContents has gone away.
       RenderViewHostDestructionObserver::CreateForWebContents(contents);
       RegisterRenderViewHost(switched_details->second);
       break;
     }
 
     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED: {
       WebContents* contents = content::Source<WebContents>(source).ptr();
-      if (contents->GetBrowserContext() != GetProfile())
+      if (contents->GetBrowserContext() != GetBrowserContext())
         break;
       const Extension* extension = GetExtensionForRenderViewHost(
           contents->GetRenderViewHost());
       if (!extension)
         return;
 
       // 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<Profile>(GetProfile()),
+          content::Source<BrowserContext>(GetBrowserContext()),
           content::Details<RenderViewHost>(contents->GetRenderViewHost()));
       break;
     }
 
     case chrome::NOTIFICATION_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();
   }
 }
 
 void ExtensionProcessManager::OnDevToolsStateChanged(
     content::DevToolsAgentHost* agent_host, bool attached) {
   RenderViewHost* rvh = agent_host->GetRenderViewHost();
   // Ignore unrelated notifications.
   if (!rvh ||
-      rvh->GetSiteInstance()->GetProcess()->GetBrowserContext() != GetProfile())
+      rvh->GetSiteInstance()->GetProcess()->GetBrowserContext() !=
+          GetBrowserContext())
     return;
   if (extensions::GetViewType(WebContents::FromRenderViewHost(rvh)) !=
       extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE)
     return;
   const Extension* extension = GetExtensionForRenderViewHost(rvh);
   if (!extension)
     return;
   if (attached) {
     // Keep the lazy background page alive while it's being inspected.
     CancelSuspend(extension);
     IncrementLazyKeepaliveCount(extension);
   } else {
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::CreateBackgroundHostsForProfileStartup() {
+  DVLOG(1) << "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();
+  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());
 
     extensions::RuntimeEventRouter::DispatchOnStartupEvent(
-        GetProfile(), (*extension)->id());
+        GetBrowserContext(), (*extension)->id());
   }
 
   // Background pages should only be loaded once. To prevent any further loads
   // occurring, we remove the notification listeners.
-  Profile* original_profile = GetProfile()->GetOriginalProfile();
+  BrowserContext* original_context =
+      ExtensionsBrowserClient::Get()->GetOriginalContext(GetBrowserContext());
   registrar_.Remove(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                     content::NotificationService::AllSources());
-  if (registrar_.IsRegistered(this, chrome::NOTIFICATION_PROFILE_CREATED,
-                              content::Source<Profile>(original_profile)))
-    registrar_.Remove(this, chrome::NOTIFICATION_PROFILE_CREATED,
-                      content::Source<Profile>(original_profile));
-  if (registrar_.IsRegistered(this, chrome::NOTIFICATION_EXTENSIONS_READY,
-                              content::Source<Profile>(original_profile)))
-    registrar_.Remove(this, chrome::NOTIFICATION_EXTENSIONS_READY,
-                      content::Source<Profile>(original_profile));
+  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));
+  }
 }
 
 Profile* ExtensionProcessManager::GetProfile() const {
   return Profile::FromBrowserContext(site_instance_->GetBrowserContext());
 }
 
+content::BrowserContext* ExtensionProcessManager::GetBrowserContext() const {
+  return site_instance_->GetBrowserContext();
+}
+
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
-  DCHECK_EQ(site_instance_->GetBrowserContext(), host->profile());
+  DCHECK_EQ(site_instance_->GetBrowserContext(), host->browser_context());
   if (is_background) {
     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",
                                  since_suspended->Elapsed());
@@ skipping 18 matching lines @@
   }
 }
 
 void ExtensionProcessManager::UnregisterExtension(
     const std::string& extension_id) {
   // The lazy_keepalive_count may be greater than zero at this point because
   // RenderViewHosts are still alive. During extension reloading, they will
   // decrement the lazy_keepalive_count to negative for the new extension
   // instance when they are destroyed. Since we are erasing the background page
   // data for the unloaded extension, unregister the RenderViewHosts too.
-  Profile* profile = GetProfile();
+  BrowserContext* context = GetBrowserContext();
   for (ExtensionRenderViews::iterator it = all_extension_views_.begin();
        it != all_extension_views_.end(); ) {
     if (GetExtensionID(it->first) == extension_id) {
-      OnRenderViewHostUnregistered(profile, it->first);
+      OnRenderViewHostUnregistered(context, it->first);
       all_extension_views_.erase(it++);
     } else {
       ++it;
     }
   }
 
   background_page_data_.erase(extension_id);
 }
 
 void ExtensionProcessManager::ClearBackgroundPageData(
     const std::string& extension_id) {
   background_page_data_.erase(extension_id);
 
   // 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 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 &&
-         CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowAppList);
-#endif
+  // The extensions embedder may have special rules about background hosts.
+  return ExtensionsBrowserClient::Get()->DeferLoadingBackgroundHosts(
+      GetBrowserContext());
 }
 
 //
 // IncognitoExtensionProcessManager
 //
 
 IncognitoExtensionProcessManager::IncognitoExtensionProcessManager(
-    Profile* profile)
-    : ExtensionProcessManager(profile),
-      original_manager_(extensions::ExtensionSystem::Get(
-          profile->GetOriginalProfile())->process_manager()) {
-  DCHECK(profile->IsOffTheRecord());
+    BrowserContext* incognito_context,
+    BrowserContext* original_context)
+    : ExtensionProcessManager(incognito_context, original_context),
+      original_manager_(extensions::ExtensionSystem::GetForBrowserContext(
+          original_context)->process_manager()) {
+  DCHECK(incognito_context->IsOffTheRecord());
 
   // The original profile will have its own ExtensionProcessManager 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<Profile>(profile->GetOriginalProfile()));
+                    content::Source<BrowserContext>(original_context));
   registrar_.Remove(this, chrome::NOTIFICATION_PROFILE_CREATED,
-                    content::Source<Profile>(profile->GetOriginalProfile()));
+                    content::Source<BrowserContext>(original_context));
 }
 
 IncognitoExtensionProcessManager::~IncognitoExtensionProcessManager() {
   // TODO(yoz): This cleanup code belongs in the MenuManager.
   // Remove "incognito" "split" mode context menu items.
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(GetProfile())->extension_service();
+  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+      GetBrowserContext())->extension_service();
   if (service)
     service->menu_manager()->RemoveAllIncognitoContextItems();
 }
 
 ExtensionHost* IncognitoExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
     extensions::ViewType view_type) {
   if (extensions::IncognitoInfo::IsSplitMode(extension)) {
@@ skipping 19 matching lines @@
       return ExtensionProcessManager::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 NULL;
 }
 
 SiteInstance* IncognitoExtensionProcessManager::GetSiteInstanceForURL(
     const GURL& url) {
-  ExtensionService* service = GetProfile()->GetExtensionService();
+  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+      GetBrowserContext())->extension_service();
   if (service) {
     const Extension* extension =
         service->extensions()->GetExtensionOrAppByURL(url);
     if (extension &&
         !extensions::IncognitoInfo::IsSplitMode(extension)) {
       return original_manager_->GetSiteInstanceForURL(url);
     }
   }
   return ExtensionProcessManager::GetSiteInstanceForURL(url);
 }
 
 bool IncognitoExtensionProcessManager::IsIncognitoEnabled(
     const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
-  ExtensionService* service = GetProfile()->GetExtensionService();
+  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+      GetBrowserContext())->extension_service();
   return extension_util::IsIncognitoEnabled(extension->id(), service);
 }
 
 void IncognitoExtensionProcessManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     // Do not use ExtensionProcessManager's handler for
     // NOTIFICATION_BROWSER_WINDOW_READY.
     case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
       // We want to spawn our background hosts as soon as the user opens an
       // incognito window. Watch for new browsers and create the hosts if
       // it matches our profile.
       Browser* browser = content::Source<Browser>(source).ptr();
       if (browser->profile() == site_instance_->GetBrowserContext()) {
         // On Chrome OS, a login screen is implemented as a browser.
         // This browser has no extension service.  In this case,
         // service will be NULL.
-        ExtensionService* service = GetProfile()->GetExtensionService();
+        ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+            GetBrowserContext())->extension_service();
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup();
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }