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 463 matching lines @@
       webkit_preferences_(webkit_prefs),
       send_content_state_immediately_(false),
       enabled_bindings_(0),
       send_preferred_size_changes_(false),
       script_can_close_(true),
       is_loading_(false),
       navigation_gesture_(NavigationGestureUnknown),
       opened_by_user_gesture_(true),
       opener_suppressed_(false),
       is_prerendering_(false),
+      is_swapped_out_(false),
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
       last_indexed_page_id_(-1),
       history_list_offset_(-1),
       history_list_length_(0),
       has_unload_listener_(false),
       target_url_status_(TARGET_NONE),
       view_type_(ViewType::INVALID),
       browser_window_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)),
@@ skipping 162 matching lines @@
 
 void RenderView::AddObserver(RenderViewObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RenderView::RemoveObserver(RenderViewObserver* observer) {
   observer->set_render_view(NULL);
   observers_.RemoveObserver(observer);
 }
 
+void RenderView::SwapIn() {
+  DCHECK(is_swapped_out_);
+  is_swapped_out_ = false;
+
+  // Increment the ChildProcess's ref count now that this RenderView is active
+  // again.  This prevents the process from exiting.
+  RenderProcess::current()->AddRefProcess();
+}
+
 bool RenderView::RendererAccessibilityNotification::ShouldIncludeChildren() {
   typedef ViewHostMsg_AccessibilityNotification_Params params;
   if (type == WebKit::WebAccessibilityNotificationChildrenChanged ||
       type == WebKit::WebAccessibilityNotificationLoadComplete) {
     return true;
   }
   return false;
 }
 
 WebKit::WebView* RenderView::webview() const {
@@ skipping 262 matching lines @@
                         OnDisplayPrerenderedPage)
     IPC_MESSAGE_HANDLER(ViewMsg_RunFileChooserResponse, OnFileChooserResponse)
     IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode, OnEnableViewSourceMode)
     IPC_MESSAGE_HANDLER(ViewMsg_GetAllSavableResourceLinksForCurrentPage,
                         OnGetAllSavableResourceLinksForCurrentPage)
     IPC_MESSAGE_HANDLER(
         ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks,
         OnGetSerializedHtmlDataForCurrentPageWithLocalLinks)
     IPC_MESSAGE_HANDLER(ExtensionMsg_GetApplicationInfo, OnGetApplicationInfo)
     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_HandleMessageFromExternalHost,
                         OnHandleMessageFromExternalHost)
     IPC_MESSAGE_HANDLER(ViewMsg_DisassociateFromPopupCount,
                         OnDisassociateFromPopupCount)
     IPC_MESSAGE_HANDLER(ViewMsg_AllowScriptToClose,
                         OnAllowScriptToClose)
     IPC_MESSAGE_HANDLER(ViewMsg_MoveOrResizeStarted, OnMoveOrResizeStarted)
     IPC_MESSAGE_HANDLER(ViewMsg_ClearFocusedNode, OnClearFocusedNode)
@@ skipping 268 matching lines @@
 
   HISTOGRAM_TIMES("Renderer4.Snapshot",
                   base::TimeTicks::Now() - beginning_time);
   return true;
 }
 
 void RenderView::OnNavigate(const ViewMsg_Navigate_Params& params) {
   if (!webview())
     return;
 
+  // Swap this renderer back in if necessary.
+  if (is_swapped_out_) {
+    SwapIn();
+  }
+
   history_list_offset_ = params.current_history_list_offset;
   history_list_length_ = params.current_history_list_length;
 
   child_process_logging::SetActiveURL(params.url);
 
   AboutHandler::MaybeHandle(params.url);
 
   bool is_reload =
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
@@ skipping 234 matching lines @@
 
 // Tell the embedding application that the URL of the active page has changed
 void RenderView::UpdateURL(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
   const WebURLRequest& original_request = ds->originalRequest();
   const WebURLResponse& response = ds->response();
 
+  // Don't send an update if this renderer is swapped out.
+  // TODO(creis): This won't be necessary once OnSwapOut is fixed to clear
+  // the frame without a full navigation.
+  if (is_swapped_out_) {
+    DCHECK(request.url() == GURL(chrome::kAboutBlankURL));
+    return;
+  }
+
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
 
   ViewHostMsg_FrameNavigate_Params params;
   params.http_status_code = response.httpStatusCode();
   params.is_post = false;
   params.page_id = page_id_;
   params.frame_id = frame->identifier();
   params.socket_address.set_host(response.remoteIPAddress().utf8());
   params.socket_address.set_port(response.remotePort());
@@ skipping 669 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 2231 matching lines @@
     frame_url,
     data.data(),
     static_cast<int32>(status)));
 }
 
 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) {
+  // Swap this RenderView out so the tab can navigate to a page rendered by a
+  // different process.  This involves running the unload handler, clearing
+  // the page, and allowing the process to exit if there are no other active
+  // RenderViews in it.
+  DCHECK(!is_swapped_out_);
+  is_swapped_out_ = true;
+
+  // TODO(davemoore) This code should be removed once willClose() gets
+  // called when a page is destroyed. page_load_histograms_.Dump() is safe
+  // to call multiple times for the same frame, but it will simplify things.
+  page_load_histograms_.Dump(webview()->mainFrame());
+  page_load_histograms_.ResetCrossFramePropertyAccess();
+
+  // Send an UpdateState message before we get swapped out.
+  SyncNavigationState();
+
+  // Replace the page with a blank dummy URL, triggering the unload handler.
+  // TODO(creis): Need to add a better way to do this that avoids running the
+  // beforeunload handler and that can't match an existing URL.
+  WebURLRequest request(GURL(chrome::kAboutBlankURL));
+  webview()->mainFrame()->loadRequest(request);

[Charlie Reis, 2011/04/13 22:57:21]

This is the main sticking point right now.  We need a way of clearing the
contents of the frame as if a new navigation had taken place, running unload but
not beforeunload.  I'm simulating that by loading about:blank and intercepting
the beforeunload, but it's far from perfect, and trips up if you try to go back
from an actual about:blank page.

I'm guessing we'll have to add something to WebKit.

+
+  // Just echo back the params in the ACK.
+  Send(new ViewHostMsg_SwapOut_ACK(routing_id_, params));
+
+  // Remove this RenderView from the ChildProcess's ref count, allowing the
+  // process to exit if all of the RenderViews are swapped out.  We will
+  // increment the count if this RenderView is swapped back in.
+  RenderProcess::current()->ReleaseProcess();
+}
+
+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.
   // TODO(davemoore) This code should be removed once willClose() gets
   // called when a page is destroyed. page_load_histograms_.Dump() is safe
   // to call multiple times for the same frame, but it will simplify things.
   page_load_histograms_.Dump(webview()->mainFrame());
   page_load_histograms_.ResetCrossFramePropertyAccess();
   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 603 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);
 }