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

content/browser/web_contents/web_contents_impl.cc

 // Copyright (c) 2012 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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 268 matching lines @@
                                                     int identifier)
     : render_process_id(render_process_id),
       render_frame_id(render_frame_id),
       chooser(chooser),
       identifier(identifier) {
 }
 
 WebContentsImpl::ColorChooserInfo::~ColorChooserInfo() {
 }
 
+// WebContentsImpl::WebContentsNode --------------------------------------------
+WebContentsImpl::WebContentsNode::WebContentsNode()
+    : parent_web_contents_(NULL) {

[Charlie Reis, 2015/04/30 23:06:46]

nullptr

[lazyboy, 2015/05/05 07:28:14]

Done.

+}
+
+WebContentsImpl::WebContentsNode::~WebContentsNode() {

[Charlie Reis, 2015/04/30 23:06:47]

Is there any way for us to enforce that a child WebContentsNode gets deleted
before its parent?  Otherwise the child could have a stale pointer to its parent
WebContents, risking a use-after-free.

[lazyboy, 2015/05/05 07:28:14]

Should we keep vector<WebContents*> children_ inside WebContentsNode?
That way we can invalidate the pointers when ~WebContents() is called.

+}
+
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(BrowserContext* browser_context,
                                  WebContentsImpl* opener)
     : delegate_(NULL),
       controller_(this, browser_context),
       render_view_host_delegate_view_(NULL),
       opener_(opener),
       created_with_opener_(!!opener),
 #if defined(OS_WIN)
@@ skipping 313 matching lines @@
 const GURL& WebContentsImpl::GetLastCommittedURL() const {
   // We may not have a navigation entry yet.
   NavigationEntry* entry = controller_.GetLastCommittedEntry();
   return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
 }
 
 WebContentsDelegate* WebContentsImpl::GetDelegate() {
   return delegate_;
 }
 
+int WebContentsImpl::AttachLocalFrameToGuest(WebContents* embedder_web_contents,
+                                             int embedder_frame_process_id,
+                                             int embedder_frame_routing_id) {
+  DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(

[Charlie Reis, 2015/04/30 23:06:46]

CHECK

[lazyboy, 2015/05/05 07:28:14]

Done.

+             switches::kSitePerProcess));
+  // 1. Create a link to our parent WebContents.
+  node_.set_parent_web_contents(
+      static_cast<WebContentsImpl*>(embedder_web_contents));
+
+  RenderFrameHostImpl* embedder_frame =
+      RenderFrameHostImpl::FromID(embedder_frame_process_id,
+                                  embedder_frame_routing_id);
+  DCHECK(embedder_frame);
+
+  // 2. Create a swapped out RVH and a proxy in our render manager, pointing
+  // to embedder site instance. The swapped out RVH will be used to send

[Charlie Reis, 2015/04/30 23:06:47]

the embedder's SiteInstance.

[lazyboy, 2015/05/05 07:28:14]

Done.

+  // postMessage to guest.

[Charlie Reis, 2015/04/30 23:06:46]

Alex pointed out that postMessage doesn't go through RenderViewHost anymore.  We
may still need the swapped out RVH (not sure), but you might want to check with
him about routing postMessage through the RFPH instead.

[lazyboy, 2015/05/05 07:28:14]

I've changed the CL to use <iframe>.contentWindow directly to send postMessage.

+  int swapped_out_render_view_routing_id = MSG_ROUTING_NONE;
+  int proxy_to_embedder_routing_id = MSG_ROUTING_NONE;
+  GetRenderManager()->CreateEmbedderProxy(
+      embedder_frame->GetSiteInstance(),
+      &swapped_out_render_view_routing_id,
+      &proxy_to_embedder_routing_id);
+
+  // 3. Swap the embedder's initial frame pointing to guest with the proxy

[Charlie Reis, 2015/04/30 23:06:47]

initial frame for the guest

[lazyboy, 2015/05/05 07:28:14]

Done.

+  // we've created above.
+  // The proxy has a CPFC and it uses the swapped out RV as its RenderWidget,
+  // which gives us input and rendering.
+  embedder_frame->frame_tree_node()->render_manager()
+      ->ReplaceWithGuestProxy(proxy_to_embedder_routing_id);
+
+  // The swapped out render view routing ID will be used to send
+  // postMessage.
+  return swapped_out_render_view_routing_id;

[Charlie Reis, 2015/04/30 23:06:46]

Is this needed, given that postMessage should go through RFPH?

[lazyboy, 2015/05/05 07:28:14]

Not anymore. this function returns void now.

+}
+
 void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
   // TODO(cbentzel): remove this debugging code?
   if (delegate == delegate_)
     return;
   if (delegate_)
     delegate_->Detach(this);
   delegate_ = delegate;
   if (delegate_) {
     delegate_->Attach(this);
     // Ensure the visible RVH reflects the new delegate's preferences.
@@ skipping 565 matching lines @@
               params.main_frame_routing_id == MSG_ROUTING_NONE) ||
          (params.routing_id != MSG_ROUTING_NONE &&
               params.main_frame_routing_id != MSG_ROUTING_NONE));
   GetRenderManager()->Init(
       params.browser_context, params.site_instance, params.routing_id,
       params.main_frame_routing_id);
 
   WebContentsViewDelegate* delegate =
       GetContentClient()->browser()->GetWebContentsViewDelegate(this);
 
-  if (browser_plugin_guest_) {
+  if (browser_plugin_guest_ &&
+          !base::CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kSitePerProcess)) {
     scoped_ptr<WebContentsView> platform_view(CreateWebContentsView(
         this, delegate, &render_view_host_delegate_view_));
 
     WebContentsViewGuest* rv = new WebContentsViewGuest(
         this, browser_plugin_guest_.get(), platform_view.Pass(),
         render_view_host_delegate_view_);
     render_view_host_delegate_view_ = rv;
     view_.reset(rv);
   } else {
     // Regular WebContentsView.
@@ skipping 282 matching lines @@
   if (delegate_)
     delegate_->LostMouseLock();
 }
 
 void WebContentsImpl::CreateNewWindow(
     int render_process_id,
     int route_id,
     int main_frame_route_id,
     const ViewHostMsg_CreateWindow_Params& params,
     SessionStorageNamespace* session_storage_namespace) {
+  // TODO(lazyboy): CreateNewWindow doesn't work for <webview> yet.
+  DCHECK(0);

[Charlie Reis, 2015/04/30 23:06:47]

This needs updating to work in non-site-per-process mode.

[lazyboy, 2015/05/05 07:28:14]

This doesn't break until we use new window from <webview>,
so I've put a NOTREACHED() here.

   // We usually create the new window in the same BrowsingInstance (group of
   // script-related windows), by passing in the current SiteInstance.  However,
   // if the opener is being suppressed (in a non-guest), we create a new
   // SiteInstance in its own BrowsingInstance.
   bool is_guest = BrowserPluginGuest::IsGuest(this);
 
   // If the opener is to be suppressed, the new window can be in any process.
   // Since routing ids are process specific, we must not have one passed in
   // as argument here.
   DCHECK(!params.opener_suppressed || route_id == MSG_ROUTING_NONE);
@@ skipping 201 matching lines @@
 void WebContentsImpl::ShowCreatedWidget(int route_id,
                                         bool is_fullscreen,
                                         const gfx::Rect& initial_rect) {
   RenderWidgetHostViewBase* widget_host_view =
       static_cast<RenderWidgetHostViewBase*>(GetCreatedWidget(route_id));
   if (!widget_host_view)
     return;
 
   RenderWidgetHostView* view = NULL;
   BrowserPluginGuest* guest = GetBrowserPluginGuest();
-  if (guest && guest->embedder_web_contents()) {
+  if (guest && guest->embedder_web_contents() &&
+          base::CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kSitePerProcess)) {
     view = guest->embedder_web_contents()->GetRenderWidgetHostView();
   } else {
     view = GetRenderWidgetHostView();
   }
 
   if (is_fullscreen) {
     DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
     view_->StoreFocus();
     fullscreen_widget_routing_id_ = route_id;
     if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
@@ skipping 2422 matching lines @@
     int proxy_routing_id,
     bool for_main_frame_navigation) {
   TRACE_EVENT0("browser,navigation",
                "WebContentsImpl::CreateRenderViewForRenderManager");
   // Can be NULL during tests.
   RenderWidgetHostViewBase* rwh_view;
   // TODO(kenrb): RenderWidgetHostViewChildFrame special casing is temporary
   // until RenderWidgetHost is attached to RenderFrameHost. We need to special
   // case this because RWH is still a base class of RenderViewHost, and child
   // frame RWHVs are unique in that they do not have their own WebContents.
-  if (!for_main_frame_navigation) {
+  bool is_guest_in_site_per_process = !!browser_plugin_guest_.get() &&
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess);
+  if (!for_main_frame_navigation || is_guest_in_site_per_process) {

[Charlie Reis, 2015/04/30 23:06:46]

Sounds like you might not need this if you don't pass
CREATE_RF_FOR_MAIN_FRAME_NAVIGATION?

[lazyboy, 2015/05/05 07:28:14]

Not passing CREATE_RF_FOR_MAIN_FRAME_NAVIGATION still sends
for_main_frame_navigation = true as RFHM::Navigate uses
frame_tree_node_->IsMainFrame() to set the param through RFHM::InitRenderView.

     RenderWidgetHostViewChildFrame* rwh_view_child =
         new RenderWidgetHostViewChildFrame(render_view_host);
     rwh_view = rwh_view_child;
+    if (is_guest_in_site_per_process)
+      GetRenderManager()->UpdateGuestRWHView(rwh_view_child);
   } else {
     rwh_view = view_->CreateViewForWidget(render_view_host, false);
   }
 
   // Now that the RenderView has been created, we need to tell it its size.
   if (rwh_view)
     rwh_view->SetSize(GetSizeForNewRenderView());
 
   // Make sure we use the correct starting page_id in the new RenderView.
   UpdateMaxPageIDIfNecessary(render_view_host);
@@ skipping 118 matching lines @@
   last_reported_encoding_ = encoding;
 
   canonical_encoding_ = GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 bool WebContentsImpl::IsHidden() {
   return capturer_count_ == 0 && !should_normally_be_visible_;
 }
 
+int64 WebContentsImpl::GetEmbedderFrameTreeNodeID() {
+  if (node_.parent_web_contents()) {
+    return node_.parent_web_contents()->GetFrameTree()->root()
+        ->frame_tree_node_id();
+  }
+  return -1;
+}
+
 RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
   return frame_tree_.root()->render_manager();
 }
 
 BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
   return browser_plugin_guest_.get();
 }
 
 void WebContentsImpl::SetBrowserPluginGuest(BrowserPluginGuest* guest) {
   CHECK(!browser_plugin_guest_);
+  CHECK(guest);
   browser_plugin_guest_.reset(guest);
 }
 
 BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
   return browser_plugin_embedder_.get();
 }
 
 void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
   if (browser_plugin_embedder_)
     return;
@@ skipping 86 matching lines @@
   node->render_manager()->ResumeResponseDeferredAtStart();
 }
 
 void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
   force_disable_overscroll_content_ = force_disable;
   if (view_)
     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 }
 
 }  // namespace content