Avoid creating a RenderWidgetHostView for proxies.

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 379 matching lines @@
 
   // If the current render_frame_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_frame_host fetches
   // its first page.  (Bug 1145340)
   if (dest_render_frame_host != render_frame_host_ &&
       !render_frame_host_->IsRenderFrameLive()) {
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
     delegate_->CreateRenderViewForRenderManager(
         render_frame_host_->render_view_host(), MSG_ROUTING_NONE,
-        MSG_ROUTING_NONE, frame_tree_node_->current_replication_state(),
-        frame_tree_node_->IsMainFrame());
+        MSG_ROUTING_NONE, frame_tree_node_->current_replication_state());
   }
 
   // If the renderer crashed, then try to create a new one to satisfy this
   // navigation request.
   if (!dest_render_frame_host->IsRenderFrameLive()) {
     // 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());
     if (!InitRenderView(dest_render_frame_host->render_view_host(),
-                        MSG_ROUTING_NONE,
-                        frame_tree_node_->IsMainFrame()))
+                        MSG_ROUTING_NONE))
       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())
         dest_render_frame_host->GetView()->Hide();
     } else {
       // TODO(nasko): This is a very ugly hack. The Chrome extensions process
@@ skipping 602 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());
-    if (!InitRenderView(navigation_rfh->render_view_host(), MSG_ROUTING_NONE,
-                        frame_tree_node_->IsMainFrame())) {
+    if (!InitRenderView(navigation_rfh->render_view_host(), MSG_ROUTING_NONE)) {
       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 482 matching lines @@
   // to open a new tab to an interstitial-inducing URL, and then navigates
   // the page to a different same-site URL.  (This seems very unlikely in
   // practice.)
   if (current_entry)
     return current_entry->GetURL();
   return current_instance->GetSiteURL();
 }
 
 void RenderFrameHostManager::CreatePendingRenderFrameHost(
     SiteInstance* old_instance,
-    SiteInstance* new_instance,
-    bool is_main_frame) {
+    SiteInstance* new_instance) {
   int create_render_frame_flags = 0;
-  if (is_main_frame)
-    create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION;
-
   if (delegate_->IsHidden())
     create_render_frame_flags |= CREATE_RF_HIDDEN;
 
   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.
@@ skipping 112 matching lines @@
   // 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;
   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(),
                         create_render_frame_flags, nullptr);
 
   if (!speculative_render_frame_host_) {
     speculative_web_ui_.reset();
     return false;
   }
@@ skipping 24 matching lines @@
 
   // We are creating a pending, speculative or swapped out RFH here. We should
   // never create it in the same SiteInstance as our current RFH.
   CHECK_NE(render_frame_host_->GetSiteInstance(), instance);
 
   // Check if we've already created an RFH for this SiteInstance.  If so, try
   // to re-use the existing one, which has already been initialized.  We'll
   // remove it from the list of proxy hosts below if it will be active.
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   if (proxy && proxy->render_frame_host()) {
+    RenderViewHost* render_view_host = proxy->GetRenderViewHost();
     CHECK(!swapped_out_forbidden);
     if (view_routing_id_ptr)
       *view_routing_id_ptr = proxy->GetRenderViewHost()->GetRoutingID();
     // Delete the existing RenderFrameProxyHost, but reuse the RenderFrameHost.
     // Prevent the process from exiting while we're trying to use it.
     if (!swapped_out) {
       new_render_frame_host = proxy->PassFrameHostOwnership();
       new_render_frame_host->GetProcess()->AddPendingView();
 
       proxy_hosts_->Remove(instance->GetId());
       // NB |proxy| is deleted at this point.
     }
+    if (!render_view_host->GetView()) {
+      delegate_->CreateRenderWidgetHostViewForRenderManager(render_view_host,
+                                                            false);

[Charlie Reis, 2015/08/31 19:02:51]

How do we know main_frame_is_proxy is false?  This could be a CreateRenderFrame
call for a subframe, when the main frame has a proxy.

[lfg, 2015/09/02 00:32:16]

You're right, we don't know that. What ends up happening is that it was creating
the RWHV even for main frames, when the subframes were getting initialized.

+    }
   } else {
     // Create a new RenderFrameHost if we don't find an existing one.
     new_render_frame_host = CreateRenderFrameHost(instance, MSG_ROUTING_NONE,
                                                   MSG_ROUTING_NONE, flags);
     RenderViewHostImpl* render_view_host =
         new_render_frame_host->render_view_host();
     int proxy_routing_id = MSG_ROUTING_NONE;
 
     // Prevent the process from exiting while we're trying to navigate in it.
     // Otherwise, if the new RFH is swapped out already, store it.
     if (!swapped_out) {
       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_->Add(instance->GetId(), make_scoped_ptr(proxy));
       proxy_routing_id = proxy->GetRoutingID();
       proxy->TakeFrameHostOwnership(new_render_frame_host.Pass());
     }
 
-    success = InitRenderView(render_view_host, proxy_routing_id,
-                             !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION));
+    success = InitRenderView(render_view_host, proxy_routing_id);
+    if (proxy_routing_id == MSG_ROUTING_NONE && !render_view_host->GetView()) {

[Charlie Reis, 2015/08/31 19:02:51]

Maybe using |!swapped_out| would be clearer than |proxy_routing_id ==
MSG_ROUTING_NONE|?  I had to stare at this to see that we're only creating the
RWHV if the frame is active (and doesn't yet have a view).

[lfg, 2015/09/02 00:32:16]

Done.

+      delegate_->CreateRenderWidgetHostViewForRenderManager(render_view_host,
+                                                            false);

[Charlie Reis, 2015/08/31 19:02:51]

Again, this could be a subframe, so I'm not sure how we know that
main_frame_is_proxy is false.

[lfg, 2015/09/02 00:32:16]

Same as above. I've added a IsMainFrame() check, which should fix this.

+    }
+
     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_->Add(instance->GetId(), make_scoped_ptr(proxy));
   }
 
   if (SiteIsolationPolicy::IsSwappedOutStateForbidden() &&
       frame_tree_node_->IsMainFrame()) {
-    InitRenderView(render_view_host, proxy->GetRoutingID(), true);
+    InitRenderView(render_view_host, proxy->GetRoutingID());
     proxy->set_render_frame_proxy_created(true);
   } else {
     proxy->InitRenderFrameProxy();
   }
 
   return proxy->GetRoutingID();
 }
 
 void RenderFrameHostManager::CreateProxiesForChildFrame(FrameTreeNode* child) {
   for (const auto& pair : *proxy_hosts_) {
@@ skipping 17 matching lines @@
 
   // 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);
+  InitRenderView(render_view_host, proxy->GetRoutingID());
   proxy->set_render_frame_proxy_created(true);
 }
 
 void RenderFrameHostManager::CreateOuterDelegateProxy(
     SiteInstance* outer_contents_site_instance,
     RenderFrameHostImpl* render_frame_host) {
   CHECK(BrowserPluginGuestMode::UseCrossProcessFramesForGuests());
   RenderFrameProxyHost* proxy = new RenderFrameProxyHost(
       outer_contents_site_instance, nullptr, frame_tree_node_);
   proxy_hosts_->Add(outer_contents_site_instance->GetId(),
@@ skipping 14 matching lines @@
 }
 
 void RenderFrameHostManager::SetRWHViewForInnerContents(
     RenderWidgetHostView* child_rwhv) {
   DCHECK(ForInnerDelegate() && frame_tree_node_->IsMainFrame());
   GetProxyToOuterDelegate()->SetChildRWHView(child_rwhv);
 }
 
 bool RenderFrameHostManager::InitRenderView(
     RenderViewHostImpl* render_view_host,
-    int proxy_routing_id,
-    bool for_main_frame_navigation) {
+    int proxy_routing_id) {
   // 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;
 
   // If the ongoing navigation is to a WebUI and the RenderView is not in a
@@ skipping 16 matching lines @@
       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_frame_routing_id, proxy_routing_id,
-      frame_tree_node_->current_replication_state(), for_main_frame_navigation);
+      frame_tree_node_->current_replication_state());
 }
 
 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 289 matching lines @@
 
     // New SiteInstance: create a pending RFH to navigate.
 
     // This will possibly create (set to nullptr) a Web UI object for the
     // pending page. We'll use this later to give the page special access. This
     // must happen before the new renderer is created below so it will get
     // bindings. It must also happen after the above conditional call to
     // CancelPending(), otherwise CancelPending may clear the pending_web_ui_
     // and the page will not have its bindings set appropriately.
     SetPendingWebUI(dest_url, bindings);
-    CreatePendingRenderFrameHost(current_instance, new_instance.get(),
-                                 frame_tree_node_->IsMainFrame());
+    CreatePendingRenderFrameHost(current_instance, new_instance.get());
     if (!pending_render_frame_host_)
       return nullptr;
 
     // Check if our current RFH is live before we set up a transition.
     if (!render_frame_host_->IsRenderFrameLive()) {
       // The current RFH is not live.  There's no reason to sit around with a
       // sad tab or a newly created RFH while we wait for the pending RFH to
       // navigate.  Just switch to the pending RFH now and go back to normal.
       // (Note that we don't care about on{before}unload handlers if the current
       // RFH isn't live.)
@@ skipping 260 matching lines @@
     // 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);
   } 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);
+    frame_tree->root()->render_manager()->CreateRenderFrame(
+        instance, nullptr, 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