Define the public interface for content browser SiteInstance. This interface is implemented by th...

content/browser/tab_contents/render_view_host_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 "content/browser/tab_contents/render_view_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/browser/debugger/devtools_manager_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
-#include "content/browser/site_instance.h"
+#include "content/browser/site_instance_impl.h"
 #include "content/browser/tab_contents/navigation_controller_impl.h"
 #include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/webui/web_ui_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_ui_controller.h"
@@ skipping 27 matching lines @@
 
   // 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(content::BrowserContext* browser_context,
-                                 SiteInstance* site_instance,
+                                 content::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(browser_context);
+    site_instance = content::SiteInstance::CreateSiteInstance(
+        browser_context);
   render_view_host_ = RenderViewHostFactory::Create(
       site_instance, render_view_delegate_, routing_id, delegate_->
       GetControllerForRenderManager().GetSessionStorageNamespace());
 
   // Keep track of renderer processes as they start to shut down.
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  content::NotificationService::AllSources());
 }
 
 RenderWidgetHostView* RenderViewHostManager::GetRenderWidgetHostView() const {
@@ skipping 258 matching lines @@
     const NavigationEntryImpl* new_entry) const {
   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->GetURL() :
-      render_view_host_->site_instance()->site();
+      render_view_host_->site_instance()->GetSite();
   content::BrowserContext* browser_context =
       delegate_->GetControllerForRenderManager().GetBrowserContext();
   const content::WebUIFactory* web_ui_factory =
       content::GetContentClient()->browser()->GetWebUIFactory();
   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(browser_context,
                                                  new_entry->GetURL()))
       return true;
   } else {
@@ skipping 13 matching lines @@
   // We can't switch a RenderView between view source and non-view source mode
   // without screwing up the session history sometimes (when navigating between
   // "view-source:http://foo.com/" and "http://foo.com/", WebKit doesn't treat
   // it as a new navigation). So require a view switch.
   if (cur_entry->IsViewSourceMode() != new_entry->IsViewSourceMode())
     return true;
 
   return false;
 }
 
-SiteInstance* RenderViewHostManager::GetSiteInstanceForEntry(
+content::SiteInstance* RenderViewHostManager::GetSiteInstanceForEntry(
     const NavigationEntryImpl& entry,
-    SiteInstance* curr_instance) {
+    content::SiteInstance* curr_instance) {
   // NOTE: This is only called when ShouldTransitionCrossSite is true.
 
   const GURL& dest_url = entry.GetURL();
   NavigationControllerImpl& controller =
       delegate_->GetControllerForRenderManager();
   content::BrowserContext* browser_context = controller.GetBrowserContext();
 
   // If the entry has an instance already we should use it.
   if (entry.site_instance())
     return entry.site_instance();
 
   // (UGLY) HEURISTIC, process-per-site only:
   //
   // If this navigation is generated, then it probably corresponds to a search
   // query.  Given that search results typically lead to users navigating to
   // other sites, we don't really want to use the search engine hostname to
   // determine the site instance for this navigation.
   //
   // NOTE: This can be removed once we have a way to transition between
   //       RenderViews in response to a link click.
   //
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kProcessPerSite) &&
       entry.GetTransitionType() == content::PAGE_TRANSITION_GENERATED)
     return curr_instance;
 
   // If we haven't used our SiteInstance (and thus RVH) yet, then we can use it
   // for this entry.  We won't commit the SiteInstance to this site until the
   // navigation commits (in DidNavigate), unless the navigation entry was
   // restored or it's a Web UI as described below.
-  if (!curr_instance->has_site()) {
+  if (!curr_instance->HasSite()) {
     // If we've already created a SiteInstance for our destination, we don't
     // want to use this unused SiteInstance; use the existing one.  (We don't
     // do this check if the curr_instance has a site, because for now, we want
     // 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, Web UI URLs (such as the new tab page), and apps we do
@@ skipping 37 matching lines @@
   // has a site), then we must have been opened from another tab.  We want
   // to compare against the URL of the page that opened us, but we can't
   // get to it directly.  The best we can do is check against the site of
   // the SiteInstance.  This will be correct when we intercept links and
   // script-based navigations, but for now, it could place some pages in a
   // 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->GetURL() :
-      curr_instance->site();
+      curr_instance->GetSite();
 
   // 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(browser_context, current_url, dest_url) &&
+  if (content::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(browser_context, dest_url);
+    return content::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);
   }
 }
 
 bool RenderViewHostManager::CreatePendingRenderView(
-    const NavigationEntryImpl& entry, SiteInstance* instance) {
+  const NavigationEntryImpl& entry, content::SiteInstance* instance) {
   NavigationEntry* curr_entry =
       delegate_->GetControllerForRenderManager().GetLastCommittedEntry();
   if (curr_entry) {
     DCHECK(!curr_entry->GetContentState().empty());
     // TODO(creis): Should send a message to the RenderView to let it know
     // we're about to switch away, so that it sends an UpdateState message.
   }
 
   // Check if we've already created an RVH for this SiteInstance.
   CHECK(instance);
   RenderViewHostMap::iterator iter =
-      swapped_out_hosts_.find(instance->id());
+      swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end()) {
     // Re-use the existing RenderViewHost, which has already been initialized.
     // We'll remove it from the list of swapped out hosts if it commits.
     pending_render_view_host_ = iter->second;
 
     // Prevent the process from exiting while we're trying to use it.
     pending_render_view_host_->process()->AddPendingView();
 
     return true;
   }
@@ skipping 84 matching lines @@
 
   std::pair<RenderViewHost*, RenderViewHost*> details =
       std::make_pair(old_render_view_host, render_view_host_);
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
       content::Source<NavigationController>(
           &delegate_->GetControllerForRenderManager()),
       content::Details<std::pair<RenderViewHost*, RenderViewHost*> >(&details));
 
   // If the pending view was on the swapped out list, we can remove it.
-  swapped_out_hosts_.erase(render_view_host_->site_instance()->id());
+  swapped_out_hosts_.erase(render_view_host_->site_instance()->GetId());
 
   // If the old RVH is live, we are swapping it out and should keep track of it
   // in case we navigate back to it.
   if (old_render_view_host->IsRenderViewLive()) {
     DCHECK(old_render_view_host->is_swapped_out());
     // Temp fix for http://crbug.com/90867 until we do a better cleanup to make
     // sure we don't get different rvh instances for the same site instance
     // in the same rvhmgr.
     // TODO(creis): Clean this up.
-    int32 old_site_instance_id = old_render_view_host->site_instance()->id();
+    int32 old_site_instance_id = old_render_view_host->site_instance()->GetId();
     RenderViewHostMap::iterator iter =
         swapped_out_hosts_.find(old_site_instance_id);
     if (iter != swapped_out_hosts_.end() &&
         iter->second != old_render_view_host) {
       // Shutdown the RVH that will be replaced in the map to avoid a leak.
       iter->second->Shutdown();
     }
     swapped_out_hosts_[old_site_instance_id] = old_render_view_host;
   } else {
     old_render_view_host->Shutdown();
@@ skipping 17 matching lines @@
   // This will possibly create (set to NULL) a Web UI object for the pending
   // page. We'll use this later to give the page special access. This must
   // happen before the new renderer is created below so it will get bindings.
   // It must also happen after the above conditional call to CancelPending(),
   // otherwise CancelPending may clear the pending_web_ui_ and the page will
   // not have it's bindings set appropriately.
   pending_web_ui_.reset(delegate_->CreateWebUIForRenderManager(entry.GetURL()));
 
   // render_view_host_ will not be deleted before the end of this method, so we
   // don't have to worry about this SiteInstance's ref count dropping to zero.
-  SiteInstance* curr_instance = render_view_host_->site_instance();
+  content::SiteInstance* curr_instance = render_view_host_->site_instance();
 
   // Determine if we need a new SiteInstance for this entry.
   // Again, new_instance won't be deleted before the end of this method, so it
   // is safe to use a normal pointer here.
-  SiteInstance* new_instance = curr_instance;
+  content::SiteInstance* new_instance = curr_instance;
   bool force_swap = ShouldSwapProcessesForNavigation(
       delegate_->GetLastCommittedNavigationEntryForRenderManager(), &entry);
   if (ShouldTransitionCrossSite() || force_swap)
     new_instance = GetSiteInstanceForEntry(entry, curr_instance);
 
   if (new_instance != curr_instance || force_swap) {
     // New SiteInstance.
     DCHECK(!cross_navigation_pending_);
 
     // Create a pending RVH and navigate it.
@@ skipping 128 matching lines @@
       swapped_out_hosts_.erase(iter);
       break;
     }
   }
 }
 
 bool RenderViewHostManager::IsSwappedOut(RenderViewHost* rvh) {
   if (!rvh->site_instance())
     return false;
 
-  return swapped_out_hosts_.find(rvh->site_instance()->id()) !=
+  return swapped_out_hosts_.find(rvh->site_instance()->GetId()) !=
       swapped_out_hosts_.end();
 }