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 127 matching lines @@
 }
 
 RenderWidgetHostView* RenderFrameHostManager::GetRenderWidgetHostView() const {
   if (interstitial_page_)
     return interstitial_page_->GetView();
   if (render_frame_host_)
     return render_frame_host_->GetView();
   return nullptr;
 }
 
+bool RenderFrameHostManager::ForInnerDelegate() {
+  // TODO(lazyboy): Subframes inside inner WebContents needs to be tested and
+  // we have to make sure that IsMainFrame() check below is appropriate. See
+  // http://crbug.com/500957.
+  return frame_tree_node_->IsMainFrame() &&
+         delegate_->GetOuterDelegateFrameTreeNodeID() !=
+             FrameTreeNode::kFrameTreeNodeInvalidID;
+}
+
+RenderWidgetHostImpl*
+RenderFrameHostManager::GetOuterRenderWidgetHostForKeyboardInput() {
+  if (!ForInnerDelegate())
+    return nullptr;
+
+  FrameTreeNode* outer_contents_frame_tree_node =
+      FrameTreeNode::GloballyFindByID(
+          delegate_->GetOuterDelegateFrameTreeNodeID());
+  return outer_contents_frame_tree_node->parent()
+      ->current_frame_host()
+      ->render_view_host();
+}
+
 RenderFrameProxyHost* RenderFrameHostManager::GetProxyToParent() {
   if (frame_tree_node_->IsMainFrame())
     return NULL;
 
   RenderFrameProxyHostMap::iterator iter =
       proxy_hosts_.find(frame_tree_node_->parent()
                             ->render_manager()
                             ->current_frame_host()
                             ->GetSiteInstance()
                             ->GetId());
   if (iter == proxy_hosts_.end())
     return NULL;
 
   return iter->second;
 }
 
+RenderFrameProxyHost* RenderFrameHostManager::GetProxyToOuterDelegate() {
+  int outer_contents_frame_tree_node_id =
+      delegate_->GetOuterDelegateFrameTreeNodeID();
+  FrameTreeNode* outer_contents_frame_tree_node =
+      FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id);
+  if (!outer_contents_frame_tree_node ||
+      !outer_contents_frame_tree_node->parent()) {
+    return nullptr;
+  }
+
+  return GetRenderFrameProxyHost(outer_contents_frame_tree_node->parent()
+                                     ->current_frame_host()
+                                     ->GetSiteInstance());
+}
+
+void RenderFrameHostManager::RemoveOuterDelegateFrame() {

[nasko, 2015/06/23 13:39:23]

I also feel this method doesn't quite belong in RFHM, as it is WebContents that
gets linked and unlinked. However, this means adding specific method for this to
the delegate interface, which isn't great either and other code that deals with
linking is here. I'll defer to Charlie on this one.

[lazyboy, 2015/06/23 23:00:00]

I've added a TODO for this to move out of RFHM.
Charlie is away next 2 weeks... So we should keep this as is and attempt to land
and come back to the TODO above when Charlie comes back.

+  FrameTreeNode* outer_delegate_frame_tree_node =
+      FrameTreeNode::GloballyFindByID(
+          delegate_->GetOuterDelegateFrameTreeNodeID());
+  DCHECK(outer_delegate_frame_tree_node->parent());
+  outer_delegate_frame_tree_node->frame_tree()->RemoveFrame(
+      outer_delegate_frame_tree_node);
+}
+
 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 1466 matching lines @@
     return;
 
   // Recreate the opener chain.
   int opener_route_id = CreateOpenerProxiesIfNeeded(instance);
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   InitRenderView(render_view_host, opener_route_id, proxy->GetRoutingID(),
                  false);
   proxy->set_render_frame_proxy_created(true);
 }
 
+void RenderFrameHostManager::CreateOuterDelegateProxy(
+    SiteInstance* outer_contents_site_instance,
+    RenderFrameHostImpl* render_frame_host) {
+  CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSitePerProcess));
+  RenderFrameProxyHost* proxy = new RenderFrameProxyHost(
+      outer_contents_site_instance, nullptr, frame_tree_node_);
+  proxy_hosts_[outer_contents_site_instance->GetId()] = proxy;
+
+  // Swap the outer WebContents's frame with the proxy to inner WebContents.
+  render_frame_host->Send(new FrameMsg_SwapOut(
+      render_frame_host->GetRoutingID(), proxy->GetRoutingID(),
+      false /* is_loading */, FrameReplicationState()));

[nasko, 2015/06/23 13:39:23]

nit: Do we still need a TODO for the is_loading?

[lazyboy, 2015/06/23 23:00:00]

Done.

+  proxy->set_render_frame_proxy_created(true);
+}
+
+void RenderFrameHostManager::SetRWHViewForInnerContents(
+    RenderWidgetHostView* child_rwhv) {
+  DCHECK(ForInnerDelegate());
+  GetProxyToOuterDelegate()->SetChildRWHView(child_rwhv);
+}
+
 bool RenderFrameHostManager::InitRenderView(
     RenderViewHostImpl* render_view_host,
     int opener_route_id,
     int proxy_routing_id,
     bool for_main_frame_navigation) {
   // Ensure the renderer process is initialized before creating the
   // RenderView.
   if (!render_view_host->GetProcess()->Init())
     return false;
 
@@ skipping 578 matching lines @@
     frame_tree->root()->render_manager()->
         CreateRenderFrame(instance, nullptr, opener_route_id,
                           CREATE_RF_FOR_MAIN_FRAME_NAVIGATION |
                           CREATE_RF_SWAPPED_OUT | CREATE_RF_HIDDEN,
                           &render_view_routing_id);
   }
   return render_view_routing_id;
 }
 
 }  // namespace content