Remove GetExtensionService from Profile.

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 622 matching lines @@
   return ChromeWebUIControllerFactory::GetInstance();
 }
 
 GURL ChromeContentBrowserClient::GetEffectiveURL(
     content::BrowserContext* browser_context, const GURL& url) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
   // Get the effective URL for the given actual URL. If the URL is part of an
   // installed app, the effective URL is an extension URL with the ID of that
   // extension as the host. This has the effect of grouping apps together in
   // a common SiteInstance.
-  if (!profile || !profile->GetExtensionService())
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  if (!extension_service)
     return url;
 
-  const Extension* extension = profile->GetExtensionService()->extensions()->
+  const Extension* extension = extension_service->extensions()->
       GetHostedAppByURL(ExtensionURLInfo(url));
   if (!extension)
     return url;
 
   // Bookmark apps do not use the hosted app process model, and should be
   // treated as normal URLs.
   if (extension->from_bookmark())
     return url;
 
   // If the URL is part of an extension's web extent, convert it to an
   // extension URL.
   return extension->GetResourceURL(url.path());
 }
 
 bool ChromeContentBrowserClient::ShouldUseProcessPerSite(
     content::BrowserContext* browser_context, const GURL& effective_url) {
   // Non-extension URLs should generally use process-per-site-instance.
   // Because we expect to use the effective URL, URLs for hosted apps (apart
   // from bookmark apps) should have an extension scheme by now.
   if (!effective_url.SchemeIs(extensions::kExtensionScheme))
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  if (!profile || !profile->GetExtensionService())
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  if (!extension_service)
     return false;
 
-  const Extension* extension = profile->GetExtensionService()->extensions()->
+  const Extension* extension = extension_service->extensions()->
       GetExtensionOrAppByURL(ExtensionURLInfo(effective_url));
   if (!extension)
     return false;
 
   // If the URL is part of a hosted app that does not have the background
   // permission, or that does not allow JavaScript access to the background
   // page, we want to give each instance its own process to improve
   // responsiveness.
   if (extension->GetType() == Extension::TYPE_HOSTED_APP) {
     if (!extension->HasAPIPermission(APIPermission::kBackground) ||
@@ skipping 10 matching lines @@
 
 bool ChromeContentBrowserClient::IsHandledURL(const GURL& url) {
   return ProfileIOData::IsHandledURL(url);
 }
 
 bool ChromeContentBrowserClient::IsSuitableHost(
     content::RenderProcessHost* process_host,
     const GURL& site_url) {
   Profile* profile =
       Profile::FromBrowserContext(process_host->GetBrowserContext());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   extensions::ProcessMap* process_map = service->process_map();
 
   // Don't allow the Task Manager to share a process with anything else.
   // Otherwise it can affect the renderers it is observing.
   // Note: we could create another RenderProcessHostPrivilege bucket for
   // this to allow multiple chrome://tasks instances to share, but that's
   // a very unlikely case without serious consequences.
   if (site_url.GetOrigin() == GURL(chrome::kChromeUITaskManagerURL).GetOrigin())
     return false;
 
@@ skipping 26 matching lines @@
 // with background pages. It uses a globally set percentage of processes to
 // run such extensions and if the limit is exceeded, it returns true, to
 // indicate to the content module to group extensions together.
 bool ChromeContentBrowserClient::ShouldTryToUseExistingProcessHost(
     content::BrowserContext* browser_context, const GURL& url) {
   // It has to be a valid URL for us to check for an extension.
   if (!url.is_valid())
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return false;
 
   // We have to have a valid extension with background page to proceed.
   const Extension* extension =
       service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(url));
   if (!extension)
     return false;
   if (!extension->has_background_page())
     return false;
@@ skipping 25 matching lines @@
 
   return false;
 }
 
 void ChromeContentBrowserClient::SiteInstanceGotProcess(
     SiteInstance* site_instance) {
   CHECK(site_instance->HasProcess());
 
   Profile* profile = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
 
   const Extension* extension =
       service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(
           site_instance->GetSiteURL()));
   if (!extension)
     return;
 
   service->process_map()->Insert(extension->id(),
                                  site_instance->GetProcess()->GetID(),
                                  site_instance->GetId());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ExtensionInfoMap::RegisterExtensionProcess,
                  extensions::ExtensionSystem::Get(profile)->info_map(),
                  extension->id(),
                  site_instance->GetProcess()->GetID(),
                  site_instance->GetId()));
 }
 
 void ChromeContentBrowserClient::SiteInstanceDeleting(
     SiteInstance* site_instance) {
   if (!site_instance->HasProcess())
     return;
 
   Profile* profile = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
 
   const Extension* extension =
       service->extensions()->GetExtensionOrAppByURL(
           ExtensionURLInfo(site_instance->GetSiteURL()));
   if (!extension)
     return;
 
   service->process_map()->Remove(extension->id(),
@@ skipping 76 matching lines @@
         browser_command_line.GetSwitchValueASCII(switches::kLoginProfile);
     if (!login_profile.empty())
       command_line->AppendSwitchASCII(switches::kLoginProfile, login_profile);
 #endif
 
     content::RenderProcessHost* process =
         content::RenderProcessHost::FromID(child_process_id);
     if (process) {
       Profile* profile = Profile::FromBrowserContext(
           process->GetBrowserContext());
-      if (profile->GetExtensionService()) {
-        extensions::ProcessMap* process_map =
-            profile->GetExtensionService()->process_map();
+      ExtensionService* extension_service =
+          extensions::ExtensionSystem::Get(profile)->extension_service();
+      if (extension_service) {
+        extensions::ProcessMap* process_map = extension_service->process_map();
         if (process_map && process_map->Contains(process->GetID()))
           command_line->AppendSwitch(switches::kExtensionProcess);
       }
 
       PrefService* prefs = profile->GetPrefs();
       // Currently this pref is only registered if applied via a policy.
       if (prefs->HasPrefPath(prefs::kDisable3DAPIs) &&
           prefs->GetBoolean(prefs::kDisable3DAPIs)) {
         // Turn this policy into a command line switch.
         command_line->AppendSwitch(switches::kDisable3DAPIs);
@@ skipping 420 matching lines @@
       tab_util::GetWebContentsByID(render_process_id, render_view_id);
   if (!contents) {
     NOTREACHED();
     return;
   }
 
   // Skip showing the infobar if the request comes from an extension, and that
   // extension has the 'notify' permission. (If the extension does not have the
   // permission, the user will still be prompted.)
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   const Extension* extension = !service ? NULL :
       service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(
           source_origin));
   if (extension &&
       extension->HasAPIPermission(APIPermission::kNotification)) {
     RenderViewHost* rvh =
         RenderViewHost::FromID(render_process_id, render_view_id);
     if (rvh)
       rvh->DesktopNotificationPermissionRequestDone(callback_context);
     return;
@@ skipping 269 matching lines @@
       CharacterEncoding::GetCanonicalEncodingNameByAliasName(
           web_prefs->default_encoding);
   if (web_prefs->default_encoding.empty()) {
     prefs->ClearPref(prefs::kDefaultCharset);
     web_prefs->default_encoding = prefs->GetString(prefs::kDefaultCharset);
   }
   DCHECK(!web_prefs->default_encoding.empty());
 
   WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
   chrome::ViewType view_type = chrome::GetViewType(web_contents);
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   if (service) {
     const GURL& url = rvh->GetSiteInstance()->GetSiteURL();
     const Extension* extension = service->extensions()->GetByID(url.host());
     // Ensure that we are only granting extension preferences to URLs with
     // the correct scheme. Without this check, chrome-guest:// schemes used by
     // webview tags as well as hosts that happen to match the id of an
     // installed extension would get the wrong preferences.
     if (url.SchemeIs(extensions::kExtensionScheme)) {
       extension_webkit_preferences::SetPreferences(
           extension, view_type, web_prefs);
@@ skipping 118 matching lines @@
     return false;
 
   std::string host = url.host();
   if (url.SchemeIs(extensions::kExtensionScheme) &&
       allowed_socket_origins_.count(host)) {
     return true;
   }
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
   const Extension* extension = NULL;
-  if (profile && profile->GetExtensionService()) {
-    extension = profile->GetExtensionService()->extensions()->
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  if (extension_service) {
+    extension = extension_service->extensions()->
         GetExtensionOrAppByURL(ExtensionURLInfo(url));
   }
 
   // Need to check this now and not on construction because otherwise it won't
   // work with browser_tests.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   std::string allowed_list =
       command_line.GetSwitchValueASCII(switches::kAllowNaClSocketAPI);
   if (allowed_list == "*") {
     // The wildcard allows socket API only for packaged and platform apps.
@@ skipping 127 matching lines @@
     io_thread_application_locale_ = locale;
 }
 
 void ChromeContentBrowserClient::SetApplicationLocaleOnIOThread(
     const std::string& locale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   io_thread_application_locale_ = locale;
 }
 
 }  // namespace chrome