Start using RenderFrameProxyHost objects.

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 <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 36 matching lines @@
 
 // Iterate over the FrameTree to reset any node affected by the loss of the
 // given RenderViewHost's process.
 bool ResetNodesForNewProcess(RenderViewHost* render_view_host,
                              FrameTreeNode* node) {
   if (render_view_host == node->current_frame_host()->render_view_host())
     node->ResetForNewProcess();
   return true;
 }
 
+bool CreateProxyForSiteInstance(FrameTreeNode* source_node,
+                                const scoped_refptr<SiteInstance>& instance,
+                                FrameTreeNode* node) {
+  // Skip the node that initiated the creation.
+  if (source_node == node)
+    return true;
+
+  node->render_manager()->CreateRenderFrameProxy(instance);
+  return true;
+}
+
 }  // namespace
 
 FrameTree::FrameTree(Navigator* navigator,
                      RenderFrameHostDelegate* render_frame_delegate,
                      RenderViewHostDelegate* render_view_delegate,
                      RenderWidgetHostDelegate* render_widget_delegate,
                      RenderFrameHostManager::Delegate* manager_delegate)
     : render_frame_delegate_(render_frame_delegate),
       render_view_delegate_(render_view_delegate),
       render_widget_delegate_(render_widget_delegate),
@@ skipping 61 matching lines @@
 
   // Notify observers of the frame removal.
   RenderFrameHostImpl* render_frame_host = child->current_frame_host();
   if (!on_frame_removed_.is_null()) {
     on_frame_removed_.Run(render_frame_host);
   }
 
   parent->RemoveChild(child);
 }
 
+void FrameTree::CreateProxiesForSiteInstance(
+    FrameTreeNode* source,
+    SiteInstance* site_instance) {
+  // Create the swapped out RVH for the new SiteInstance. This will create
+  // a top-level swapped out RFH as well, which will then be wrapped by a
+  // RenderFrameProxyHost.
+  if (!source->IsMainFrame()) {
+    RenderViewHostImpl* render_view_host =
+        source->frame_tree()->GetRenderViewHost(site_instance);
+    if (!render_view_host) {
+      source->frame_tree()->root()->render_manager()

[Charlie Reis, 2014/07/28 22:32:28]

This can be simplified to root_->render_manager(), since source->frame_tree() is
|this|.  (Then we can get rid of the line wrap before the arrow, as well.)

[kenrb, 2014/07/29 16:38:36]

Done.

+          ->CreateRenderFrame(site_instance,
+                              MSG_ROUTING_NONE,
+                              true,
+                              false,
+                              true);
+    }
+  }
+
+  scoped_refptr<SiteInstance> instance(site_instance);
+  ForEach(base::Bind(&CreateProxyForSiteInstance, source, instance));
+}
+
 void FrameTree::ResetForMainFrameSwap() {
   root_->ResetForNewProcess();
   focused_frame_tree_node_id_ = -1;
 }
 
 void FrameTree::RenderProcessGone(RenderViewHost* render_view_host) {
   // Walk the full tree looking for nodes that may be affected.  Once a frame
   // crashes, all of its child FrameTreeNodes go away.
   // Note that the helper function may call ResetForNewProcess on a node, which
   // clears its children before we iterate over them.  That's ok, because
@@ skipping 12 matching lines @@
 
 void FrameTree::SetFocusedFrame(FrameTreeNode* node) {
   focused_frame_tree_node_id_ = node->frame_tree_node_id();
 }
 
 void FrameTree::SetFrameRemoveListener(
     const base::Callback<void(RenderFrameHost*)>& on_frame_removed) {
   on_frame_removed_ = on_frame_removed;
 }
 
-RenderViewHostImpl* FrameTree::CreateRenderViewHostForMainFrame(
-    SiteInstance* site_instance,
-    int routing_id,
-    int main_frame_routing_id,
-    bool swapped_out,
-    bool hidden) {
+RenderViewHostImpl* FrameTree::CreateRenderViewHost(SiteInstance* site_instance,
+                                                    int routing_id,
+                                                    int main_frame_routing_id,
+                                                    bool swapped_out,
+                                                    bool hidden) {
   DCHECK(main_frame_routing_id != MSG_ROUTING_NONE);
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   if (iter != render_view_host_map_.end()) {
     // If a RenderViewHost is pending shutdown for this |site_instance|, put it
-    // in the map of RenderViewHosts pending shutdown. Otherwise there should
-    // not be a RenderViewHost for the SiteInstance.
-    CHECK_EQ(RenderViewHostImpl::STATE_PENDING_SHUTDOWN,
-             iter->second->rvh_state());
-    render_view_host_pending_shutdown_map_.insert(
-        std::pair<int, RenderViewHostImpl*>(site_instance->GetId(),
-                                            iter->second));
-    render_view_host_map_.erase(iter);
+    // in the map of RenderViewHosts pending shutdown. Otherwise return the
+    // existing RenderViewHost for the SiteInstance.
+    if (iter->second->rvh_state() ==
+        RenderViewHostImpl::STATE_PENDING_SHUTDOWN) {
+      render_view_host_pending_shutdown_map_.insert(
+          std::pair<int, RenderViewHostImpl*>(site_instance->GetId(),
+                                              iter->second));
+      render_view_host_map_.erase(iter);
+    } else {
+      return iter->second;
+    }
   }
   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::GetRenderViewHostForSubFrame(
-    SiteInstance* site_instance) {
+RenderViewHostImpl* FrameTree::GetRenderViewHost(SiteInstance* site_instance) {
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   // TODO(creis): Mirror the frame tree so this check can't fail.
   if (iter == render_view_host_map_.end())
     return NULL;
   return iter->second;
 }
 
 void FrameTree::RegisterRenderFrameHost(
     RenderFrameHostImpl* render_frame_host) {
@@ skipping 45 matching lines @@
         rvh->Shutdown();
         render_view_host_pending_shutdown_map_.erase(multi_iter);
       }
       break;
     }
     CHECK(render_view_host_found);
   }
 }
 
 }  // namespace content