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"
 #include "content/public/browser/web_ui_factory.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::NavigationEntryImpl;
+using content::SiteInstance;
 
 RenderViewHostManager::RenderViewHostManager(
     content::RenderViewHostDelegate* render_view_delegate,
     Delegate* delegate)
     : delegate_(delegate),
       cross_navigation_pending_(false),
       render_view_delegate_(render_view_delegate),
       render_view_host_(NULL),
       pending_render_view_host_(NULL),
       interstitial_page_(NULL) {
@@ skipping 16 matching lines @@
   }
 }
 
 void RenderViewHostManager::Init(content::BrowserContext* browser_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(browser_context);
+    site_instance = SiteInstance::Create(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 41 matching lines @@
   // 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;
 
+  SiteInstanceImpl* curr_site_instance =
+      static_cast<SiteInstanceImpl*>(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_site_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);
+    if (curr_site_instance->HasRelatedSiteInstance(dest_url))
+      return curr_site_instance->GetRelatedSiteInstance(dest_url);
 
     // For extensions, Web UI URLs (such as the new tab page), and apps we do
     // not want to use the curr_instance if it has no site, since it will have a
     // RenderProcessHost of PRIV_NORMAL.  Create a new SiteInstance for this
     // URL instead (with the correct process type).
-    if (curr_instance->HasWrongProcessForURL(dest_url))
-      return curr_instance->GetRelatedSiteInstance(dest_url);
+    if (curr_site_instance->HasWrongProcessForURL(dest_url))
+      return curr_site_instance->GetRelatedSiteInstance(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.
     if (entry.restore_type() != NavigationEntryImpl::RESTORE_NONE)
-      curr_instance->SetSite(dest_url);
+      curr_site_instance->SetSite(dest_url);
 
-    return curr_instance;
+    return curr_site_instance;
   }
 
   // Otherwise, only create a new SiteInstance for cross-site navigation.
 
   // TODO(creis): Once we intercept links and script-based navigations, we
   // will be able to enforce that all entries in a SiteInstance actually have
   // the same site, and it will be safe to compare the URL against the
   // SiteInstance's site, as follows:
   // const GURL& current_url = curr_instance->site();
   // For now, though, we're in a hybrid model where you only switch
   // SiteInstances if you type in a cross-site URL.  This means we have to
   // compare the entry's URL to the last committed entry's URL.
   NavigationEntry* curr_entry = controller.GetLastCommittedEntry();
   if (interstitial_page_) {
     // The interstitial is currently the last committed entry, but we want to
     // compare against the last non-interstitial entry.
     curr_entry = controller.GetEntryAtOffset(-1);
   }
   // If there is no last non-interstitial entry (and curr_instance already
   // 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) &&
-      !curr_instance->HasWrongProcessForURL(dest_url)) {
+      !static_cast<SiteInstanceImpl*>(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 SiteInstance::CreateForURL(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, 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 171 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();
 }