Inside of content, prefer SiteInstanceImpl to SiteInstance.

content/browser/frame_host/frame_tree.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/frame_tree.h"
 
 #include <stddef.h>
 
 #include <queue>
 #include <utility>
@@ skipping 13 matching lines @@
 #include "content/common/site_isolation_policy.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 
 namespace content {
 
 namespace {
 
 // Helper function to collect SiteInstances involved in rendering a single
 // FrameTree (which is a subset of SiteInstances in main frame's proxy_hosts_
 // because of openers).
-std::set<SiteInstance*> CollectSiteInstances(FrameTree* tree) {
-  std::set<SiteInstance*> instances;
+std::set<SiteInstanceImpl*> CollectSiteInstances(FrameTree* tree) {
+  std::set<SiteInstanceImpl*> instances;
   for (FrameTreeNode* node : tree->Nodes())
     instances.insert(node->current_frame_host()->GetSiteInstance());
   return instances;
 }
 
 }  // namespace
 
 FrameTree::NodeIterator::NodeIterator(const NodeIterator& other) = default;
 
 FrameTree::NodeIterator::~NodeIterator() {}
@@ skipping 159 matching lines @@
 void FrameTree::RemoveFrame(FrameTreeNode* child) {
   FrameTreeNode* parent = child->parent();
   if (!parent) {
     NOTREACHED() << "Unexpected RemoveFrame call for main frame.";
     return;
   }
 
   parent->RemoveChild(child);
 }
 
-void FrameTree::CreateProxiesForSiteInstance(
-    FrameTreeNode* source,
-    SiteInstance* site_instance) {
+void FrameTree::CreateProxiesForSiteInstance(FrameTreeNode* source,
+                                             SiteInstanceImpl* site_instance) {
   // Create the RenderFrameProxyHost for the new SiteInstance.
   if (!source || !source->IsMainFrame()) {
     RenderViewHostImpl* render_view_host = GetRenderViewHost(site_instance);
     if (!render_view_host) {
       root()->render_manager()->CreateRenderFrameProxy(site_instance);
     } else {
       root()->render_manager()->EnsureRenderViewInitialized(render_view_host,
                                                             site_instance);
     }
   }
 
   // Proxies are created in the FrameTree in response to a node navigating to a
   // new SiteInstance. Since |source|'s navigation will replace the currently
   // loaded document, the entire subtree under |source| will be removed.
   for (FrameTreeNode* node : NodesExcept(source)) {
     // If a new frame is created in the current SiteInstance, other frames in
     // that SiteInstance don't need a proxy for the new frame.
-    SiteInstance* current_instance =
+    SiteInstanceImpl* current_instance =
         node->render_manager()->current_frame_host()->GetSiteInstance();
     if (current_instance != site_instance)
       node->render_manager()->CreateRenderFrameProxy(site_instance);
   }
 }
 
 RenderFrameHostImpl* FrameTree::GetMainFrame() const {
   return root_->current_frame_host();
 }
 
 FrameTreeNode* FrameTree::GetFocusedFrame() {
   return FindByID(focused_frame_tree_node_id_);
 }
 
-void FrameTree::SetFocusedFrame(FrameTreeNode* node, SiteInstance* source) {
+void FrameTree::SetFocusedFrame(FrameTreeNode* node, SiteInstanceImpl* source) {
   if (node == GetFocusedFrame())
     return;
 
-  std::set<SiteInstance*> frame_tree_site_instances =
+  std::set<SiteInstanceImpl*> frame_tree_site_instances =
       CollectSiteInstances(this);
 
-  SiteInstance* current_instance =
+  SiteInstanceImpl* current_instance =
       node->current_frame_host()->GetSiteInstance();
 
   // Update the focused frame in all other SiteInstances.  If focus changes to
   // a cross-process frame, this allows the old focused frame's renderer
   // process to clear focus from that frame and fire blur events.  It also
   // ensures that the latest focused frame is available in all renderers to
   // compute document.activeElement.
   //
   // We do not notify the |source| SiteInstance because it already knows the
   // new focused frame (since it initiated the focus change), and we notify the
@@ skipping 21 matching lines @@
   // focused frame changes.
   root()->current_frame_host()->UpdateAXTreeData();
 }
 
 void FrameTree::SetFrameRemoveListener(
     const base::Callback<void(RenderFrameHost*)>& on_frame_removed) {
   on_frame_removed_ = on_frame_removed;
 }
 
 RenderViewHostImpl* FrameTree::CreateRenderViewHost(
-    SiteInstance* site_instance,
+    SiteInstanceImpl* site_instance,
     int32_t routing_id,
     int32_t main_frame_routing_id,
     bool swapped_out,
     bool hidden) {
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   if (iter != render_view_host_map_.end()) {
     // If a RenderViewHost is pending deletion for this |site_instance|, it
     // shouldn't be reused, so put it in the map of RenderViewHosts pending
     // shutdown.  Otherwise, return the existing RenderViewHost for the
@@ skipping 10 matching lines @@
   }
   RenderViewHostImpl* rvh =
       static_cast<RenderViewHostImpl*>(RenderViewHostFactory::Create(
           site_instance, render_view_delegate_, render_widget_delegate_,
           routing_id, main_frame_routing_id, swapped_out, hidden));
 
   render_view_host_map_[site_instance->GetId()] = rvh;
   return rvh;
 }
 
-RenderViewHostImpl* FrameTree::GetRenderViewHost(SiteInstance* site_instance) {
+RenderViewHostImpl* FrameTree::GetRenderViewHost(
+    SiteInstanceImpl* site_instance) {
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   // Don't return the RVH if it is pending deletion.
   if (iter != render_view_host_map_.end() &&
       !root_->render_manager()->IsViewPendingDeletion(iter->second)) {
     return iter->second;
   }
   return nullptr;
 }
 
 void FrameTree::AddRenderViewHostRef(RenderViewHostImpl* render_view_host) {
-  SiteInstance* site_instance = render_view_host->GetSiteInstance();
+  SiteInstanceImpl* site_instance = render_view_host->GetSiteInstance();
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   CHECK(iter != render_view_host_map_.end());
   CHECK(iter->second == render_view_host);
 
   iter->second->increment_ref_count();
 }
 
 void FrameTree::ReleaseRenderViewHostRef(RenderViewHostImpl* render_view_host) {
-  SiteInstance* site_instance = render_view_host->GetSiteInstance();
+  SiteInstanceImpl* site_instance = render_view_host->GetSiteInstance();
   int32_t site_instance_id = site_instance->GetId();
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance_id);
   if (iter != render_view_host_map_.end() && iter->second == render_view_host) {
     // Decrement the refcount and shutdown the RenderViewHost if no one else is
     // using it.
     CHECK_GT(iter->second->ref_count(), 0);
     iter->second->decrement_ref_count();
     if (iter->second->ref_count() == 0) {
       iter->second->ShutdownAndDestroy();
@@ skipping 74 matching lines @@
 
 bool FrameTree::IsLoading() const {
   for (const FrameTreeNode* node : const_cast<FrameTree*>(this)->Nodes()) {
     if (node->IsLoading())
       return true;
   }
   return false;
 }
 
 void FrameTree::ReplicatePageFocus(bool is_focused) {
-  std::set<SiteInstance*> frame_tree_site_instances =
+  std::set<SiteInstanceImpl*> frame_tree_site_instances =
       CollectSiteInstances(this);
 
   // Send the focus update to main frame's proxies in all SiteInstances of
   // other frames in this FrameTree. Note that the main frame might also know
   // about proxies in SiteInstances for frames in a different FrameTree (e.g.,
   // for window.open), so we can't just iterate over its proxy_hosts_ in
   // RenderFrameHostManager.
   for (const auto& instance : frame_tree_site_instances)
     SetPageFocus(instance, is_focused);
 }
 
-void FrameTree::SetPageFocus(SiteInstance* instance, bool is_focused) {
+void FrameTree::SetPageFocus(SiteInstanceImpl* instance, bool is_focused) {
   RenderFrameHostManager* root_manager = root_->render_manager();
 
   // This is only used to set page-level focus in cross-process subframes, and
   // requests to set focus in main frame's SiteInstance are ignored.
   if (instance != root_manager->current_frame_host()->GetSiteInstance()) {
     RenderFrameProxyHost* proxy =
         root_manager->GetRenderFrameProxyHost(instance);
     proxy->Send(new InputMsg_SetFocus(proxy->GetRoutingID(), is_focused));
   }
 }
 
 }  // namespace content