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 133 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() {
+  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 1461 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.
+  //
+  // 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
+  // false to |is_loading| below.
+  // TODO(lazyboy): This |is_loading| behavior might not be what we want,
+  // investigate and fix.
+  render_frame_host->Send(new FrameMsg_SwapOut(
+      render_frame_host->GetRoutingID(), proxy->GetRoutingID(),
+      false /* is_loading */, FrameReplicationState()));
+  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