Removal of Profile from content part 1.

chrome/browser/chrome_content_browser_client.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "chrome/app/breakpad_mac.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 74 matching lines @@
 
 void InitRenderViewHostForExtensions(RenderViewHost* render_view_host) {
   // Note that due to GetEffectiveURL(), even hosted apps will have a
   // chrome-extension:// URL for their site, so we can ignore that wrinkle here.
   SiteInstance* site_instance = render_view_host->site_instance();
   const GURL& site = site_instance->site();
 
   if (!site.SchemeIs(chrome::kExtensionScheme))
     return;
 
-  Profile* profile = site_instance->browsing_instance()->profile();
+  Profile* profile = Profile::FromBrowserContext(
+      site_instance->browsing_instance()->browser_context());
   ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return;
 
   ExtensionProcessManager* process_manager =
       profile->GetExtensionProcessManager();
   CHECK(process_manager);
 
   // This can happen if somebody typos a chrome-extension:// URL.
   const Extension* extension = service->GetExtensionByURL(site);
@@ skipping 33 matching lines @@
       type == Extension::TYPE_USER_SCRIPT ||
       type == Extension::TYPE_PACKAGED_APP ||
       (type == Extension::TYPE_HOSTED_APP &&
        extension->location() == Extension::COMPONENT)) {
     render_view_host->Send(new ExtensionMsg_ActivateExtension(extension->id()));
     render_view_host->AllowBindings(BindingsPolicy::EXTENSION);
   }
 }
 
 // Handles rewriting Web UI URLs.
-static bool HandleWebUI(GURL* url, Profile* profile) {
-  if (!ChromeWebUIFactory::GetInstance()->UseWebUIForURL(profile, *url))
+static bool HandleWebUI(GURL* url, content::BrowserContext* browser_context) {
+  if (!ChromeWebUIFactory::GetInstance()->UseWebUIForURL(browser_context, *url))
     return false;
 
   // Special case the new tab page. In older versions of Chrome, the new tab
   // page was hosted at chrome-internal:<blah>. This might be in people's saved
   // sessions or bookmarks, so we say any URL with that scheme triggers the new
   // tab page.
   if (url->SchemeIs(chrome::kChromeInternalScheme)) {
     // Rewrite it with the proper new tab URL.
     *url = GURL(chrome::kChromeUINewTabURL);
   }
@@ skipping 10 matching lines @@
   new ChromeRenderViewHostObserver(render_view_host);
   new DevToolsHandler(render_view_host);
   new ExtensionMessageHandler(render_view_host);
 
   InitRenderViewHostForExtensions(render_view_host);
 }
 
 void ChromeContentBrowserClient::BrowserRenderProcessHostCreated(
     BrowserRenderProcessHost* host) {
   int id = host->id();
-  Profile* profile = host->profile();
+  Profile* profile = Profile::FromBrowserContext(host->browser_context());
   host->channel()->AddFilter(new ChromeRenderMessageFilter(
       id, profile, profile->GetRequestContextForRenderProcess(id)));
   host->channel()->AddFilter(new PrintingMessageFilter());
   host->channel()->AddFilter(
       new SearchProviderInstallStateMessageFilter(id, profile));
   host->channel()->AddFilter(new SpellCheckMessageFilter(id));
 #if defined(OS_MACOSX)
   host->channel()->AddFilter(new TextInputClientMessageFilter(host->id()));
 #endif
 
   host->Send(new ViewMsg_SetIsIncognitoProcess(profile->IsOffTheRecord()));
 }
 
 void ChromeContentBrowserClient::PluginProcessHostCreated(
     PluginProcessHost* host) {
   host->AddFilter(new ChromePluginMessageFilter(host));
 }
 
 void ChromeContentBrowserClient::WorkerProcessHostCreated(
     WorkerProcessHost* host) {
   host->AddFilter(new ChromeWorkerMessageFilter(host));
 }
 
 content::WebUIFactory* ChromeContentBrowserClient::GetWebUIFactory() {
   return ChromeWebUIFactory::GetInstance();
 }
 
-GURL ChromeContentBrowserClient::GetEffectiveURL(Profile* profile,
-                                                 const GURL& url) {
+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())
     return url;
 
   const Extension* extension =
       profile->GetExtensionService()->GetExtensionByWebExtent(url);
   if (!extension)
     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(
-    Profile* profile,
-    const GURL& effective_url) {
+    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, hosted apps URLs should have
   // an extension scheme by now.
   if (!effective_url.SchemeIs(chrome::kExtensionScheme))
     return false;
 
+  Profile* profile = Profile::FromBrowserContext(browser_context);
   if (!profile || !profile->GetExtensionService())
     return false;
 
   const Extension* extension =
       profile->GetExtensionService()->GetExtensionByURL(effective_url);
   if (!extension)
     return false;
 
   // If the URL is part of a hosted app that does not have the background
   // permission, we want to give each instance its own process to improve
@@ skipping 48 matching lines @@
       command_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir);
 #if defined(OS_CHROMEOS)
     const std::string& login_profile =
         browser_command_line.GetSwitchValueASCII(switches::kLoginProfile);
     if (!login_profile.empty())
       command_line->AppendSwitchASCII(switches::kLoginProfile, login_profile);
 #endif
 
     RenderProcessHost* process = RenderProcessHost::FromID(child_process_id);
 
-    PrefService* prefs = process->profile()->GetPrefs();
+    Profile* profile = Profile::FromBrowserContext(process->browser_context());
+    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);
     }
 
     // Disable client-side phishing detection in the renderer if it is disabled
     // in the Profile preferences or the browser process.
     if (!prefs->GetBoolean(prefs::kSafeBrowsingEnabled) ||
@@ skipping 72 matching lines @@
     command_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
                                    arraysize(kSwitchNames));
   }
 }
 
 std::string ChromeContentBrowserClient::GetApplicationLocale() {
   return g_browser_process->GetApplicationLocale();
 }
 
 std::string ChromeContentBrowserClient::GetAcceptLangs(const TabContents* tab) {
-  return tab->profile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
+  Profile* profile = Profile::FromBrowserContext(tab->browser_context());
+  return profile->GetPrefs()->GetString(prefs::kAcceptLanguages);
 }
 
 SkBitmap* ChromeContentBrowserClient::GetDefaultFavicon() {
   ResourceBundle &rb = ResourceBundle::GetSharedInstance();
   return rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
 }
 
 bool ChromeContentBrowserClient::AllowAppCache(
     const GURL& manifest_url,
     const content::ResourceContext& context) {
@@ skipping 158 matching lines @@
     int render_process_id,
     int render_view_id) {
   RenderViewHost* rvh = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!rvh) {
     NOTREACHED();
     return;
   }
 
   RenderProcessHost* process = rvh->process();
+  Profile* profile = Profile::FromBrowserContext(process->browser_context());
   DesktopNotificationService* service =
-      DesktopNotificationServiceFactory::GetForProfile(process->profile());
+      DesktopNotificationServiceFactory::GetForProfile(profile);
   service->RequestPermission(
       source_origin, render_process_id, render_view_id, callback_context,
       tab_util::GetTabContentsByID(render_process_id, render_view_id));
 }
 
 WebKit::WebNotificationPresenter::Permission
     ChromeContentBrowserClient::CheckDesktopNotificationPermission(
         const GURL& source_url,
         const content::ResourceContext& context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 20 matching lines @@
     int render_view_id,
     bool worker) {
   RenderViewHost* rvh = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!rvh) {
     NOTREACHED();
     return;
   }
 
   RenderProcessHost* process = rvh->process();
+  Profile* profile = Profile::FromBrowserContext(process->browser_context());
   DesktopNotificationService* service =
-      DesktopNotificationServiceFactory::GetForProfile(process->profile());
+      DesktopNotificationServiceFactory::GetForProfile(profile);
   service->ShowDesktopNotification(
     params, render_process_id, render_view_id,
     worker ? DesktopNotificationService::WorkerNotification :
         DesktopNotificationService::PageNotification);
 }
 
 void ChromeContentBrowserClient::CancelDesktopNotification(
     int render_process_id,
     int render_view_id,
     int notification_id) {
   RenderViewHost* rvh = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!rvh) {
     NOTREACHED();
     return;
   }
 
   RenderProcessHost* process = rvh->process();
+  Profile* profile = Profile::FromBrowserContext(process->browser_context());
   DesktopNotificationService* service =
-      DesktopNotificationServiceFactory::GetForProfile(process->profile());
+      DesktopNotificationServiceFactory::GetForProfile(profile);
   service->CancelDesktopNotification(
       render_process_id, render_view_id, notification_id);
 }
 
 bool ChromeContentBrowserClient::CanCreateWindow(
     const GURL& source_url,
     WindowContainerType container_type,
     const content::ResourceContext& context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // If the opener is trying to create a background window but doesn't have
@@ skipping 41 matching lines @@
 
 net::NetLog* ChromeContentBrowserClient::GetNetLog() {
   return g_browser_process->net_log();
 }
 
 bool ChromeContentBrowserClient::IsFastShutdownPossible() {
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   return !browser_command_line.HasSwitch(switches::kChromeFrame);
 }
 
-WebPreferences ChromeContentBrowserClient::GetWebkitPrefs(Profile* profile,
-                                                          bool is_web_ui) {
-  return RenderViewHostDelegateHelper::GetWebkitPrefs(profile, is_web_ui);
+WebPreferences ChromeContentBrowserClient::GetWebkitPrefs(
+    content::BrowserContext* browser_context, bool is_web_ui) {
+  return RenderViewHostDelegateHelper::GetWebkitPrefs(browser_context,
+                                                      is_web_ui);
 }
 
 void ChromeContentBrowserClient::UpdateInspectorSetting(
     RenderViewHost* rvh, const std::string& key, const std::string& value) {
   RenderViewHostDelegateHelper::UpdateInspectorSetting(
-      rvh->process()->profile(), key, value);
+      rvh->process()->browser_context(), key, value);
 }
 
 void ChromeContentBrowserClient::ClearInspectorSettings(RenderViewHost* rvh) {
   RenderViewHostDelegateHelper::ClearInspectorSettings(
-      rvh->process()->profile());
+      rvh->process()->browser_context());
 }
 
 void ChromeContentBrowserClient::BrowserURLHandlerCreated(
     BrowserURLHandler* handler) {
   // Add the default URL handlers.
   handler->AddHandlerPair(&ExtensionWebUI::HandleChromeURLOverride,
                           BrowserURLHandler::null_handler());
   handler->AddHandlerPair(BrowserURLHandler::null_handler(),
                           &ExtensionWebUI::HandleChromeURLOverrideReverse);
 
   // about:
   handler->AddHandlerPair(&WillHandleBrowserAboutURL,
                           BrowserURLHandler::null_handler());
   // chrome: & friends.
   handler->AddHandlerPair(&HandleWebUI,
                           BrowserURLHandler::null_handler());
 }
 
 void ChromeContentBrowserClient::ClearCache(RenderViewHost* rvh) {
-  Profile* profile = rvh->site_instance()->GetProcess()->profile();
+  Profile* profile = Profile::FromBrowserContext(
+      rvh->site_instance()->GetProcess()->browser_context());
   BrowsingDataRemover* remover = new BrowsingDataRemover(profile,
       BrowsingDataRemover::EVERYTHING,
       base::Time());
   remover->Remove(BrowsingDataRemover::REMOVE_CACHE);
   // BrowsingDataRemover takes care of deleting itself when done.
 }
 
 void ChromeContentBrowserClient::ClearCookies(RenderViewHost* rvh) {
-  Profile* profile = rvh->site_instance()->GetProcess()->profile();
+  Profile* profile = Profile::FromBrowserContext(
+      rvh->site_instance()->GetProcess()->browser_context());
   BrowsingDataRemover* remover = new BrowsingDataRemover(profile,
       BrowsingDataRemover::EVERYTHING,
       base::Time());
   int remove_mask = BrowsingDataRemover::REMOVE_COOKIES;
   remover->Remove(remove_mask);
   // BrowsingDataRemover takes care of deleting itself when done.
 }
 
 void ChromeContentBrowserClient::GetSaveDir(TabContents* tab_contents,
                                             FilePath* website_save_dir,
@@ skipping 55 matching lines @@
 #if defined(USE_NSS)
 crypto::CryptoModuleBlockingPasswordDelegate*
     ChromeContentBrowserClient::GetCryptoPasswordDelegate(
         const GURL& url) {
   return browser::NewCryptoModuleBlockingDialogDelegate(
       browser::kCryptoModulePasswordKeygen, url.host());
 }
 #endif
 
 }  // namespace chrome