Inside of content, prefer SiteInstanceImpl to SiteInstance.

content/browser/frame_host/render_frame_host_manager.cc

 // Copyright 2013 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/frame_host/render_frame_host_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 66 matching lines @@
   // It is important to delete those prior to deleting the current
   // RenderFrameHost, since the CrossProcessFrameConnector (owned by
   // RenderFrameProxyHost) points to the RenderWidgetHostView associated with
   // the current RenderFrameHost and uses it during its destructor.
   ResetProxyHosts();
 
   // We should always have a current RenderFrameHost except in some tests.
   SetRenderFrameHost(scoped_ptr<RenderFrameHostImpl>());
 }
 
-void RenderFrameHostManager::Init(SiteInstance* site_instance,
+void RenderFrameHostManager::Init(SiteInstanceImpl* site_instance,
                                   int32_t view_routing_id,
                                   int32_t frame_routing_id,
                                   int32_t widget_routing_id) {
   DCHECK(site_instance);
   // TODO(avi): While RenderViewHostImpl is-a RenderWidgetHostImpl, this must
   // hold true to avoid having two RenderWidgetHosts for the top-level frame.
   // https://crbug.com/545684
   DCHECK(!frame_tree_node_->IsMainFrame() ||
          view_routing_id == widget_routing_id);
   SetRenderFrameHost(CreateRenderFrameHost(site_instance, view_routing_id,
@@ skipping 459 matching lines @@
       }
     }
   } else {
     // No one else should be sending us DidNavigate in this state.
     NOTREACHED();
   }
 }
 
 void RenderFrameHostManager::DidChangeOpener(
     int opener_routing_id,
-    SiteInstance* source_site_instance) {
+    SiteInstanceImpl* source_site_instance) {
   FrameTreeNode* opener = nullptr;
   if (opener_routing_id != MSG_ROUTING_NONE) {
     RenderFrameHostImpl* opener_rfhi = RenderFrameHostImpl::FromID(
         source_site_instance->GetProcess()->GetID(), opener_routing_id);
     // If |opener_rfhi| is null, the opener RFH has already disappeared.  In
     // this case, clear the opener rather than keeping the old opener around.
     if (opener_rfhi)
       opener = opener_rfhi->frame_tree_node();
   }
 
@@ skipping 29 matching lines @@
 void RenderFrameHostManager::CommitPendingSandboxFlags() {
   // Return early if there were no pending sandbox flags updates.
   if (!frame_tree_node_->CommitPendingSandboxFlags())
     return;
 
   // Sandbox flags updates can only happen when the frame has a parent.
   CHECK(frame_tree_node_->parent());
 
   // Notify all of the frame's proxies about updated sandbox flags, excluding
   // the parent process since it already knows the latest flags.
-  SiteInstance* parent_site_instance =
+  SiteInstanceImpl* parent_site_instance =
       frame_tree_node_->parent()->current_frame_host()->GetSiteInstance();
   for (const auto& pair : proxy_hosts_) {
     if (pair.second->GetSiteInstance() != parent_site_instance) {
       pair.second->Send(new FrameMsg_DidUpdateSandboxFlags(
           pair.second->GetRoutingID(),
           frame_tree_node_->current_replication_state().sandbox_flags));
     }
   }
 }
 
@@ skipping 148 matching lines @@
   CHECK(IsBrowserSideNavigationEnabled());
   RenderFrameHostImpl* dest_rfh = GetFrameHostForNavigation(request);
   DCHECK(dest_rfh);
 }
 
 // PlzNavigate
 RenderFrameHostImpl* RenderFrameHostManager::GetFrameHostForNavigation(
     const NavigationRequest& request) {
   CHECK(IsBrowserSideNavigationEnabled());
 
-  SiteInstance* current_site_instance = render_frame_host_->GetSiteInstance();
+  SiteInstanceImpl* current_site_instance =
+      render_frame_host_->GetSiteInstance();
 
-  SiteInstance* candidate_site_instance =
+  SiteInstanceImpl* candidate_site_instance =
       speculative_render_frame_host_
           ? speculative_render_frame_host_->GetSiteInstance()
           : nullptr;
 
-  scoped_refptr<SiteInstance> dest_site_instance = GetSiteInstanceForNavigation(
-      request.common_params().url, request.source_site_instance(),
-      request.dest_site_instance(), candidate_site_instance,
-      request.common_params().transition,
-      request.restore_type() != NavigationEntryImpl::RESTORE_NONE,
-      request.is_view_source());
+  scoped_refptr<SiteInstanceImpl> dest_site_instance =
+      GetSiteInstanceForNavigation(
+          request.common_params().url, request.source_site_instance(),
+          request.dest_site_instance(), candidate_site_instance,
+          request.common_params().transition,
+          request.restore_type() != NavigationEntryImpl::RESTORE_NONE,
+          request.is_view_source());
 
   // The appropriate RenderFrameHost to commit the navigation.
   RenderFrameHostImpl* navigation_rfh = nullptr;
 
   bool notify_webui_of_rv_creation = false;
 
   // Reuse the current RenderFrameHost if its SiteInstance matches the
   // navigation's.
   bool no_renderer_swap = current_site_instance == dest_site_instance.get();
   if (SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
@@ skipping 202 matching lines @@
     SiteInstanceImpl* site_instance) {
   // |site_instance| no longer contains any active RenderFrameHosts, so we don't
   // need to maintain a proxy there anymore.
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(site_instance);
   CHECK(proxy);
 
   DeleteRenderFrameProxyHost(site_instance);
 }
 
 RenderFrameProxyHost* RenderFrameHostManager::CreateRenderFrameProxyHost(
-    SiteInstance* site_instance,
+    SiteInstanceImpl* site_instance,
     RenderViewHostImpl* rvh) {
   int site_instance_id = site_instance->GetId();
   CHECK(proxy_hosts_.find(site_instance_id) == proxy_hosts_.end())
       << "A proxy already existed for this SiteInstance.";
   RenderFrameProxyHost* proxy_host =
       new RenderFrameProxyHost(site_instance, rvh, frame_tree_node_);
   proxy_hosts_[site_instance_id] = make_scoped_ptr(proxy_host);
   static_cast<SiteInstanceImpl*>(site_instance)->AddObserver(this);
   return proxy_host;
 }
 
 void RenderFrameHostManager::DeleteRenderFrameProxyHost(
-    SiteInstance* site_instance) {
+    SiteInstanceImpl* site_instance) {
   static_cast<SiteInstanceImpl*>(site_instance)->RemoveObserver(this);
   proxy_hosts_.erase(site_instance->GetId());
 }
 
 bool RenderFrameHostManager::ShouldTransitionCrossSite() {
   // The logic below is weaker than "are all sites isolated" -- it asks instead,
   // "is any site isolated". That's appropriate here since we're just trying to
   // figure out if we're in any kind of site isolated mode, and in which case,
   // we ignore the kSingleProcess and kProcessPerTab settings.
   //
@@ skipping 11 matching lines @@
   // SiteIsolationPolicy.
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kSingleProcess) &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kProcessPerTab);
 }
 
 bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation(
     const GURL& current_effective_url,
     bool current_is_view_source_mode,
-    SiteInstance* new_site_instance,
+    SiteInstanceImpl* new_site_instance,
     const GURL& new_effective_url,
     bool new_is_view_source_mode) const {
   // A subframe must stay in the same BrowsingInstance as its parent.
   // TODO(nasko): Ensure that SiteInstance swap is still triggered for subframes
   // in the cases covered by the rest of the checks in this method.
   if (!frame_tree_node_->IsMainFrame())
     return false;
 
   // If new_entry already has a SiteInstance, assume it is correct.  We only
   // need to force a swap if it is in a different BrowsingInstance.
@@ skipping 54 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/", Blink doesn't treat
   // it as a new navigation). So require a BrowsingInstance switch.
   if (current_is_view_source_mode != new_is_view_source_mode)
     return true;
 
   return false;
 }
 
-scoped_refptr<SiteInstance>
+scoped_refptr<SiteInstanceImpl>
 RenderFrameHostManager::GetSiteInstanceForNavigation(
     const GURL& dest_url,
-    SiteInstance* source_instance,
-    SiteInstance* dest_instance,
-    SiteInstance* candidate_instance,
+    SiteInstanceImpl* source_instance,
+    SiteInstanceImpl* dest_instance,
+    SiteInstanceImpl* candidate_instance,
     ui::PageTransition transition,
     bool dest_is_restore,
     bool dest_is_view_source_mode) {
-  SiteInstance* current_instance = render_frame_host_->GetSiteInstance();
+  SiteInstanceImpl* current_instance = render_frame_host_->GetSiteInstance();
 
   // We do not currently swap processes for navigations in webview tag guests.
   if (current_instance->GetSiteURL().SchemeIs(kGuestScheme))
     return current_instance;
 
   // Determine if we need a new BrowsingInstance for this entry.  If true, this
   // implies that it will get a new SiteInstance (and likely process), and that
   // other tabs in the current BrowsingInstance will be unable to script it.
   // This is used for cases that require a process swap even in the
   // process-per-tab model, such as WebUI pages.
@@ skipping 15 matching lines @@
       SiteInstanceImpl::GetEffectiveURL(browser_context, dest_url),
       dest_is_view_source_mode);
   SiteInstanceDescriptor new_instance_descriptor =
       SiteInstanceDescriptor(current_instance);
   if (ShouldTransitionCrossSite() || force_swap) {
     new_instance_descriptor = DetermineSiteInstanceForURL(
         dest_url, source_instance, current_instance, dest_instance, transition,
         dest_is_restore, dest_is_view_source_mode, force_swap);
   }
 
-  scoped_refptr<SiteInstance> new_instance =
+  scoped_refptr<SiteInstanceImpl> new_instance =
       ConvertToSiteInstance(new_instance_descriptor, candidate_instance);
   // If |force_swap| is true, we must use a different SiteInstance than the
   // current one. If we didn't, we would have two RenderFrameHosts in the same
   // SiteInstance and the same frame, resulting in page_id conflicts for their
   // NavigationEntries.
   if (force_swap)
     CHECK_NE(new_instance, current_instance);
 
   return new_instance;
 }
 
 RenderFrameHostManager::SiteInstanceDescriptor
 RenderFrameHostManager::DetermineSiteInstanceForURL(
     const GURL& dest_url,
-    SiteInstance* source_instance,
-    SiteInstance* current_instance,
-    SiteInstance* dest_instance,
+    SiteInstanceImpl* source_instance,
+    SiteInstanceImpl* current_instance,
+    SiteInstanceImpl* dest_instance,
     ui::PageTransition transition,
     bool dest_is_restore,
     bool dest_is_view_source_mode,
     bool force_browsing_instance_swap) {
   SiteInstanceImpl* current_instance_impl =
       static_cast<SiteInstanceImpl*>(current_instance);
   NavigationControllerImpl& controller =
       delegate_->GetControllerForRenderManager();
   BrowserContext* browser_context = controller.GetBrowserContext();
 
@@ skipping 220 matching lines @@
   if (SiteIsolationPolicy::IsTopDocumentIsolationEnabled() &&
       (!frame_tree_node_->IsMainFrame() ||
        rfh->GetSiteInstance()->is_default_subframe_site_instance())) {
     // Always attempt a transfer in these cases.
     return true;
   }
 
   return false;
 }
 
-scoped_refptr<SiteInstance> RenderFrameHostManager::ConvertToSiteInstance(
+scoped_refptr<SiteInstanceImpl> RenderFrameHostManager::ConvertToSiteInstance(
     const SiteInstanceDescriptor& descriptor,
-    SiteInstance* candidate_instance) {
+    SiteInstanceImpl* candidate_instance) {
   SiteInstanceImpl* current_instance = render_frame_host_->GetSiteInstance();
 
   // Note: If the |candidate_instance| matches the descriptor, it will already
   // be set to |descriptor.existing_site_instance|.
   if (descriptor.existing_site_instance)
     return descriptor.existing_site_instance;
 
   // Note: If the |candidate_instance| matches the descriptor,
   // GetRelatedSiteInstance will return it.
   if (descriptor.relation == SiteInstanceRelation::RELATED)
-    return current_instance->GetRelatedSiteInstance(descriptor.new_site_url);
+    return current_instance->GetRelatedSiteInstanceImpl(
+        descriptor.new_site_url);
 
   if (descriptor.relation == SiteInstanceRelation::RELATED_DEFAULT_SUBFRAME)
     return current_instance->GetDefaultSubframeSiteInstance();
 
   // At this point we know an unrelated site instance must be returned. First
   // check if the candidate matches.
   if (candidate_instance &&
       !current_instance->IsRelatedSiteInstance(candidate_instance) &&
       candidate_instance->GetSiteURL() == descriptor.new_site_url) {
     return candidate_instance;
   }
 
   // Otherwise return a newly created one.
-  return SiteInstance::CreateForURL(
+  return SiteInstanceImpl::CreateForURL(
       delegate_->GetControllerForRenderManager().GetBrowserContext(),
       descriptor.new_site_url);
 }
 
 bool RenderFrameHostManager::IsCurrentlySameSite(RenderFrameHostImpl* candidate,
                                                  const GURL& dest_url) {
   BrowserContext* browser_context =
       delegate_->GetControllerForRenderManager().GetBrowserContext();
 
   // If the process type is incorrect, reject the candidate even if |dest_url|
@@ skipping 30 matching lines @@
           browser_context,
           GURL(candidate->GetLastCommittedOrigin().Serialize()), dest_url)) {
     return true;
   }
 
   // Not same-site.
   return false;
 }
 
 void RenderFrameHostManager::CreatePendingRenderFrameHost(
-    SiteInstance* old_instance,
-    SiteInstance* new_instance) {
+    SiteInstanceImpl* old_instance,
+    SiteInstanceImpl* new_instance) {
   if (pending_render_frame_host_)
     CancelPending();
 
   // The process for the new SiteInstance may (if we're sharing a process with
   // another host that already initialized it) or may not (we have our own
   // process or the existing process crashed) have been initialized. Calling
   // Init multiple times will be ignored, so this is safe.
   if (!new_instance->GetProcess()->Init())
     return;
 
   CreateProxiesForNewRenderFrameHost(old_instance, new_instance);
 
   // Create a non-swapped-out RFH with the given opener.
   pending_render_frame_host_ =
       CreateRenderFrame(new_instance, delegate_->IsHidden(), nullptr);
 }
 
 void RenderFrameHostManager::CreateProxiesForNewRenderFrameHost(
-    SiteInstance* old_instance,
-    SiteInstance* new_instance) {
+    SiteInstanceImpl* old_instance,
+    SiteInstanceImpl* new_instance) {
   // Only create opener proxies if they are in the same BrowsingInstance.
   if (new_instance->IsRelatedSiteInstance(old_instance)) {
     CreateOpenerProxies(new_instance, frame_tree_node_);
   } else if (SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
     // Ensure that the frame tree has RenderFrameProxyHosts for the
     // new SiteInstance in all nodes except the current one.  We do this for
     // all frames in the tree, whether they are in the same BrowsingInstance or
     // not.  If |new_instance| is in the same BrowsingInstance as
     // |old_instance|, this will be done as part of CreateOpenerProxies above;
     // otherwise, we do this here.  We will still check whether two frames are
@@ skipping 11 matching lines @@
   DCHECK(!frame_tree_node_->frame_name().empty());
 
   // If this is a top-level frame, create proxies for this node in the
   // SiteInstances of its opener's ancestors, which are allowed to discover
   // this frame by name (see https://crbug.com/511474 and part 4 of
   // https://html.spec.whatwg.org/#the-rules-for-choosing-a-browsing-context-
   // given-a-browsing-context-name).
   FrameTreeNode* opener = frame_tree_node_->opener();
   if (!opener || !frame_tree_node_->IsMainFrame())
     return;
-  SiteInstance* current_instance = render_frame_host_->GetSiteInstance();
+  SiteInstanceImpl* current_instance = render_frame_host_->GetSiteInstance();
 
   // Start from opener's parent.  There's no need to create a proxy in the
   // opener's SiteInstance, since new windows are always first opened in the
   // same SiteInstance as their opener, and if the new window navigates
   // cross-site, that proxy would be created as part of swapping out.
   for (FrameTreeNode* ancestor = opener->parent(); ancestor;
        ancestor = ancestor->parent()) {
     RenderFrameHostImpl* ancestor_rfh = ancestor->current_frame_host();
     if (ancestor_rfh->GetSiteInstance() != current_instance)
       CreateRenderFrameProxy(ancestor_rfh->GetSiteInstance());
   }
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost(
-    SiteInstance* site_instance,
+    SiteInstanceImpl* site_instance,
     int32_t view_routing_id,
     int32_t frame_routing_id,
     int32_t widget_routing_id,
     bool hidden) {
   if (frame_routing_id == MSG_ROUTING_NONE)
     frame_routing_id = site_instance->GetProcess()->GetNextRoutingID();
 
   // Create a RVH for main frames, or find the existing one for subframes.
   FrameTree* frame_tree = frame_tree_node_->frame_tree();
   RenderViewHostImpl* render_view_host = nullptr;
@@ skipping 20 matching lines @@
   }
 
   return RenderFrameHostFactory::Create(
       site_instance, render_view_host, render_frame_delegate_,
       render_widget_delegate_, frame_tree, frame_tree_node_, frame_routing_id,
       widget_routing_id, hidden);
 }
 
 // PlzNavigate
 bool RenderFrameHostManager::CreateSpeculativeRenderFrameHost(
-    SiteInstance* old_instance,
-    SiteInstance* new_instance) {
+    SiteInstanceImpl* old_instance,
+    SiteInstanceImpl* new_instance) {
   CHECK(new_instance);
   CHECK_NE(old_instance, new_instance);
 
   // The process for the new SiteInstance may (if we're sharing a process with
   // another host that already initialized it) or may not (we have our own
   // process or the existing process crashed) have been initialized. Calling
   // Init multiple times will be ignored, so this is safe.
   if (!new_instance->GetProcess()->Init())
     return false;
 
   CreateProxiesForNewRenderFrameHost(old_instance, new_instance);
 
   speculative_render_frame_host_ =
       CreateRenderFrame(new_instance, delegate_->IsHidden(), nullptr);
 
   return !!speculative_render_frame_host_;
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrame(
-    SiteInstance* instance,
+    SiteInstanceImpl* instance,
     bool hidden,
     int* view_routing_id_ptr) {
   int32_t widget_routing_id = MSG_ROUTING_NONE;
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
 
   CHECK(instance);
   CHECK(SiteIsolationPolicy::AreCrossProcessFramesPossible() ||
         frame_tree_node_->IsMainFrame());
 
   scoped_ptr<RenderFrameHostImpl> new_render_frame_host;
@@ skipping 56 matching lines @@
   }
 
   // Return the new RenderFrameHost on successful creation.
   if (success) {
     DCHECK(new_render_frame_host->GetSiteInstance() == instance);
     return new_render_frame_host;
   }
   return nullptr;
 }
 
-int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstance* instance) {
+int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstanceImpl* instance) {
   // A RenderFrameProxyHost should never be created in the same SiteInstance as
   // the current RFH.
   CHECK(instance);
   CHECK_NE(instance, render_frame_host_->GetSiteInstance());
 
   RenderViewHostImpl* render_view_host = nullptr;
 
   // Ensure a RenderViewHost exists for |instance|, as it creates the page
   // level structure in Blink.
   render_view_host =
@@ skipping 29 matching lines @@
     if (pair.second.get() == outer_delegate_proxy)
       continue;
 
     child->render_manager()->CreateRenderFrameProxy(
         pair.second->GetSiteInstance());
   }
 }
 
 void RenderFrameHostManager::EnsureRenderViewInitialized(
     RenderViewHostImpl* render_view_host,
-    SiteInstance* instance) {
+    SiteInstanceImpl* instance) {
   DCHECK(frame_tree_node_->IsMainFrame());
 
   if (render_view_host->IsRenderViewLive())
     return;
 
   // If the proxy in |instance| doesn't exist, this RenderView is not swapped
   // out and shouldn't be reinitialized here.
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   if (!proxy)
     return;
 
   InitRenderView(render_view_host, proxy);
 }
 
 void RenderFrameHostManager::CreateOuterDelegateProxy(
-    SiteInstance* outer_contents_site_instance,
+    SiteInstanceImpl* outer_contents_site_instance,
     RenderFrameHostImpl* render_frame_host) {
   CHECK(BrowserPluginGuestMode::UseCrossProcessFramesForGuests());
   RenderFrameProxyHost* proxy =
       CreateRenderFrameProxyHost(outer_contents_site_instance, nullptr);
 
   // Swap the outer WebContents's frame with the proxy to inner WebContents.
   //
   // We are in the outer WebContents, and its FrameTree would never see
   // a load start for any of its inner WebContents. Eventually, that also makes
   // the FrameTree never see the matching load stop. Therefore, we always pass
@@ skipping 37 matching lines @@
     proxy->set_render_frame_proxy_created(true);
 
   return created;
 }
 
 bool RenderFrameHostManager::InitRenderFrame(
     RenderFrameHostImpl* render_frame_host) {
   if (render_frame_host->IsRenderFrameLive())
     return true;
 
-  SiteInstance* site_instance = render_frame_host->GetSiteInstance();
+  SiteInstanceImpl* site_instance = render_frame_host->GetSiteInstance();
 
   int opener_routing_id = MSG_ROUTING_NONE;
   if (frame_tree_node_->opener())
     opener_routing_id = GetOpenerRoutingID(site_instance);
 
   int parent_routing_id = MSG_ROUTING_NONE;
   if (frame_tree_node_->parent()) {
     parent_routing_id = frame_tree_node_->parent()
                             ->render_manager()
                             ->GetRoutingIdForSiteInstance(site_instance);
@@ skipping 59 matching lines @@
   // https://crbug.com/591478. Verify that the parent routing ID
   // points to a live RenderFrameProxy when this is not a remote-to-local
   // navigation (i.e., when there's no |existing_proxy|).
   if (!existing_proxy && frame_tree_node_->parent()) {
     RenderFrameProxyHost* parent_proxy = RenderFrameProxyHost::FromID(
         render_frame_host->GetProcess()->GetID(), parent_routing_id);
     if (!parent_proxy || !parent_proxy->is_render_frame_proxy_live()) {
       base::debug::SetCrashKeyValue("initrf_parent_proxy_exists",
                                     parent_proxy ? "yes" : "no");
 
-      SiteInstance* parent_instance =
+      SiteInstanceImpl* parent_instance =
           frame_tree_node_->parent()->current_frame_host()->GetSiteInstance();
       base::debug::SetCrashKeyValue(
           "initrf_parent_is_in_same_site_instance",
           site_instance == parent_instance ? "yes" : "no");
       base::debug::SetCrashKeyValue("initrf_parent_process_is_live",
                                     frame_tree_node_->parent()
                                             ->current_frame_host()
                                             ->GetProcess()
                                             ->HasConnection()
                                         ? "yes"
                                         : "no");
       base::debug::SetCrashKeyValue(
           "initrf_render_view_is_live",
           render_frame_host->render_view_host()->IsRenderViewLive() ? "yes"
                                                                     : "no");
 
       // Collect some additional information for root's proxy if it's different
       // from the parent.
       FrameTreeNode* root = frame_tree_node_->frame_tree()->root();
       if (root != frame_tree_node_->parent()) {
-        SiteInstance* root_instance =
+        SiteInstanceImpl* root_instance =
             root->current_frame_host()->GetSiteInstance();
         base::debug::SetCrashKeyValue(
             "initrf_root_is_in_same_site_instance",
             site_instance == root_instance ? "yes" : "no");
         base::debug::SetCrashKeyValue(
             "initrf_root_is_in_same_site_instance_as_parent",
             parent_instance == root_instance ? "yes" : "no");
         base::debug::SetCrashKeyValue("initrf_root_process_is_live",
                                       frame_tree_node_->frame_tree()
                                               ->root()
@@ skipping 15 matching lines @@
       base::debug::DumpWithoutCrashing();
     }
   }
 
   return delegate_->CreateRenderFrameForRenderManager(
       render_frame_host, proxy_routing_id, opener_routing_id, parent_routing_id,
       previous_sibling_routing_id);
 }
 
 int RenderFrameHostManager::GetRoutingIdForSiteInstance(
-    SiteInstance* site_instance) {
+    SiteInstanceImpl* site_instance) {
   if (render_frame_host_->GetSiteInstance() == site_instance)
     return render_frame_host_->GetRoutingID();
 
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(site_instance);
   if (proxy)
     return proxy->GetRoutingID();
 
   return MSG_ROUTING_NONE;
 }
 
@@ skipping 135 matching lines @@
     proxy_to_parent->SetChildRWHView(render_frame_host_->GetView());
   }
 
   // After all is done, there must never be a proxy in the list which has the
   // same SiteInstance as the current RenderFrameHost.
   CHECK(!GetRenderFrameProxyHost(render_frame_host_->GetSiteInstance()));
 }
 
 RenderFrameHostImpl* RenderFrameHostManager::UpdateStateForNavigate(
     const GURL& dest_url,
-    SiteInstance* source_instance,
-    SiteInstance* dest_instance,
+    SiteInstanceImpl* source_instance,
+    SiteInstanceImpl* dest_instance,
     ui::PageTransition transition,
     bool dest_is_restore,
     bool dest_is_view_source_mode,
     const GlobalRequestID& transferred_request_id,
     int bindings) {
   if (!frame_tree_node_->IsMainFrame()) {
     // Don't swap for subframes unless we are in an OOPIF-enabled mode.  We can
     // get here in tests for subframes (e.g., NavigateFrameToURL).
     if (!SiteIsolationPolicy::AreCrossProcessFramesPossible())
       return render_frame_host_.get();
@@ skipping 15 matching lines @@
     // the policy determines that a transfer would have been needed.  We can get
     // here for session restore.
     if (!IsRendererTransferNeededForNavigation(render_frame_host_.get(),
                                                resolved_url)) {
       DCHECK(!dest_instance ||
              dest_instance == render_frame_host_->GetSiteInstance());
       return render_frame_host_.get();
     }
   }
 
-  SiteInstance* current_instance = render_frame_host_->GetSiteInstance();
-  scoped_refptr<SiteInstance> new_instance = GetSiteInstanceForNavigation(
+  SiteInstanceImpl* current_instance = render_frame_host_->GetSiteInstance();
+  scoped_refptr<SiteInstanceImpl> new_instance = GetSiteInstanceForNavigation(
       dest_url, source_instance, dest_instance, nullptr, transition,
       dest_is_restore, dest_is_view_source_mode);
 
   // If we are currently navigating cross-process to a pending RFH for a
   // different SiteInstance, we want to get back to normal and then navigate as
   // usual.  We will reuse the pending RFH below if it matches the destination
   // SiteInstance.
   if (pending_render_frame_host_ &&
       pending_render_frame_host_->GetSiteInstance() != new_instance)
     CancelPending();
@@ skipping 186 matching lines @@
     return false;
 
   RenderFrameProxyHost* host = GetRenderFrameProxyHost(rfh->GetSiteInstance());
   if (!host)
     return false;
 
   return host->render_frame_host() == rfh;
 }
 
 RenderViewHostImpl* RenderFrameHostManager::GetSwappedOutRenderViewHost(
-   SiteInstance* instance) const {
+    SiteInstance* instance) const {
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   if (proxy)
     return proxy->GetRenderViewHost();
   return nullptr;
 }
 
 RenderFrameProxyHost* RenderFrameHostManager::GetRenderFrameProxyHost(
     SiteInstance* instance) const {
-  auto it = proxy_hosts_.find(instance->GetId());
+  auto it =
+      proxy_hosts_.find(static_cast<SiteInstanceImpl*>(instance)->GetId());
   if (it != proxy_hosts_.end())
     return it->second.get();
   return nullptr;
 }
 
 int RenderFrameHostManager::GetProxyCount() {
   return proxy_hosts_.size();
 }
 
 void RenderFrameHostManager::CollectOpenerFrameTrees(
@@ skipping 32 matching lines @@
         size_t position =
             std::distance(opener_frame_trees->begin(), existing_tree_it);
         if (position < visited_index)
           nodes_with_back_links->insert(node);
       }
     }
   }
 }
 
 void RenderFrameHostManager::CreateOpenerProxies(
-    SiteInstance* instance,
+    SiteInstanceImpl* instance,
     FrameTreeNode* skip_this_node) {
   std::vector<FrameTree*> opener_frame_trees;
   base::hash_set<FrameTreeNode*> nodes_with_back_links;
 
   CollectOpenerFrameTrees(&opener_frame_trees, &nodes_with_back_links);
 
   // Create opener proxies for frame trees, processing furthest openers from
   // this node first and this node last.  In the common case without cycles,
   // this will ensure that each tree's openers are created before the tree's
   // nodes need to reference them.
@@ skipping 21 matching lines @@
 
     int opener_routing_id =
         node->render_manager()->GetOpenerRoutingID(instance);
     DCHECK_NE(opener_routing_id, MSG_ROUTING_NONE);
     proxy->Send(new FrameMsg_UpdateOpener(proxy->GetRoutingID(),
                                           opener_routing_id));
   }
 }
 
 void RenderFrameHostManager::CreateOpenerProxiesForFrameTree(
-    SiteInstance* instance,
+    SiteInstanceImpl* instance,
     FrameTreeNode* skip_this_node) {
   // Currently, this function is only called on main frames.  It should
   // actually work correctly for subframes as well, so if that need ever
   // arises, it should be sufficient to remove this DCHECK.
   DCHECK(frame_tree_node_->IsMainFrame());
 
   if (frame_tree_node_ == skip_this_node)
     return;
 
   FrameTree* frame_tree = frame_tree_node_->frame_tree();
@@ skipping 27 matching lines @@
       EnsureRenderViewInitialized(rvh, instance);
     } else {
       // Create a RenderFrameProxyHost in the given SiteInstance if none
       // exists. Since an opener can point to a subframe, do this on the root
       // frame of the current opener's frame tree.
       frame_tree->root()->render_manager()->CreateRenderFrameProxy(instance);
     }
   }
 }
 
-int RenderFrameHostManager::GetOpenerRoutingID(SiteInstance* instance) {
+int RenderFrameHostManager::GetOpenerRoutingID(SiteInstanceImpl* instance) {
   if (!frame_tree_node_->opener())
     return MSG_ROUTING_NONE;
 
   return frame_tree_node_->opener()
       ->render_manager()
       ->GetRoutingIdForSiteInstance(instance);
 }
 
 void RenderFrameHostManager::SendPageMessage(IPC::Message* msg) {
   DCHECK(IPC_MESSAGE_CLASS(*msg) == PageMsgStart);
@@ skipping 21 matching lines @@
   } else if (pending_render_frame_host_) {
     send_msg(pending_render_frame_host_.get(),
              pending_render_frame_host_->GetRoutingID(), msg);
   }
 
   msg->set_routing_id(render_frame_host_->GetRoutingID());
   render_frame_host_->Send(msg);
 }
 
 }  // namespace content