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 277 matching lines @@
                                                     int identifier)
     : render_process_id(render_process_id),
       render_frame_id(render_frame_id),
       chooser(chooser),
       identifier(identifier) {
 }
 
 WebContentsImpl::ColorChooserInfo::~ColorChooserInfo() {
 }
 
+// WebContentsImpl::WebContentsTreeNode ----------------------------------------
+WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode()
+    : outer_web_contents_(nullptr),
+      outer_contents_frame_tree_node_id_(
+          FrameTreeNode::kFrameTreeNodeInvalidID) {
+}
+
+WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {
+  // Remove child pointer from our parent.
+  if (outer_web_contents_) {
+    ChildrenSet& child_ptrs_in_parent =
+        outer_web_contents_->node_->inner_web_contents_tree_nodes_;
+    ChildrenSet::iterator iter = child_ptrs_in_parent.find(this);
+    DCHECK(iter != child_ptrs_in_parent.end());
+    child_ptrs_in_parent.erase(this);
+  }
+
+  // Remove parent pointers from our children.
+  // TODO(lazyboy): We should destroy the children WebContentses too. If the
+  // children do not manage their own lifetime, then we would leak their
+  // WebContentses.
+  for (WebContentsTreeNode* child : inner_web_contents_tree_nodes_)
+    child->outer_web_contents_ = nullptr;
+}
+
+void WebContentsImpl::WebContentsTreeNode::ConnectToOuterWebContents(
+    WebContentsImpl* outer_web_contents,
+    RenderFrameHostImpl* outer_contents_frame) {
+  outer_web_contents_ = outer_web_contents;
+  outer_contents_frame_tree_node_id_ =
+      outer_contents_frame->frame_tree_node()->frame_tree_node_id();
+
+  if (!outer_web_contents_->node_)
+    outer_web_contents_->node_.reset(new WebContentsTreeNode());
+
+  outer_web_contents_->node_->inner_web_contents_tree_nodes_.insert(this);
+}
+
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
     : delegate_(NULL),
       controller_(this, browser_context),
       render_view_host_delegate_view_(NULL),
       created_with_opener_(false),
 #if defined(OS_WIN)
       accessible_parent_(NULL),
 #endif
@@ skipping 861 matching lines @@
 bool WebContentsImpl::NeedToFireBeforeUnload() {
   // TODO(creis): Should we fire even for interstitial pages?
   return WillNotifyDisconnection() && !ShowingInterstitialPage() &&
          !GetRenderViewHost()->SuddenTerminationAllowed();
 }
 
 void WebContentsImpl::DispatchBeforeUnload(bool for_cross_site_transition) {
   GetMainFrame()->DispatchBeforeUnload(for_cross_site_transition);
 }
 
+void WebContentsImpl::AttachToOuterWebContentsFrame(
+    WebContents* outer_web_contents,
+    RenderFrameHost* outer_contents_frame) {
+  CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSitePerProcess));
+  // Create a link to our outer WebContents.
+  node_.reset(new WebContentsTreeNode());
+  node_->ConnectToOuterWebContents(
+      static_cast<WebContentsImpl*>(outer_web_contents),
+      static_cast<RenderFrameHostImpl*>(outer_contents_frame));
+
+  DCHECK(outer_contents_frame);
+
+  // Create a proxy in top-level RenderFrameHostManager, pointing to the
+  // SiteInstance of the outer WebContents. The proxy will be used to send
+  // postMessage to the inner WebContents.
+  GetRenderManager()->CreateOuterDelegateProxy(
+      outer_contents_frame->GetSiteInstance(),
+      static_cast<RenderFrameHostImpl*>(outer_contents_frame));
+
+  GetRenderManager()->SetRWHViewForInnerContents(
+      GetRenderManager()->GetRenderWidgetHostView());
+}
+
 void WebContentsImpl::Stop() {
   GetRenderManager()->Stop();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, NavigationStopped());
 }
 
 WebContents* WebContentsImpl::Clone() {
   // We use our current SiteInstance since the cloned entry will use it anyway.
   // We pass our own opener so that the cloned page can access it if it was set
   // before.
   CreateParams create_params(GetBrowserContext(), GetSiteInstance());
@@ skipping 53 matching lines @@
          (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);
   frame_tree_.root()->SetFrameName(params.main_frame_name);
 
   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 280 matching lines @@
     int route_id,
     int main_frame_route_id,
     const ViewHostMsg_CreateWindow_Params& params,
     SessionStorageNamespace* session_storage_namespace) {
   // 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 (is_guest &&
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    // TODO(lazyboy): CreateNewWindow doesn't work for OOPIF-based <webview>
+    // yet.
+    NOTREACHED();
+  }
+
   // 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);
 
   scoped_refptr<SiteInstance> site_instance =
       params.opener_suppressed && !is_guest ?
       SiteInstance::CreateForURL(GetBrowserContext(), params.target_url) :
       GetSiteInstance();
 
@@ skipping 2352 matching lines @@
   // probably not a risk for apps since other pages won't have references
   // to App windows.
   return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
 }
 
 void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
   WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
       WebContents::FromRenderFrameHost(source_rfh));
 
   if (source_web_contents) {
+    // If this message is going to outer WebContents from inner WebContents,
+    // then we should not create a RenderView. AttachToOuterWebContentsFrame()
+    // already created a RenderFrameProxyHost for that purpose.
+    if (GetBrowserPluginEmbedder() &&
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kSitePerProcess)) {
+      return;
+    }
+
     if (GetBrowserPluginGuest()) {
       // We create a swapped out RenderView for the embedder in the guest's
       // render process but we intentionally do not expose the embedder's
       // opener chain to it.
       source_web_contents->CreateSwappedOutRenderView(GetSiteInstance());
     } else {
       RenderFrameHostImpl* source_rfhi =
           static_cast<RenderFrameHostImpl*>(source_rfh);
       source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
           GetSiteInstance());
@@ skipping 200 matching lines @@
     const FrameReplicationState& replicated_frame_state,
     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) {
     RenderWidgetHostViewChildFrame* rwh_view_child =
         new RenderWidgetHostViewChildFrame(render_view_host);
     rwh_view = 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());
@@ skipping 123 matching lines @@
   last_reported_encoding_ = encoding;
 
   canonical_encoding_ = GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 bool WebContentsImpl::IsHidden() {
   return capturer_count_ == 0 && !should_normally_be_visible_;
 }
 
+int WebContentsImpl::GetOuterDelegateFrameTreeNodeID() {
+  if (node_ && node_->outer_web_contents())
+    return node_->outer_contents_frame_tree_node_id();
+
+  return FrameTreeNode::kFrameTreeNodeInvalidID;
+}
+
 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 81 matching lines @@
   player_map->erase(it);
 }
 
 void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
   force_disable_overscroll_content_ = force_disable;
   if (view_)
     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 }
 
 }  // namespace content