Support window.opener after a process swap.

content/renderer/render_view.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/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 614 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_ScrollFocusedEditableNodeIntoView,
                         OnScrollFocusedEditableNodeIntoView)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateTargetURL_ACK, OnUpdateTargetURLAck)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateWebPreferences, OnUpdateWebPreferences)
     IPC_MESSAGE_HANDLER(ViewMsg_SetAltErrorPageURL, OnSetAltErrorPageURL)
     IPC_MESSAGE_HANDLER(ViewMsg_InstallMissingPlugin, OnInstallMissingPlugin)
     IPC_MESSAGE_HANDLER(ViewMsg_EnumerateDirectoryResponse,
                         OnEnumerateDirectoryResponse)
     IPC_MESSAGE_HANDLER(ViewMsg_RunFileChooserResponse, OnFileChooserResponse)
     IPC_MESSAGE_HANDLER(ViewMsg_ShouldClose, OnShouldClose)
+    IPC_MESSAGE_HANDLER(ViewMsg_SwapOut, OnSwapOut)
     IPC_MESSAGE_HANDLER(ViewMsg_ClosePage, OnClosePage)
     IPC_MESSAGE_HANDLER(ViewMsg_ThemeChanged, OnThemeChanged)
     IPC_MESSAGE_HANDLER(ViewMsg_DisassociateFromPopupCount,
                         OnDisassociateFromPopupCount)
     IPC_MESSAGE_HANDLER(ViewMsg_MoveOrResizeStarted, OnMoveOrResizeStarted)
     IPC_MESSAGE_HANDLER(ViewMsg_ClearFocusedNode, OnClearFocusedNode)
     IPC_MESSAGE_HANDLER(ViewMsg_SetBackground, OnSetBackground)
     IPC_MESSAGE_HANDLER(ViewMsg_EnablePreferredSizeChangedMode,
                         OnEnablePreferredSizeChangedMode)
     IPC_MESSAGE_HANDLER(ViewMsg_DisableScrollbarsForSmallWindows,
@@ skipping 33 matching lines @@
     // Have the super handle all other messages.
     IPC_MESSAGE_UNHANDLED(handled = RenderWidget::OnMessageReceived(message))
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RenderView::OnNavigate(const ViewMsg_Navigate_Params& params) {
   if (!webview())
     return;
 
+  // Swap this renderer back in if necessary.
+  if (is_swapped_out_) {
+    SetSwappedOut(false);
+  }
+
   history_list_offset_ = params.current_history_list_offset;
   history_list_length_ = params.current_history_list_length;
 
   content::GetContentClient()->SetActiveURL(params.url);
 
   bool is_reload =
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
 
   WebFrame* main_frame = webview()->mainFrame();
@@ skipping 779 matching lines @@
         pending_accessibility_notifications_[i].type, &param.notification_type);
     param.acc_obj = WebAccessibility(
         obj, accessibility_.get(), notification.ShouldIncludeChildren());
     notifications.push_back(param);
   }
   pending_accessibility_notifications_.clear();
   Send(new ViewHostMsg_AccessibilityNotifications(routing_id_, notifications));
   accessibility_ack_pending_ = true;
 }
 
+bool RenderView::CanSendWhileSwappedOut(IPC::Message* message) {
+  // We filter out most IPC messages when swapped out.  However, some are
+  // important (e.g., ACKs) for keeping the browser and renderer state
+  // consistent in case we later return to this renderer.
+  switch (message->type()) {
+    // RenderView
+    case ViewHostMsg_RenderViewGone::ID:
+    case ViewHostMsg_ShouldClose_ACK::ID:
+    case ViewHostMsg_SwapOut_ACK::ID:
+    case ViewHostMsg_ClosePage_ACK::ID:
+      return true;
+    default:
+      break;
+  }
+
+  // Check with our observers, in case they need to let messages through.
+  ObserverListBase<RenderViewObserver>::Iterator it(observers_);
+  RenderViewObserver* observer;
+  while ((observer = it.GetNext()) != NULL)
+    if (observer->CanSendWhileSwappedOut(message))
+      return true;
+
+  return RenderWidget::CanSendWhileSwappedOut(message);
+}
+
 bool RenderView::handleCurrentKeyboardEvent() {
   if (edit_commands_.empty())
     return false;
 
   WebFrame* frame = webview()->focusedFrame();
   if (!frame)
     return false;
 
   EditCommands::iterator it = edit_commands_.begin();
   EditCommands::iterator end = edit_commands_.end();
@@ skipping 60 matching lines @@
                                  UTF16ToWideHack(default_value),
                                  frame->url(),
                                  &result);
   if (ok)
     actual_value->assign(WideToUTF16Hack(result));
   return ok;
 }
 
 bool RenderView::runModalBeforeUnloadDialog(
     WebFrame* frame, const WebString& message) {
+  // If we are swapping out, we have already run the beforeunload handler.
+  // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
+  // at all, to avoid running it twice.
+  if (is_swapped_out_)
+    return true;
+
   bool success = false;
   // This is an ignored return value, but is included so we can accept the same
   // response as RunJavaScriptMessage.
   std::wstring ignored_result;
   SendAndRunNestedMessageLoop(new ViewHostMsg_RunBeforeUnloadConfirm(
       routing_id_, frame->url(), UTF16ToWideHack(message), &success,
       &ignored_result));
   return success;
 }
 
@@ skipping 342 matching lines @@
   if (policy == WebKit::WebNavigationPolicyDownload) {
     Send(new ViewHostMsg_DownloadUrl(routing_id_, request.url(), referrer));
   } else {
     OpenURL(request.url(), referrer, policy);
   }
 }
 
 WebNavigationPolicy RenderView::decidePolicyForNavigation(
     WebFrame* frame, const WebURLRequest& request, WebNavigationType type,
     const WebNode&, WebNavigationPolicy default_policy, bool is_redirect) {
+  // TODO(creis): Remove this when we fix OnSwapOut to not need a navigation.
+  if (is_swapped_out_) {
+    DCHECK(request.url() == GURL("about:swappedout"));
+    return default_policy;
+  }
+
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = request.url();
 
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
   bool is_content_initiated =
       NavigationState::FromDataSource(frame->provisionalDataSource())->
           is_content_initiated();
@@ skipping 1564 matching lines @@
   DCHECK(accessibility_ack_pending_);
   accessibility_ack_pending_ = false;
   SendPendingAccessibilityNotifications();
 }
 
 void RenderView::OnShouldClose() {
   bool should_close = webview()->dispatchBeforeUnloadEvent();
   Send(new ViewHostMsg_ShouldClose_ACK(routing_id_, should_close));
 }
 
-void RenderView::OnClosePage(const ViewMsg_ClosePage_Params& params) {
+void RenderView::OnSwapOut(const ViewMsg_SwapOut_Params& params) {
+  if (is_swapped_out_)
+    return;
+
+  // Swap this RenderView out so the tab can navigate to a page rendered by a
+  // different process.  This involves running the unload handler and clearing
+  // the page.  Once WasSwappedOut is called, we also allow this process to exit
+  // if there are no other active RenderViews in it.
+
+  // Send an UpdateState message before we get swapped out.
+  SyncNavigationState();
+
+  // Synchronously run the unload handler before sending the ACK.
+  webview()->dispatchUnloadEvent();
+
+  // Swap out and stop sending any IPC messages that are not ACKs.
+  SetSwappedOut(true);
+
+  // Replace the page with a blank dummy URL.  The unload handler will not be
+  // run a second time, thanks to a check in FrameLoader::stopLoading.
+  // TODO(creis): Need to add a better way to do this that avoids running the
+  // beforeunload handler.  For now, we just run it a second time silently.
+  webview()->mainFrame()->loadHTMLString(std::string(),
+                                         GURL("about:swappedout"),
+                                         GURL("about:swappedout"),
+                                         false);
+
+  // Just echo back the params in the ACK.
+  Send(new ViewHostMsg_SwapOut_ACK(routing_id_, params));
+}
+
+void RenderView::OnClosePage() {
   // TODO(creis): We'd rather use webview()->Close() here, but that currently
   // sets the WebView's delegate_ to NULL, preventing any JavaScript dialogs
   // in the onunload handler from appearing.  For now, we're bypassing that and
   // calling the FrameLoader's CloseURL method directly.  This should be
   // revisited to avoid having two ways to close a page.  Having a single way
   // to close that can run onunload is also useful for fixing
   // http://b/issue?id=753080.
   webview()->dispatchUnloadEvent();
 
-  // Just echo back the params in the ACK.
-  Send(new ViewHostMsg_ClosePage_ACK(routing_id_, params));
+  Send(new ViewHostMsg_ClosePage_ACK(routing_id_));
 }
 
 void RenderView::OnThemeChanged() {
 #if defined(OS_WIN)
   gfx::NativeThemeWin::instance()->CloseHandles();
   if (webview())
     webview()->themeChanged();
 #else  // defined(OS_WIN)
   // TODO(port): we don't support theming on non-Windows platforms yet
   NOTIMPLEMENTED();
@@ skipping 568 matching lines @@
     const webkit_glue::CustomContextMenuContext& custom_context) {
   if (custom_context.is_pepper_menu)
     pepper_delegate_.OnContextMenuClosed(custom_context);
   else
     context_menu_node_.reset();
 }
 
 void RenderView::OnNetworkStateChanged(bool online) {
   WebNetworkStateNotifier::setOnLine(online);
 }