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::GetProxyToEmbedder() {
+  int64 embedder_frame_tree_node_id = delegate_->GetEmbedderFrameTreeNodeID();

[Charlie Reis, 2015/05/19 07:12:31]

nit: We've recently changed FTN IDs to be ints rather than int64.  (Check for
this throughout the CL.)

[lazyboy, 2015/05/21 23:23:46]

Done.

+  FrameTreeNode* embedder_frame_tree_node =
+      FrameTreeNode::GloballyFindByID(embedder_frame_tree_node_id);
+  if (!embedder_frame_tree_node)
+    return nullptr;
+
+  return GetRenderFrameProxyHost(
+      embedder_frame_tree_node->current_frame_host()->GetSiteInstance());
+}
+
+bool RenderFrameHostManager::IsGuest() {
+  return frame_tree_node_->IsMainFrame() &&

[Charlie Reis, 2015/05/19 07:12:31]

Why is this line needed?  Is it important not to treat subframes of the guest
(inner WebContents) as guests?  The comment for this method should probably
clarify the reason for that.

[lazyboy, 2015/05/21 23:23:46]

I haven't started running subframes inside guest yet.
That's why I narrowed this to main frames only.
Added a TODO in description to follow up with subframes inside guest.

+         delegate_->GetEmbedderFrameTreeNodeID() != -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 280 matching lines @@
   CommitPendingIfNecessary(render_frame_host, was_caused_by_user_gesture);
 
   // Make sure any dynamic changes to this frame's sandbox flags that were made
   // prior to navigation take effect.
   CommitPendingSandboxFlags();
 }
 
 void RenderFrameHostManager::CommitPendingIfNecessary(
     RenderFrameHostImpl* render_frame_host,
     bool was_caused_by_user_gesture) {
+  RenderFrameProxyHost* proxy_to_embedder = GetProxyToEmbedder();
+  if (proxy_to_embedder) {
+    DCHECK(render_frame_host->GetSiteInstance()->GetSiteURL().SchemeIs(
+        "chrome-guest"));
+    // TODO(lazyboy): This probably breaks guest visibility.
+    current_host()->GetView()->Show();

[Charlie Reis, 2015/05/19 07:12:31]

Any thoughts yet on where this belongs?  I don't think it should stay here.

[lazyboy, 2015/05/21 23:23:47]

Not entirely yet, I've moved this outside of content/, to
GuestViewBase(WCO)::DidNavigateMainFrame()

There used to be guest visibility issue with plugin implementation and we
needed to send extra IPC (BrowserPluginHostMsg_SetVisibility), I am yet
to investigate that for out-of-process implementation, but we should be
good for now.

+  }
+
   if (!pending_render_frame_host_ && !speculative_render_frame_host_) {
     DCHECK_IMPLIES(should_reuse_web_ui_, web_ui_);
 
     // We should only hear this from our current renderer.
     DCHECK_EQ(render_frame_host_, render_frame_host);
 
     // Even when there is no pending RVH, there may be a pending Web UI.
     if (pending_web_ui() || speculative_web_ui_)
       CommitPending();
     return;
@@ skipping 1143 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::CreateEmbedderProxy(
+    SiteInstance* embedder_site_instance) {
+  CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSitePerProcess));
+  int embedder_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_embedder_rfh = CreateRenderFrame(
+      embedder_site_instance, nullptr,
+      MSG_ROUTING_NONE,  // opener_route_id
+      embedder_proxy_flags, &swapped_out_render_view_routing_id);
+
+  RenderFrameProxyHost* rfph_in_embedder =
+      GetRenderFrameProxyHost(embedder_site_instance);
+  CHECK(rfph_in_embedder);

[Charlie Reis, 2015/05/19 07:12:31]

DCHECK is sufficient if you want to document the invariant.  We'll crash on the
next line anyway in release builds.

[lazyboy, 2015/05/21 23:23:47]

Done.

+  return rfph_in_embedder->GetRoutingID();
+}
+
+void RenderFrameHostManager::ReplaceWithGuestProxy(
+    int proxy_to_embedder_routing_id) {
+  current_frame_host()->Send(new FrameMsg_SwapOut(
+      current_frame_host()->GetRoutingID(), proxy_to_embedder_routing_id,
+      false /* is_loading */, content::FrameReplicationState()));
+}
+
+void RenderFrameHostManager::SetGuestRWHView(RenderWidgetHostView* child_rwhv) {
+  GetProxyToEmbedder()->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