Removal of Profile from content part 1.

content/browser/tab_contents/render_view_host_manager.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 "content/browser/tab_contents/render_view_host_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/renderer_host/render_view_host.h"
@@ skipping 38 matching lines @@
   render_view_host->Shutdown();
 
   // Shut down any swapped out RenderViewHosts.
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     iter->second->Shutdown();
   }
 }
 
-void RenderViewHostManager::Init(Profile* profile,
+void RenderViewHostManager::Init(content::BrowserContext* context,
                                  SiteInstance* site_instance,
                                  int routing_id) {
   // Create a RenderViewHost, once we have an instance.  It is important to
   // immediately give this SiteInstance to a RenderViewHost so that it is
   // ref counted.
   if (!site_instance)
-    site_instance = SiteInstance::CreateSiteInstance(profile);
+    site_instance = SiteInstance::CreateSiteInstance(context);
   render_view_host_ = RenderViewHostFactory::Create(
       site_instance, render_view_delegate_, routing_id, delegate_->
       GetControllerForRenderManager().session_storage_namespace());
 
   // Keep track of renderer processes as they start to shut down.
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  NotificationService::AllSources());
 }
 
 RenderWidgetHostView* RenderViewHostManager::GetRenderWidgetHostView() const {
@@ skipping 262 matching lines @@
   DCHECK(new_entry);
 
   // Check for reasons to swap processes even if we are in a process model that
   // doesn't usually swap (e.g., process-per-tab).
 
   // For security, we should transition between processes when one is a Web UI
   // page and one isn't.  If there's no cur_entry, check the current RVH's
   // site, which might already be committed to a Web UI URL (such as the NTP).
   const GURL& current_url = (cur_entry) ? cur_entry->url() :
       render_view_host_->site_instance()->site();
-  Profile* profile = delegate_->GetControllerForRenderManager().profile();
+  content::BrowserContext* browser_context =
+      delegate_->GetControllerForRenderManager().browser_context();
   const content::WebUIFactory* web_ui_factory = content::WebUIFactory::Get();
-  if (web_ui_factory->UseWebUIForURL(profile, current_url)) {
+  if (web_ui_factory->UseWebUIForURL(browser_context, current_url)) {
     // Force swap if it's not an acceptable URL for Web UI.
-    if (!web_ui_factory->IsURLAcceptableForWebUI(profile, new_entry->url()))
+    if (!web_ui_factory->IsURLAcceptableForWebUI(browser_context,
+                                                 new_entry->url()))
       return true;
   } else {
     // Force swap if it's a Web UI URL.
-    if (web_ui_factory->UseWebUIForURL(profile, new_entry->url()))
+    if (web_ui_factory->UseWebUIForURL(browser_context, new_entry->url()))
       return true;
   }
 
   if (!cur_entry) {
     // Always choose a new process when navigating to extension URLs. The
     // process grouping logic will combine all of a given extension's pages
     // into the same process.
     if (new_entry->url().SchemeIs(chrome::kExtensionScheme))
       return true;
 
@@ skipping 18 matching lines @@
   return false;
 }
 
 SiteInstance* RenderViewHostManager::GetSiteInstanceForEntry(
     const NavigationEntry& entry,
     SiteInstance* curr_instance) {
   // NOTE: This is only called when ShouldTransitionCrossSite is true.
 
   const GURL& dest_url = entry.url();
   NavigationController& controller = delegate_->GetControllerForRenderManager();
-  Profile* profile = controller.profile();
+  content::BrowserContext* browser_context = controller.browser_context();
 
   // If the entry has an instance already we should use it, unless the URL
   // is part of an app that has been installed or uninstalled since the last
   // visit.
   if (entry.site_instance()) {
     if (entry.site_instance()->HasWrongProcessForURL(dest_url))
       return curr_instance->GetRelatedSiteInstance(dest_url);
     else
       return entry.site_instance();
   }
@@ skipping 23 matching lines @@
     // to compare against the current URL and not the SiteInstance's site.  In
     // this case, there is no current URL, so comparing against the site is ok.
     // See additional comments below.)
     if (curr_instance->HasRelatedSiteInstance(dest_url))
       return curr_instance->GetRelatedSiteInstance(dest_url);
 
     // For extensions and Web UI URLs (such as the new tab page), we do not
     // want to use the curr_instance if it has no site, since it will have a
     // RenderProcessHost of TYPE_NORMAL.  Create a new SiteInstance for this
     // URL instead (with the correct process type).
-    if (content::WebUIFactory::Get()->UseWebUIForURL(profile, dest_url)) {
-      return SiteInstance::CreateSiteInstanceForURL(profile, dest_url);
+    if (content::WebUIFactory::Get()->UseWebUIForURL(browser_context,
+                                                     dest_url)) {
+      return SiteInstance::CreateSiteInstanceForURL(browser_context, dest_url);
     }
 
     // Normally the "site" on the SiteInstance is set lazily when the load
     // actually commits. This is to support better process sharing in case
     // the site redirects to some other site: we want to use the destination
     // site in the site instance.
     //
     // In the case of session restore, as it loads all the pages immediately
     // we need to set the site first, otherwise after a restore none of the
     // pages would share renderers in process-per-site.
@@ skipping 28 matching lines @@
   // new process unnecessarily.  We should only hit this case if a page tries
   // to open a new tab to an interstitial-inducing URL, and then navigates
   // the page to a different same-site URL.  (This seems very unlikely in
   // practice.)
   const GURL& current_url = (curr_entry) ? curr_entry->url() :
       curr_instance->site();
 
   // Use the current SiteInstance for same site navigations, as long as the
   // process type is correct.  (The URL may have been installed as an app since
   // the last time we visited it.)
-  if (SiteInstance::IsSameWebSite(profile, current_url, dest_url) &&
+  if (SiteInstance::IsSameWebSite(browser_context, current_url, dest_url) &&
       !curr_instance->HasWrongProcessForURL(dest_url)) {
     return curr_instance;
   } else if (ShouldSwapProcessesForNavigation(curr_entry, &entry)) {
     // When we're swapping, we need to force the site instance AND browsing
     // instance to be different ones. This addresses special cases where we use
     // a single BrowsingInstance for all pages of a certain type (e.g., New Tab
     // Pages), keeping them in the same process. When you navigate away from
     // that page, we want to explicity ignore that BrowsingInstance and group
     // this page into the appropriate SiteInstance for its URL.
-    return SiteInstance::CreateSiteInstanceForURL(profile, dest_url);
+    return SiteInstance::CreateSiteInstanceForURL(browser_context, dest_url);
   } else {
     // Start the new renderer in a new SiteInstance, but in the current
     // BrowsingInstance.  It is important to immediately give this new
     // SiteInstance to a RenderViewHost (if it is different than our current
     // SiteInstance), so that it is ref counted.  This will happen in
     // CreatePendingRenderView.
     return curr_instance->GetRelatedSiteInstance(dest_url);
   }
 }
 
@@ skipping 352 matching lines @@
   delegate_->NotifySwappedFromRenderManager();
 }
 
 bool RenderViewHostManager::IsSwappedOut(RenderViewHost* rvh) {
   if (!rvh->site_instance())
     return false;
 
   return swapped_out_hosts_.find(rvh->site_instance()->id()) !=
       swapped_out_hosts_.end();
 }