Make <webview> use out-of-process iframe architecture.

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 <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 142 matching lines @@
                             ->render_manager()
                             ->current_frame_host()
                             ->GetSiteInstance()
                             ->GetId());
   if (iter == proxy_hosts_.end())
     return NULL;
 
   return iter->second;
 }
 
+RenderFrameProxyHost* RenderFrameHostManager::GetProxyToOuterContents() {
+  int outer_contents_frame_tree_node_id =
+      delegate_->GetOuterWebContentsFrameTreeNodeID();
+  FrameTreeNode* outer_contents_frame_tree_node =
+      FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id);
+  if (!outer_contents_frame_tree_node)
+    return nullptr;
+
+  return GetRenderFrameProxyHost(
+      outer_contents_frame_tree_node->current_frame_host()->GetSiteInstance());
+}
+
+bool RenderFrameHostManager::IsGuest() {
+  return frame_tree_node_->IsMainFrame() &&

[Charlie Reis, 2015/05/22 23:44:30]

Thanks for the TODO in the .h file.  Can you also put it above this line, to
make it clear to readers that this IsMainFrame check is temporary?

[lazyboy, 2015/05/26 16:32:54]

Done.

+         delegate_->GetOuterWebContentsFrameTreeNodeID() != -1;
+}
+
 void RenderFrameHostManager::SetPendingWebUI(const GURL& url, int bindings) {
   pending_web_ui_ = CreateWebUI(url, bindings);
   pending_and_current_web_ui_.reset();
 }
 
 scoped_ptr<WebUIImpl> RenderFrameHostManager::CreateWebUI(const GURL& url,
                                                           int bindings) {
   scoped_ptr<WebUIImpl> new_web_ui(delegate_->CreateWebUIForRenderManager(url));
 
   // If we have assigned (zero or more) bindings to this NavigationEntry in the
@@ skipping 1419 matching lines @@
 
   // Recreate the opener chain.
   int opener_route_id =
       delegate_->CreateOpenerRenderViewsForRenderManager(instance);
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   InitRenderView(render_view_host, opener_route_id, proxy->GetRoutingID(),
                  source->IsMainFrame());
   proxy->set_render_frame_proxy_created(true);
 }
 
+int RenderFrameHostManager::CreateOuterContentsProxy(
+    SiteInstance* outer_contents_site_instance) {
+  CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSitePerProcess));
+  int outer_contents_proxy_flags = CREATE_RF_HIDDEN | CREATE_RF_SWAPPED_OUT |
+                                   CREATE_RF_FOR_MAIN_FRAME_NAVIGATION;
+  int swapped_out_render_view_routing_id;  // Unused.
+  scoped_ptr<RenderFrameHostImpl> swapped_out_rfh_in_outer_contents =
+      CreateRenderFrame(outer_contents_site_instance, nullptr,

[nasko, 2015/05/22 16:32:27]

Ah, this is unfortunate : (. I'm working on a CL that removes swapped out in
--site-per-process, which means you will be able to just call
RFHM::CreateRenderFrameProxy :).

[lazyboy, 2015/05/26 16:32:54]

Bug#?

+                        MSG_ROUTING_NONE,  // opener_route_id
+                        outer_contents_proxy_flags,
+                        &swapped_out_render_view_routing_id);
+
+  RenderFrameProxyHost* rfph_in_outer_contents =
+      GetRenderFrameProxyHost(outer_contents_site_instance);
+  DCHECK(rfph_in_outer_contents);
+  return rfph_in_outer_contents->GetRoutingID();
+}
+
+void RenderFrameHostManager::ReplaceWithInnerContentsProxy(
+    int proxy_to_outer_contents_routing_id) {
+  current_frame_host()->Send(new FrameMsg_SwapOut(

[Charlie Reis, 2015/05/22 23:44:30]

Is it correct to pass false for is_loading?  I was under the impression that we
call this when we start the load in the guest.  Maybe we should pass the loading
state from frame_tree_node_?

[lazyboy, 2015/05/29 00:02:23]

We are in the outer WebContents's FTN and this FTN or the outer
WebContents's FrameTree never sees a load start.
Eventually, that also makes it never see a load stop.
Think that's the right behavior?
I've added DCHECK because frame tree node's is_loading should
always be false here.

+      current_frame_host()->GetRoutingID(), proxy_to_outer_contents_routing_id,
+      false /* is_loading */, content::FrameReplicationState()));

[nasko, 2015/05/22 16:32:27]

nit: No need to use "content::" prefix, this code is already in content/ :)

[lazyboy, 2015/05/26 16:32:54]

Done, thanks.

+}
+
+void RenderFrameHostManager::SetRWHViewForInnerContents(
+    RenderWidgetHostView* child_rwhv) {
+  GetProxyToOuterContents()->SetChildRWHView(child_rwhv);
+}
+
 bool RenderFrameHostManager::InitRenderView(
     RenderViewHostImpl* render_view_host,
     int opener_route_id,
     int proxy_routing_id,
     bool for_main_frame_navigation) {
   // We may have initialized this RenderViewHost for another RenderFrameHost.
   if (render_view_host->IsRenderViewLive())
     return true;
 
   // If the ongoing navigation is to a WebUI and the RenderView is not in a
@@ skipping 497 matching lines @@
 void RenderFrameHostManager::DeleteRenderFrameProxyHost(
     SiteInstance* instance) {
   RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId());
   if (iter != proxy_hosts_.end()) {
     delete iter->second;
     proxy_hosts_.erase(iter);
   }
 }
 
 }  // namespace content