Handle frame openers in the same FrameTree when navigating subframes.

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 <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 400 matching lines @@
     // Instruct the destination render frame host to set up a Mojo connection
     // with the new render frame if necessary.  Note that this call needs to
     // occur before initializing the RenderView; the flow of creating the
     // RenderView can cause browser-side code to execute that expects the this
     // RFH's ServiceRegistry to be initialized (e.g., if the site is a WebUI
     // site that is handled via Mojo, then Mojo WebUI code in //chrome will
     // add a service to this RFH's ServiceRegistry).
     dest_render_frame_host->SetUpMojoIfNeeded();
 
     // Recreate the opener chain.
-    CreateOpenerProxiesIfNeeded(dest_render_frame_host->GetSiteInstance());
+    CreateOpenerProxies(dest_render_frame_host->GetSiteInstance(),
+                        frame_tree_node_);
     if (!InitRenderView(dest_render_frame_host->render_view_host(),
                         MSG_ROUTING_NONE,
                         frame_tree_node_->IsMainFrame()))
       return nullptr;
 
     // Now that we've created a new renderer, be sure to hide it if it isn't
     // our primary one.  Otherwise, we might crash if we try to call Show()
     // on it later.
     if (dest_render_frame_host != render_frame_host_) {
       if (dest_render_frame_host->GetView())
@@ skipping 604 matching lines @@
     }
   }
   DCHECK(navigation_rfh &&
          (navigation_rfh == render_frame_host_.get() ||
           navigation_rfh == speculative_render_frame_host_.get()));
 
   // If the RenderFrame that needs to navigate is not live (its process was just
   // created or has crashed), initialize it.
   if (!navigation_rfh->IsRenderFrameLive()) {
     // Recreate the opener chain.
-    CreateOpenerProxiesIfNeeded(navigation_rfh->GetSiteInstance());
+    CreateOpenerProxies(navigation_rfh->GetSiteInstance(), frame_tree_node_);
     if (!InitRenderView(navigation_rfh->render_view_host(), MSG_ROUTING_NONE,
                         frame_tree_node_->IsMainFrame())) {
       return nullptr;
     }
 
     if (navigation_rfh == render_frame_host_) {
       // TODO(nasko): This is a very ugly hack. The Chrome extensions process
       // manager still uses NotificationService and expects to see a
       // RenderViewHost changed notification after WebContents and
       // RenderFrameHostManager are completely initialized. This should be
@@ skipping 514 matching lines @@
 
   // Create a non-swapped-out RFH with the given opener.
   pending_render_frame_host_ = CreateRenderFrame(
       new_instance, pending_web_ui(), create_render_frame_flags, nullptr);
 }
 
 void RenderFrameHostManager::CreateProxiesForNewRenderFrameHost(
     SiteInstance* old_instance,
     SiteInstance* new_instance) {
   // Only create opener proxies if they are in the same BrowsingInstance.
-  if (new_instance->IsRelatedSiteInstance(old_instance))
-    CreateOpenerProxiesIfNeeded(new_instance);
-  if (SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
-    // Ensure that the frame tree has RenderFrameProxyHosts for the new
-    // SiteInstance in all nodes except the current one.  We do this for all
-    // frames in the tree, whether they are in the same BrowsingInstance or not.
-    // We will still check whether two frames are in the same BrowsingInstance
-    // before we allow them to interact (e.g., postMessage).
+  if (new_instance->IsRelatedSiteInstance(old_instance)) {
+    CreateOpenerProxies(new_instance, frame_tree_node_);
+  } else if (SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
+    // Ensure that the frame tree has RenderFrameProxyHosts for the
+    // new SiteInstance in all nodes except the current one.  We do this for
+    // all frames in the tree, whether they are in the same BrowsingInstance or
+    // not.  If |new_instance| is in the same BrowsingInstance as
+    // |old_instance|, this will be done as part of CreateOpenerProxies above;
+    // otherwise, we do this here.  We will still check whether two frames are
+    // in the same BrowsingInstance before we allow them to interact (e.g.,
+    // postMessage).
     frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance(
         frame_tree_node_, new_instance);
   }
 }
 
 void RenderFrameHostManager::CreateProxiesForNewNamedFrame() {
   if (!SiteIsolationPolicy::AreCrossProcessFramesPossible())
     return;
 
   DCHECK(!frame_tree_node_->frame_name().empty());
@@ skipping 277 matching lines @@
 }
 
 void RenderFrameHostManager::EnsureRenderViewInitialized(
     RenderViewHostImpl* render_view_host,
     SiteInstance* instance) {
   DCHECK(frame_tree_node_->IsMainFrame());
 
   if (render_view_host->IsRenderViewLive())
     return;
 
-  // Recreate the opener chain.
-  CreateOpenerProxiesIfNeeded(instance);
-
   // If the proxy in |instance| doesn't exist, this RenderView is not swapped
   // out and shouldn't be reinitialized here.
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   if (!proxy)
     return;
 
   InitRenderView(render_view_host, proxy->GetRoutingID(), false);
   proxy->set_render_frame_proxy_created(true);
 }
 
@@ skipping 554 matching lines @@
   return proxy_hosts_->Get(instance->GetId());
 }
 
 std::map<int, RenderFrameProxyHost*>
 RenderFrameHostManager::GetAllProxyHostsForTesting() {
   std::map<int, RenderFrameProxyHost*> result;
   result.insert(proxy_hosts_->begin(), proxy_hosts_->end());
   return result;
 }
 
-void RenderFrameHostManager::CreateOpenerProxiesIfNeeded(
-    SiteInstance* instance) {
-  FrameTreeNode* opener = frame_tree_node_->opener();
-  if (!opener)
-    return;
-
-  // TODO(alexmos): This should process all openers in the current frame tree,
-  // not just current node's opener.
-
-  // Create proxies for the opener chain.
-  opener->render_manager()->CreateOpenerProxies(instance);
-}
-
 void RenderFrameHostManager::CollectOpenerFrameTrees(
     std::vector<FrameTree*>* opener_frame_trees,
     base::hash_set<FrameTreeNode*>* nodes_with_back_links) {
   CHECK(opener_frame_trees);
   opener_frame_trees->push_back(frame_tree_node_->frame_tree());
 
   size_t visited_index = 0;
   while (visited_index < opener_frame_trees->size()) {
     FrameTree* frame_tree = (*opener_frame_trees)[visited_index];
     visited_index++;
     frame_tree->ForEach(base::Bind(&OpenerForFrameTreeNode, visited_index,
                                    opener_frame_trees, nodes_with_back_links));
   }
 }
 
-void RenderFrameHostManager::CreateOpenerProxies(SiteInstance* instance) {
+void RenderFrameHostManager::CreateOpenerProxies(
+    SiteInstance* instance,
+    FrameTreeNode* skip_this_node) {
   std::vector<FrameTree*> opener_frame_trees;
   base::hash_set<FrameTreeNode*> nodes_with_back_links;
 
   CollectOpenerFrameTrees(&opener_frame_trees, &nodes_with_back_links);
 
   // Create opener proxies for frame trees, processing furthest openers from
   // this node first and this node last.  In the common case without cycles,
   // this will ensure that each tree's openers are created before the tree's
   // nodes need to reference them.
   for (int i = opener_frame_trees.size() - 1; i >= 0; i--) {
     opener_frame_trees[i]
         ->root()
         ->render_manager()
-        ->CreateOpenerProxiesForFrameTree(instance);
+        ->CreateOpenerProxiesForFrameTree(instance, skip_this_node);
   }
 
   // Set openers for nodes in |nodes_with_back_links| in a second pass.
   // The proxies created at these FrameTreeNodes in
   // CreateOpenerProxiesForFrameTree won't have their opener routing ID
   // available when created due to cycles or back links in the opener chain.
   // They must have their openers updated as a separate step after proxy
   // creation.
   for (const auto& node : nodes_with_back_links) {
     RenderFrameProxyHost* proxy =
         node->render_manager()->GetRenderFrameProxyHost(instance);
     // If there is no proxy, the cycle may involve nodes in the same process,
     // or, if this is a subframe, --site-per-process may be off.  Either way,
     // there's nothing more to do.
     if (!proxy)
       continue;
 
     int opener_routing_id =
         node->render_manager()->GetOpenerRoutingID(instance);
     DCHECK_NE(opener_routing_id, MSG_ROUTING_NONE);
     proxy->Send(new FrameMsg_UpdateOpener(proxy->GetRoutingID(),
                                           opener_routing_id));
   }
 }
 
 void RenderFrameHostManager::CreateOpenerProxiesForFrameTree(
-    SiteInstance* instance) {
-  // If any of the RenderViewHosts (current, pending, or swapped out) for this
-  // FrameTree has the same SiteInstance, then we can return early, since
-  // proxies for other nodes in the tree should also exist (when in
-  // site-per-process mode).  An exception is if we are in
-  // IsSwappedOutStateForbidden mode and find a pending RenderViewHost: in this
-  // case, we should still create a proxy, which will allow communicating with
-  // the opener until the pending RenderView commits, or if the pending
-  // navigation is canceled.
-  FrameTree* frame_tree = frame_tree_node_->frame_tree();
-  RenderViewHostImpl* rvh = frame_tree->GetRenderViewHost(instance);
-  bool need_proxy_for_pending_rvh =
-      SiteIsolationPolicy::IsSwappedOutStateForbidden() &&
-      (rvh == pending_render_view_host());
-  if (rvh && rvh->IsRenderViewLive() && !need_proxy_for_pending_rvh)
+    SiteInstance* instance,
+    FrameTreeNode* skip_this_node) {
+  // Currently, this function is only called on main frames.  It should
+  // actually work correctly for subframes as well, so if that need ever
+  // arises, it should be sufficient to remove this DCHECK.
+  DCHECK(frame_tree_node_->IsMainFrame());
+
+  if (frame_tree_node_ == skip_this_node)
     return;
 
-  if (SiteIsolationPolicy::IsSwappedOutStateForbidden()) {
-    // Ensure that all the nodes in the opener's frame tree have
-    // RenderFrameProxyHosts for the new SiteInstance.
-    frame_tree->CreateProxiesForSiteInstance(nullptr, instance);
-  } else if (rvh && !rvh->IsRenderViewLive()) {
-    EnsureRenderViewInitialized(rvh, instance);
+  FrameTree* frame_tree = frame_tree_node_->frame_tree();
+  if (SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
+    // Ensure that all the nodes in the opener's FrameTree have
+    // RenderFrameProxyHosts for the new SiteInstance.  Only pass the node to
+    // be skipped if it's in the same FrameTree.
+    if (skip_this_node && skip_this_node->frame_tree() != frame_tree)
+      skip_this_node = nullptr;
+    frame_tree->CreateProxiesForSiteInstance(skip_this_node, instance);
   } else {
-    // Create a swapped out RenderView in the given SiteInstance if none exists,
-    // setting its opener to the given route_id.  Since the opener can point to
-    // a subframe, do this on the root frame of the opener's frame tree.
-    // Return the new view's route_id.
-    frame_tree->root()->render_manager()->
-        CreateRenderFrame(instance, nullptr,
-                          CREATE_RF_FOR_MAIN_FRAME_NAVIGATION |
-                          CREATE_RF_SWAPPED_OUT | CREATE_RF_HIDDEN,
-                          nullptr);
+    // If any of the RenderViewHosts (current, pending, or swapped out) for this
+    // FrameTree has the same SiteInstance, then we can return early and reuse
+    // them.  An exception is if we are in IsSwappedOutStateForbidden mode and
+    // find a pending RenderViewHost: in this case, we should still create a
+    // proxy, which will allow communicating with the opener until the pending
+    // RenderView commits, or if the pending navigation is canceled.
+    RenderViewHostImpl* rvh = frame_tree->GetRenderViewHost(instance);
+    bool need_proxy_for_pending_rvh =
+        SiteIsolationPolicy::IsSwappedOutStateForbidden() &&
+        (rvh == pending_render_view_host());
+    if (rvh && rvh->IsRenderViewLive() && !need_proxy_for_pending_rvh)
+      return;
+
+    if (rvh && !rvh->IsRenderViewLive()) {
+      EnsureRenderViewInitialized(rvh, instance);
+    } else {
+      // Create a swapped out RenderView in the given SiteInstance if none
+      // exists. Since an opener can point to a subframe, do this on the root
+      // frame of the current opener's frame tree.
+      frame_tree->root()->render_manager()->
+          CreateRenderFrame(instance, nullptr,
+                            CREATE_RF_FOR_MAIN_FRAME_NAVIGATION |
+                            CREATE_RF_SWAPPED_OUT | CREATE_RF_HIDDEN,
+                            nullptr);
+    }
   }
 }
 
 int RenderFrameHostManager::GetOpenerRoutingID(SiteInstance* instance) {
   if (!frame_tree_node_->opener())
     return MSG_ROUTING_NONE;
 
   return frame_tree_node_->opener()
       ->render_manager()
       ->GetRoutingIdForSiteInstance(instance);
 }
 
 }  // namespace content