Support window.opener after a process swap.

content/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2011 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/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 89 matching lines @@
 //   pending cross-site request, and then installs a CrossSiteEventHandler.
 // - When RDH receives a response, the BufferedEventHandler determines whether
 //   it is a download.  If so, it sends a message to the new renderer causing
 //   it to cancel the request, and the download proceeds in the download
 //   thread.  For now, we stay in a PENDING state (with a pending RVH) until
 //   the next DidNavigate event for this TabContents.  This isn't ideal, but it
 //   doesn't affect any functionality.
 // - After RDH receives a response and determines that it is safe and not a
 //   download, it pauses the response to first run the old page's onunload
 //   handler.  It does this by asynchronously calling the OnCrossSiteResponse
-//   method of TabContents on the UI thread, which sends a ClosePage message
+//   method of TabContents on the UI thread, which sends a SwapOut message
 //   to the current RVH.
-// - Once the onunload handler is finished, a ClosePage_ACK message is sent to
+// - Once the onunload handler is finished, a SwapOut_ACK message is sent to
 //   the ResourceDispatcherHost, who unpauses the response.  Data is then sent
 //   to the pending RVH.
 // - The pending renderer sends a FrameNavigate message that invokes the
 //   DidNavigate method.  This replaces the current RVH with the
 //   pending RVH and goes back to the NORMAL RendererState.
+// - The previous renderer is kept swapped out in RenderViewHostManager in case
+//   the user goes back.  The process only stays live if another tab is using
+//   it, but if so, the existing frame relationships will be maintained.
 
 namespace {
 
 // Amount of time we wait between when a key event is received and the renderer
 // is queried for its state and pushed to the NavigationEntry.
 const int kQueryStateDelay = 5000;
 
 const int kSyncWaitDelay = 40;
 
 // The list of prefs we want to observe.
@@ skipping 1565 matching lines @@
 
   // Run post-commit tasks.
   if (details.is_main_frame)
     DidNavigateMainFramePostCommit(details, params);
   DidNavigateAnyFramePostCommit(rvh, details, params);
 }
 
 void TabContents::UpdateState(RenderViewHost* rvh,
                               int32 page_id,
                               const std::string& state) {
-  DCHECK(rvh == render_view_host());
+  // Ensure that this state update comes from either the active RVH or one of
+  // the swapped out RVHs.  We don't expect to hear from any other RVHs.
+  DCHECK(rvh == render_view_host() || render_manager_.IsSwappedOut(rvh));
 
   // We must be prepared to handle state updates for any page, these occur
   // when the user is scrolling and entering form data, as well as when we're
   // leaving a page, in which case our state may have already been moved to
   // the next page. The navigation controller will look up the appropriate
   // NavigationEntry and update it when it is notified via the delegate.
 
   int entry_index = controller_.GetEntryIndexWithPageID(
-      GetSiteInstance(), page_id);
+      rvh->site_instance(), page_id);
   if (entry_index < 0)
     return;
   NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
 
   if (state == entry->content_state())
     return;  // Nothing to update.
   entry->set_content_state(state);
   controller_.NotifyEntryChanged(entry, entry_index);
 }
 
@@ skipping 141 matching lines @@
 }
 
 void TabContents::ProcessExternalHostMessage(const std::string& message,
                                              const std::string& origin,
                                              const std::string& target) {
   if (delegate())
     delegate()->ForwardMessageToExternalHost(message, origin, target);
 }
 
 void TabContents::RunJavaScriptMessage(
+    const RenderViewHost* rvh,
     const std::wstring& message,
     const std::wstring& default_prompt,
     const GURL& frame_url,
     const int flags,
     IPC::Message* reply_msg,
     bool* did_suppress_message) {
   // Suppress javascript messages when requested and when inside a constrained
   // popup window (because that activates them and breaks them out of the
   // constrained window jail).
   // Also suppress messages when showing an interstitial. The interstitial is
   // shown over the previous page, we don't want the hidden page dialogs to
   // interfere with the interstitial.
   bool suppress_this_message =
+      rvh->is_swapped_out() ||
       suppress_javascript_messages_ ||
       showing_interstitial_page() ||
       (delegate() && delegate()->ShouldSuppressDialogs());
   if (delegate())
     suppress_this_message |=
         (delegate()->GetConstrainingContents(this) != this);
 
   *did_suppress_message = suppress_this_message;
 
   if (!suppress_this_message) {
     base::TimeDelta time_since_last_message(
         base::TimeTicks::Now() - last_javascript_message_dismissal_);
     bool show_suppress_checkbox = false;
     // Show a checkbox offering to suppress further messages if this message is
     // being displayed within kJavascriptMessageExpectedDelay of the last one.
     if (time_since_last_message <
         base::TimeDelta::FromMilliseconds(
             chrome::kJavascriptMessageExpectedDelay))
       show_suppress_checkbox = true;
 
     RunJavascriptMessageBox(profile(), this, frame_url, flags, message,
                             default_prompt, show_suppress_checkbox, reply_msg);
   } else {
     // If we are suppressing messages, just reply as is if the user immediately
     // pressed "Cancel".
     OnMessageBoxClosed(reply_msg, false, std::wstring());
   }
 }
 
-void TabContents::RunBeforeUnloadConfirm(const std::wstring& message,
+void TabContents::RunBeforeUnloadConfirm(const RenderViewHost* rvh,
+                                         const std::wstring& message,
                                          IPC::Message* reply_msg) {
   if (delegate())
     delegate()->WillRunBeforeUnloadConfirm();
-  if (delegate() && delegate()->ShouldSuppressDialogs()) {
+  bool suppress_this_message = rvh->is_swapped_out() ||
+      (delegate() && delegate()->ShouldSuppressDialogs());
+  if (suppress_this_message) {
     render_view_host()->JavaScriptMessageBoxClosed(reply_msg, true,
                                                    std::wstring());
     return;
   }
   is_showing_before_unload_dialog_ = true;
   RunBeforeUnloadDialog(this, message, reply_msg);
 }
 
 GURL TabContents::GetAlternateErrorPageURL() const {
   return content::GetContentClient()->browser()->GetAlternateErrorPageURL(this);
@@ skipping 43 matching lines @@
                                       int new_request_id) {
   // Allows the TabContents to react when a cross-site response is ready to be
   // delivered to a pending RenderViewHost.  We must first run the onunload
   // handler of the old RenderViewHost before we can allow it to proceed.
   render_manager_.OnCrossSiteResponse(new_render_process_host_id,
                                       new_request_id);
 }
 
 void TabContents::RendererUnresponsive(RenderViewHost* rvh,
                                        bool is_during_unload) {
+  // Don't show hung renderer dialog for a swapped out RVH.
+  if (rvh != render_view_host())
+    return;
+
   if (is_during_unload) {
     // Hang occurred while firing the beforeunload/unload handler.
     // Pretend the handler fired so tab closing continues as if it had.
     rvh->set_sudden_termination_allowed(true);
 
     if (!render_manager_.ShouldCloseTabOnUnresponsiveRenderer())
       return;
 
     // If the tab hangs in the beforeunload/unload handler there's really
     // nothing we can do to recover. Pretend the unload listeners have
@@ skipping 244 matching lines @@
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }
 
 void TabContents::OnOnlineStateChanged(bool online) {
   render_view_host()->Send(new ViewMsg_NetworkStateChanged(
       render_view_host()->routing_id(), online));
 }