Move browser-to-renderer opener plumbing to frame routing IDs

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 259 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.
-    int opener_route_id =
-        CreateOpenerProxiesIfNeeded(dest_render_frame_host->GetSiteInstance());
+    CreateOpenerProxiesIfNeeded(dest_render_frame_host->GetSiteInstance());
     if (!InitRenderView(dest_render_frame_host->render_view_host(),
-                        opener_route_id,
                         MSG_ROUTING_NONE,
                         frame_tree_node_->IsMainFrame()))
       return NULL;
 
     // 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())
         dest_render_frame_host->GetView()->Hide();
@@ skipping 562 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.
-    int opener_route_id =
-        CreateOpenerProxiesIfNeeded(navigation_rfh->GetSiteInstance());
-    if (!InitRenderView(navigation_rfh->render_view_host(), opener_route_id,
-                        MSG_ROUTING_NONE, frame_tree_node_->IsMainFrame())) {
+    CreateOpenerProxiesIfNeeded(navigation_rfh->GetSiteInstance());
+    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
       // removed once the process manager moves away from NotificationService.
       // See https://crbug.com/462682.
@@ skipping 512 matching lines @@
   if (pending_render_frame_host_)
     CancelPending();
 
   // The process for the new SiteInstance may (if we're sharing a process with
   // another host that already initialized it) or may not (we have our own
   // process or the existing process crashed) have been initialized. Calling
   // Init multiple times will be ignored, so this is safe.
   if (!new_instance->GetProcess()->Init())
     return;
 
-  int opener_route_id = CreateProxiesForNewRenderFrameHost(
-      old_instance, new_instance, &create_render_frame_flags);
+  CreateProxiesForNewRenderFrameHost(old_instance, new_instance,
+                                     &create_render_frame_flags);
 
   // Create a non-swapped-out RFH with the given opener.
-  pending_render_frame_host_ =
-      CreateRenderFrame(new_instance, pending_web_ui(), opener_route_id,
-                        create_render_frame_flags, nullptr);
+  pending_render_frame_host_ = CreateRenderFrame(
+      new_instance, pending_web_ui(), create_render_frame_flags, nullptr);
 }
 
-int RenderFrameHostManager::CreateProxiesForNewRenderFrameHost(
+void RenderFrameHostManager::CreateProxiesForNewRenderFrameHost(
     SiteInstance* old_instance,
     SiteInstance* new_instance,
     int* create_render_frame_flags) {
-  int opener_route_id = MSG_ROUTING_NONE;
   // Only create opener proxies if they are in the same BrowsingInstance.
   if (new_instance->IsRelatedSiteInstance(old_instance))
-    opener_route_id = CreateOpenerProxiesIfNeeded(new_instance);
+    CreateOpenerProxiesIfNeeded(new_instance);
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess)) {
     // 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).
     frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance(
         frame_tree_node_, new_instance);
     // RenderFrames in different processes from their parent RenderFrames
     // in the frame tree require RenderWidgets for rendering and processing
     // input events.
     if (frame_tree_node_->parent() &&
         frame_tree_node_->parent()->current_frame_host()->GetSiteInstance() !=
             new_instance)
       *create_render_frame_flags |= CREATE_RF_NEEDS_RENDER_WIDGET_HOST;
   }
-  return opener_route_id;
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost(
     SiteInstance* site_instance,
     int view_routing_id,
     int frame_routing_id,
     int flags) {
   if (frame_routing_id == MSG_ROUTING_NONE)
     frame_routing_id = site_instance->GetProcess()->GetNextRoutingID();
 
@@ skipping 37 matching lines @@
   speculative_web_ui_ = CreateWebUI(url, bindings);
 
   // The process for the new SiteInstance may (if we're sharing a process with
   // another host that already initialized it) or may not (we have our own
   // process or the existing process crashed) have been initialized. Calling
   // Init multiple times will be ignored, so this is safe.
   if (!new_instance->GetProcess()->Init())
     return false;
 
   int create_render_frame_flags = 0;
-  int opener_route_id = CreateProxiesForNewRenderFrameHost(
-      old_instance, new_instance, &create_render_frame_flags);
+  CreateProxiesForNewRenderFrameHost(old_instance, new_instance,
+                                     &create_render_frame_flags);
 
   if (frame_tree_node_->IsMainFrame())
     create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION;
   if (delegate_->IsHidden())
     create_render_frame_flags |= CREATE_RF_HIDDEN;
   speculative_render_frame_host_ =
       CreateRenderFrame(new_instance, speculative_web_ui_.get(),
-                        opener_route_id, create_render_frame_flags, nullptr);
+                        create_render_frame_flags, nullptr);
 
   if (!speculative_render_frame_host_) {
     speculative_web_ui_.reset();
     return false;
   }
   return true;
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrame(
     SiteInstance* instance,
     WebUIImpl* web_ui,
-    int opener_route_id,
     int flags,
     int* view_routing_id_ptr) {
   bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
   bool swapped_out_forbidden = IsSwappedOutStateForbidden();
   bool is_site_per_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSitePerProcess);
 
   CHECK(instance);
   CHECK_IMPLIES(swapped_out_forbidden, !swapped_out);
   CHECK_IMPLIES(!is_site_per_process, frame_tree_node_->IsMainFrame());
@@ skipping 41 matching lines @@
       new_render_frame_host->GetProcess()->AddPendingView();
     } else {
       proxy = new RenderFrameProxyHost(
           new_render_frame_host->GetSiteInstance(),
           new_render_frame_host->render_view_host(), frame_tree_node_);
       proxy_hosts_[instance->GetId()] = proxy;
       proxy_routing_id = proxy->GetRoutingID();
       proxy->TakeFrameHostOwnership(new_render_frame_host.Pass());
     }
 
-    success =
-        InitRenderView(render_view_host, opener_route_id, proxy_routing_id,
-                       !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION));
+    success = InitRenderView(render_view_host, proxy_routing_id,
+                             !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION));
     if (success) {
       // Remember that InitRenderView also created the RenderFrameProxy.
       if (swapped_out)
         proxy->set_render_frame_proxy_created(true);
       if (frame_tree_node_->IsMainFrame()) {
         // Don't show the main frame's view until we get a DidNavigate from it.
         // Only the RenderViewHost for the top-level RenderFrameHost has a
         // RenderWidgetHostView; RenderWidgetHosts for out-of-process iframes
         // will be created later and hidden.
         if (render_view_host->GetView())
@@ skipping 64 matching lines @@
     return proxy->GetRoutingID();
 
   if (!proxy) {
     proxy = new RenderFrameProxyHost(
         instance, render_view_host, frame_tree_node_);
     proxy_hosts_[instance->GetId()] = proxy;
   }
 
   if (RenderFrameHostManager::IsSwappedOutStateForbidden() &&
       frame_tree_node_->IsMainFrame()) {
-    InitRenderView(
-        render_view_host, MSG_ROUTING_NONE, proxy->GetRoutingID(), true);
+    InitRenderView(render_view_host, proxy->GetRoutingID(), true);
     proxy->set_render_frame_proxy_created(true);
   } else {
     proxy->InitRenderFrameProxy();
   }
 
   return proxy->GetRoutingID();
 }
 
 void RenderFrameHostManager::CreateProxiesForChildFrame(FrameTreeNode* child) {
   for (const auto& pair : proxy_hosts_) {
     child->render_manager()->CreateRenderFrameProxy(
         pair.second->GetSiteInstance());
   }
 }
 
 void RenderFrameHostManager::EnsureRenderViewInitialized(
     RenderViewHostImpl* render_view_host,
     SiteInstance* instance) {
   DCHECK(frame_tree_node_->IsMainFrame());
 
   if (render_view_host->IsRenderViewLive())
     return;
 
   // Recreate the opener chain.
-  int opener_route_id = CreateOpenerProxiesIfNeeded(instance);
+  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, opener_route_id, proxy->GetRoutingID(),
-                 false);
+  InitRenderView(render_view_host, 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_);
@@ skipping 14 matching lines @@
 }
 
 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;
 
   // We may have initialized this RenderViewHost for another RenderFrameHost.
   if (render_view_host->IsRenderViewLive())
     return true;
@@ skipping 13 matching lines @@
     render_view_host->AllowBindings(dest_web_ui->GetBindings());
   } else {
     // Ensure that we don't create an unprivileged RenderView in a WebUI-enabled
     // process unless it's swapped out.
     if (render_view_host->is_active()) {
       CHECK(!ChildProcessSecurityPolicyImpl::GetInstance()->HasWebUIBindings(
                 render_view_host->GetProcess()->GetID()));
     }
   }
 
+  int opener_frame_routing_id =
+      GetOpenerRoutingID(render_view_host->GetSiteInstance());
+
   return delegate_->CreateRenderViewForRenderManager(
-      render_view_host,
-      opener_route_id,
-      proxy_routing_id,
-      frame_tree_node_->current_replication_state(),
-      for_main_frame_navigation);
+      render_view_host, opener_frame_routing_id, proxy_routing_id,
+      frame_tree_node_->current_replication_state(), for_main_frame_navigation);
 }
 
 bool RenderFrameHostManager::InitRenderFrame(
     RenderFrameHostImpl* render_frame_host) {
   if (render_frame_host->IsRenderFrameLive())
     return true;
 
   int parent_routing_id = MSG_ROUTING_NONE;
   int previous_sibling_routing_id = MSG_ROUTING_NONE;
   int proxy_routing_id = MSG_ROUTING_NONE;
@@ skipping 35 matching lines @@
   return delegate_->CreateRenderFrameForRenderManager(
       render_frame_host, parent_routing_id, previous_sibling_routing_id,
       proxy_routing_id);
 }
 
 int RenderFrameHostManager::GetRoutingIdForSiteInstance(
     SiteInstance* site_instance) {
   if (render_frame_host_->GetSiteInstance() == site_instance)
     return render_frame_host_->GetRoutingID();
 
-  RenderFrameProxyHostMap::iterator iter =
-      proxy_hosts_.find(site_instance->GetId());
-  if (iter != proxy_hosts_.end())
-    return iter->second->GetRoutingID();
+  // If there is a matching pending RFH, only return it if swapped out is
+  // allowed, since otherwise there should be a proxy that should be used
+  // instead.
+  if (pending_render_frame_host_ &&
+      pending_render_frame_host_->GetSiteInstance() == site_instance &&
+      !RenderFrameHostManager::IsSwappedOutStateForbidden())
+    return pending_render_frame_host_->GetRoutingID();
+
+  RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(site_instance);
+  if (proxy)
+    return proxy->GetRoutingID();
 
   return MSG_ROUTING_NONE;
 }
 
 void RenderFrameHostManager::CommitPending() {
   TRACE_EVENT1("navigation", "RenderFrameHostManager::CommitPending",
                "FrameTreeNode id", frame_tree_node_->frame_tree_node_id());
   bool browser_side_navigation =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation);
@@ skipping 422 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);
   }
 }
 
-int RenderFrameHostManager::CreateOpenerProxiesIfNeeded(
+void RenderFrameHostManager::CreateOpenerProxiesIfNeeded(
     SiteInstance* instance) {
   FrameTreeNode* opener = frame_tree_node_->opener();
   if (!opener)
-    return MSG_ROUTING_NONE;
+    return;
 
   // Create proxies for the opener chain.
-  return opener->render_manager()->CreateOpenerProxies(instance);
+  opener->render_manager()->CreateOpenerProxies(instance);
 }
 
-int RenderFrameHostManager::CreateOpenerProxies(SiteInstance* instance) {
-  int opener_route_id = MSG_ROUTING_NONE;
-
+void RenderFrameHostManager::CreateOpenerProxies(SiteInstance* instance) {
   // If this tab has an opener, recursively create proxies for the nodes on its
   // frame tree.
   // TODO(alexmos): Once we allow frame openers to be updated (which can happen
   // via window.open(url, "target_frame")), this will need to be resilient to
   // cycles. It will also need to handle tabs that have multiple openers (e.g.,
   // main frame and subframe could have different openers, each of which must
   // be traversed).
   FrameTreeNode* opener = frame_tree_node_->opener();
   if (opener)
-    opener_route_id = opener->render_manager()->CreateOpenerProxies(instance);
+    opener->render_manager()->CreateOpenerProxies(instance);
 
   // If any of the RenderViews (current, pending, or swapped out) for this
-  // FrameTree has the same SiteInstance, use it.  If such a RenderView exists,
-  // that implies that proxies for all nodes in the tree should also exist
-  // (when in site-per-process mode), so it is safe to exit early.
+  // 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).
   FrameTree* frame_tree = frame_tree_node_->frame_tree();
   RenderViewHostImpl* rvh = frame_tree->GetRenderViewHost(instance);
   if (rvh && rvh->IsRenderViewLive())
-    return rvh->GetRoutingID();
+    return;
 
-  int render_view_routing_id = MSG_ROUTING_NONE;
   if (RenderFrameHostManager::IsSwappedOutStateForbidden()) {
     // Ensure that all the nodes in the opener's frame tree have
     // RenderFrameProxyHosts for the new SiteInstance.
     frame_tree->CreateProxiesForSiteInstance(nullptr, instance);
-    rvh = frame_tree->GetRenderViewHost(instance);
-    render_view_routing_id = rvh->GetRoutingID();
   } else if (rvh && !rvh->IsRenderViewLive()) {
     EnsureRenderViewInitialized(rvh, instance);
-    render_view_routing_id = rvh->GetRoutingID();
   } 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, opener_route_id,
+        CreateRenderFrame(instance, nullptr,
                           CREATE_RF_FOR_MAIN_FRAME_NAVIGATION |
                           CREATE_RF_SWAPPED_OUT | CREATE_RF_HIDDEN,
-                          &render_view_routing_id);
+                          nullptr);
   }
-  return render_view_routing_id;
+}
+
+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