Have the unload event execute in background on cross-site navigations

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/debug/trace_event.h"
@@ skipping 207 matching lines @@
 
   // If the tab becomes unresponsive during {before}unload while doing a
   // cross-site navigation, proceed with the navigation.  (This assumes that
   // the pending RenderViewHost is still responsive.)
   if (render_view_host_->is_waiting_for_unload_ack()) {
     // The request has been started and paused while we're waiting for the
     // unload handler to finish.  We'll pretend that it did.  The pending
     // renderer will then be swapped in as part of the usual DidNavigate logic.
     // (If the unload handler later finishes, this call will be ignored because
     // the pending_nav_params_ state will already be cleaned up.)
-    current_host()->OnSwappedOut(true);
+    current_host()->OnSwappedOut(true, false);
   } else if (render_view_host_->is_waiting_for_beforeunload_ack()) {
     // Haven't gotten around to starting the request, because we're still
     // waiting for the beforeunload handler to finish.  We'll pretend that it
     // did finish, to let the navigation proceed.  Note that there's a danger
     // that the beforeunload handler will later finish and possibly return
     // false (meaning the navigation should not proceed), but we'll ignore it
     // in this case because it took too long.
     if (pending_render_view_host_->are_navigations_suspended())
       pending_render_view_host_->SetNavigationsSuspended(
           false, base::TimeTicks::Now());
   }
   return false;
 }
 
 void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) {
   // Make sure this is from our current RVH, and that we have a pending
   // navigation from OnCrossSiteResponse.  (There may be no pending navigation
   // for data URLs that don't make network requests, for example.)   If not,
-  // just return early and ignore.
+  // it may be coming from an earlier RVH that was left to wait for the
+  // execution of the unload event in the background.
   if (render_view_host != render_view_host_ || !pending_nav_params_.get()) {
+    RenderViewHostImpl* render_view_host_impl =
+        static_cast<RenderViewHostImpl*>(render_view_host);
+    if (!static_cast<SiteInstanceImpl*>(
+             render_view_host_impl->GetSiteInstance())->active_view_count() &&
+        !render_view_host_impl->should_be_preserved_on_swap_out()) {
+      ShutdownRenderViewHostsInSiteInstance(
+          render_view_host_impl->GetSiteInstance()->GetId());
+      // This is deleted while cleaning up the SiteInstance's views.
+      render_view_host_impl = NULL;
+    }
     pending_nav_params_.reset();
     return;
   }
 
   // Now that the unload handler has run, we need to either initiate the
   // pending transfer (if there is one) or resume the paused response (if not).
   // TODO(creis): The blank swapped out page is visible during this time, but
   // we can shorten this by delivering the response directly, rather than
   // forcing an identical request to be made.
   if (pending_nav_params_->is_transfer) {
@@ skipping 10 matching lines @@
         transfer_url,
         pending_nav_params_->transfer_url_chain,
         pending_nav_params_->referrer,
         pending_nav_params_->page_transition,
         CURRENT_TAB,
         pending_nav_params_->frame_id,
         pending_nav_params_->global_request_id,
         pending_nav_params_->should_replace_current_entry,
         true);
   } else if (pending_render_view_host_) {
-    RenderProcessHostImpl* pending_process =
-        static_cast<RenderProcessHostImpl*>(
-            pending_render_view_host_->GetProcess());
-    pending_process->ResumeDeferredNavigation(
+    pending_render_view_host_->GetProcess()->ResumeDeferredNavigation(
         pending_nav_params_->global_request_id);
   }
   pending_nav_params_.reset();
 }
 
 void RenderFrameHostManager::DidNavigateMainFrame(
     RenderViewHost* render_view_host) {
   if (!cross_navigation_pending_) {
     DCHECK(!pending_render_view_host_);
 
@@ skipping 581 matching lines @@
   delegate_->NotifySwappedFromRenderManager(old_render_view_host,
                                             render_view_host_);
 
   // If the pending view was on the swapped out list, we can remove it.
   swapped_out_hosts_.erase(render_view_host_->GetSiteInstance()->GetId());
 
   // If there are no active RVHs in this SiteInstance, it means that
   // this RVH was the last active one in the SiteInstance. Now that we
   // know that all RVHs are swapped out, we can delete all the RVHs in
   // this SiteInstance.
-  if (!static_cast<SiteInstanceImpl*>(old_render_view_host->GetSiteInstance())->
-          active_view_count()) {
+  if (!static_cast<SiteInstanceImpl*>(old_render_view_host->GetSiteInstance())
+           ->active_view_count() &&

[Charlie Reis, 2013/12/09 20:12:29]

nit: Please keep the arrow at the end of the line, to be consistent with other
files in frame_host/.

+      !old_render_view_host->should_be_preserved_on_swap_out()) {

[Charlie Reis, 2013/12/09 20:12:29]

I'd like to avoid adding this here if possible.

     ShutdownRenderViewHostsInSiteInstance(
         old_render_view_host->GetSiteInstance()->GetId());
-    // This is deleted while cleaning up the SitaInstance's views.
+    // This is deleted while cleaning up the SiteInstance's views.
     old_render_view_host = NULL;
-  } else if (old_render_view_host->IsRenderViewLive()) {
+  } else if (old_render_view_host->IsRenderViewLive() ||
+             old_render_view_host->should_be_preserved_on_swap_out()) {
     // If the old RVH is live, we are swapping it out and should keep track of
     // it in case we navigate back to it.
     DCHECK(old_render_view_host->is_swapped_out());
     // Temp fix for http://crbug.com/90867 until we do a better cleanup to make
     // sure we don't get different rvh instances for the same site instance
     // in the same rvhmgr.
     // TODO(creis): Clean this up.
     int32 old_site_instance_id =
         old_render_view_host->GetSiteInstance()->GetId();
     RenderViewHostMap::iterator iter =
@@ skipping 16 matching lines @@
   // list.
   swapped_out_hosts_.erase(site_instance_id);
 
   scoped_ptr<RenderWidgetHostIterator> widgets(
       RenderWidgetHostImpl::GetAllRenderWidgetHosts());
   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
     if (!widget->IsRenderView())
       continue;
     RenderViewHostImpl* rvh =
         static_cast<RenderViewHostImpl*>(RenderViewHost::From(widget));
-    if (site_instance_id == rvh->GetSiteInstance()->GetId())
+    if (site_instance_id == rvh->GetSiteInstance()->GetId()) {
+      // If the RVH was waiting for the unload event to execute in the
+      // background, it may not have completely cleaned up its state yet.
+      if (rvh->need_to_perform_clean_up_on_swapped_out()) {
+        rvh->WasSwappedOut();
+      }
       rvh->Shutdown();
+    }
   }
 }
 
 RenderViewHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     const NavigationEntryImpl& entry) {
   // If we are currently navigating cross-process, we want to get back to normal
   // and then navigate as usual.
   if (cross_navigation_pending_) {
     if (pending_render_view_host_)
       CancelPending();
@@ skipping 214 matching lines @@
 RenderViewHostImpl* RenderFrameHostManager::GetSwappedOutRenderViewHost(
     SiteInstance* instance) {
   RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end())
     return iter->second;
 
   return NULL;
 }
 
 }  // namespace content