Create swapped-out opener RVHs after a process swap.

content/browser/web_contents/render_view_host_manager.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/render_view_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 45 matching lines @@
   RenderViewHostImpl* render_view_host = render_view_host_;
   render_view_host_ = NULL;
   render_view_host->Shutdown();
 
   // Shut down any swapped out RenderViewHosts.
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     iter->second->Shutdown();
   }
+
+  registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSING,

[Matt Perry, 2012/05/01 20:45:17]

Is this needed? See comment in web_contents_impl.cc

[Charlie Reis, 2012/05/01 21:25:53]

Ah, this one's not needed if registrar_ takes care of this on destruction.  I'll
remove it.

[Charlie Reis, 2012/05/01 21:41:46]

Removed.

+                    content::NotificationService::AllSources());
 }
 
 void RenderViewHostManager::Init(content::BrowserContext* browser_context,
                                  SiteInstance* site_instance,
                                  int routing_id) {
   // Create a RenderViewHost, once we have an instance.  It is important to
   // immediately give this SiteInstance to a RenderViewHost so that it is
   // ref counted.
   if (!site_instance)
     site_instance = SiteInstance::Create(browser_context);
   render_view_host_ = static_cast<RenderViewHostImpl*>(
       RenderViewHostFactory::Create(
-          site_instance, render_view_delegate_, routing_id, delegate_->
+          site_instance, render_view_delegate_, routing_id, false, delegate_->
           GetControllerForRenderManager().GetSessionStorageNamespace()));
 
   // Keep track of renderer processes as they start to shut down.
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  content::NotificationService::AllSources());
 }
 
 RenderViewHostImpl* RenderViewHostManager::current_host() const {
   return render_view_host_;
 }
@@ skipping 16 matching lines @@
   if (!dest_render_view_host)
     return NULL;  // We weren't able to create a pending render view host.
 
   // If the current render_view_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_view_host fetches
   // its first page.  (Bug 1145340)
   if (dest_render_view_host != render_view_host_ &&
       !render_view_host_->IsRenderViewLive()) {
     // 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_view_host_);
+    delegate_->CreateRenderViewForRenderManager(render_view_host_,
+                                                MSG_ROUTING_NONE);
   }
 
   // If the renderer crashed, then try to create a new one to satisfy this
   // navigation request.
   if (!dest_render_view_host->IsRenderViewLive()) {
-    if (!InitRenderView(dest_render_view_host, entry))
+    if (!InitRenderView(dest_render_view_host, MSG_ROUTING_NONE))
       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_view_host != render_view_host_ &&
         dest_render_view_host->GetView()) {
       dest_render_view_host->GetView()->Hide();
     } else {
       // This is our primary renderer, notify here as we won't be calling
@@ skipping 404 matching lines @@
     // a single BrowsingInstance for all pages of a certain type (e.g., New Tab
     // Pages), keeping them in the same process. When you navigate away from
     // that page, we want to explicity ignore that BrowsingInstance and group
     // this page into the appropriate SiteInstance for its URL.
     return SiteInstance::CreateForURL(browser_context, dest_url);
   } else {
     // Start the new renderer in a new SiteInstance, but in the current
     // BrowsingInstance.  It is important to immediately give this new
     // SiteInstance to a RenderViewHost (if it is different than our current
     // SiteInstance), so that it is ref counted.  This will happen in
-    // CreatePendingRenderView.
+    // CreateRenderView.
     return curr_instance->GetRelatedSiteInstance(dest_url);
   }
 }
 
-bool RenderViewHostManager::CreatePendingRenderView(
-  const NavigationEntryImpl& entry, SiteInstance* instance) {
-  NavigationEntry* curr_entry =
-      delegate_->GetControllerForRenderManager().GetLastCommittedEntry();
-  if (curr_entry) {
-    DCHECK(!curr_entry->GetContentState().empty());
-    // TODO(creis): Should send a message to the RenderView to let it know
-    // we're about to switch away, so that it sends an UpdateState message.
-  }
-
+int RenderViewHostManager::CreateRenderView(
+    SiteInstance* instance,
+    int opener_route_id,
+    bool swapped_out) {
   // Check if we've already created an RVH for this SiteInstance.
   CHECK(instance);
-  RenderViewHostMap::iterator iter =
-      swapped_out_hosts_.find(instance->GetId());
+  RenderViewHostImpl* new_render_view_host = NULL;
+  RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());

[Matt Perry, 2012/05/01 21:45:56]

nit: you can use GetSwappedOutRenderViewHost() now.

[Charlie Reis, 2012/05/01 21:57:06]

Good catch.  Fixed.

   if (iter != swapped_out_hosts_.end()) {
     // Re-use the existing RenderViewHost, which has already been initialized.
     // We'll remove it from the list of swapped out hosts if it commits.
-    pending_render_view_host_ = iter->second;
+    new_render_view_host = iter->second;
 
     // Prevent the process from exiting while we're trying to use it.
-    pending_render_view_host_->GetProcess()->AddPendingView();
+    new_render_view_host->GetProcess()->AddPendingView();
+  } else {
+    // Create a new RenderViewHost if we don't find an existing one.
+    new_render_view_host = static_cast<RenderViewHostImpl*>(
+        RenderViewHostFactory::Create(instance,
+            render_view_delegate_, MSG_ROUTING_NONE, swapped_out, delegate_->
+            GetControllerForRenderManager().GetSessionStorageNamespace()));
 
-    return true;
+    // Prevent the process from exiting while we're trying to use it.
+    new_render_view_host->GetProcess()->AddPendingView();
+
+    // Store the new RVH as swapped out if necessary.
+    if (swapped_out)
+      swapped_out_hosts_[instance->GetId()] = new_render_view_host;
+
+    bool success = InitRenderView(new_render_view_host, opener_route_id);
+    if (success) {
+      // Don't show the view until we get a DidNavigate from it.
+      new_render_view_host->GetView()->Hide();
+    } else if (!swapped_out) {
+      CancelPending();
+    }
   }
 
-  pending_render_view_host_ = static_cast<RenderViewHostImpl*>(
-      RenderViewHostFactory::Create(
-          instance, render_view_delegate_, MSG_ROUTING_NONE, delegate_->
-          GetControllerForRenderManager().GetSessionStorageNamespace()));
+  // Use this as our new pending RVH if it isn't swapped out.
+  if (!swapped_out)
+    pending_render_view_host_ = new_render_view_host;
 
-  // Prevent the process from exiting while we're trying to use it.
-  pending_render_view_host_->GetProcess()->AddPendingView();
-
-  bool success = InitRenderView(pending_render_view_host_, entry);
-  if (success) {
-    // Don't show the view until we get a DidNavigate from it.
-    pending_render_view_host_->GetView()->Hide();
-  } else {
-    CancelPending();
-  }
-  return success;
+  return new_render_view_host->GetRoutingID();
 }
 
 bool RenderViewHostManager::InitRenderView(RenderViewHost* render_view_host,
-                                           const NavigationEntryImpl& entry) {
+                                           int opener_route_id) {
   // If the pending navigation is to a WebUI, tell the RenderView about any
   // bindings it will need enabled.
   if (pending_web_ui())
     render_view_host->AllowBindings(pending_web_ui()->GetBindings());
 
-  return delegate_->CreateRenderViewForRenderManager(render_view_host);
+  return delegate_->CreateRenderViewForRenderManager(render_view_host,
+                                                     opener_route_id);
 }
 
 void RenderViewHostManager::CommitPending() {
   // First check whether we're going to want to focus the location bar after
   // this commit.  We do this now because the navigation hasn't formally
   // committed yet, so if we've already cleared |pending_web_ui_| the call chain
   // this triggers won't be able to figure out what's going on.
   bool will_focus_location_bar = delegate_->FocusLocationBarByDefault();
 
   // Next commit the Web UI, if any. Either replace |web_ui_| with
@@ skipping 118 matching lines @@
     // This will possibly create (set to NULL) 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.
     pending_web_ui_.reset(
         delegate_->CreateWebUIForRenderManager(entry.GetURL()));
     pending_and_current_web_ui_.reset();
 
-    // Create a pending RVH and navigate it.
-    bool success = CreatePendingRenderView(entry, new_instance);
-    if (!success)
+    // Ensure that we have created RVHs for the new RVH's opener chain if
+    // we are staying in the same BrowsingInstance. This allows the pending RVH
+    // to send cross-process script calls to its opener(s).
+    int opener_route_id = MSG_ROUTING_NONE;
+    if (new_instance->IsRelatedSiteInstance(curr_instance)) {
+      opener_route_id =
+          delegate_->CreateOpenerRenderViewsForRenderManager(new_instance);
+    }
+
+    // Create a non-swapped-out pending RVH with the given opener and navigate
+    // it.
+    int route_id = CreateRenderView(new_instance, opener_route_id, false);
+    if (route_id == MSG_ROUTING_NONE)
       return NULL;
 
     // Check if our current RVH is live before we set up a transition.
     if (!render_view_host_->IsRenderViewLive()) {
       if (!cross_navigation_pending_) {
         // The current RVH is not live.  There's no reason to sit around with a
         // sad tab or a newly created RVH while we wait for the pending RVH to
         // navigate.  Just switch to the pending RVH now and go back to non
         // cross-navigating (Note that we don't care about on{before}unload
         // handlers if the current RVH isn't live.)
@@ skipping 118 matching lines @@
   }
 }
 
 bool RenderViewHostManager::IsSwappedOut(RenderViewHost* rvh) {
   if (!rvh->GetSiteInstance())
     return false;
 
   return swapped_out_hosts_.find(rvh->GetSiteInstance()->GetId()) !=
       swapped_out_hosts_.end();
 }
+
+RenderViewHost* RenderViewHostManager::GetSwappedOutRenderViewHost(
+    SiteInstance* instance) {
+  RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());
+  if (iter != swapped_out_hosts_.end())
+    return iter->second;
+
+  return NULL;
+}