Support window.opener after a process swap.

content/browser/renderer_host/render_view_host.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/renderer_host/render_view_host.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 79 matching lines @@
 
 RenderViewHost::RenderViewHost(SiteInstance* instance,
                                RenderViewHostDelegate* delegate,
                                int routing_id,
                                SessionStorageNamespace* session_storage)
     : RenderWidgetHost(instance->GetProcess(), routing_id),
       instance_(instance),
       delegate_(delegate),
       waiting_for_drag_context_response_(false),
       enabled_bindings_(0),
-      pending_request_id_(0),
+      pending_request_id_(-1),
       navigations_suspended_(false),
       suspended_nav_message_(NULL),
+      is_swapped_out_(false),
       run_modal_reply_msg_(NULL),
       is_waiting_for_beforeunload_ack_(false),
       is_waiting_for_unload_ack_(false),
       unload_ack_is_for_cross_site_transition_(false),
       are_javascript_messages_suppressed_(false),
       sudden_termination_allowed_(false),
       session_storage_namespace_(session_storage),
       is_extension_process_(false),
       save_accessibility_tree_for_testing_(false),
       render_view_termination_status_(base::TERMINATION_STATUS_STILL_RUNNING) {
@@ skipping 143 matching lines @@
   Navigate(params);
 }
 
 void RenderViewHost::SetNavigationsSuspended(bool suspend) {
   // This should only be called to toggle the state.
   DCHECK(navigations_suspended_ != suspend);
 
   navigations_suspended_ = suspend;
   if (!suspend && suspended_nav_message_.get()) {
     // There's a navigation message waiting to be sent.  Now that we're not
-    // suspended anymore, resume navigation by sending it.
+    // suspended anymore, resume navigation by sending it.  If we were swapped
+    // out, we should also stop filtering out the IPC messages now.
+    is_swapped_out_ = false;
     Send(suspended_nav_message_.release());
   }
 }
 
+void RenderViewHost::CancelSuspendedNavigations() {
+  // Clear any state if a pending navigation is canceled or pre-empted.
+  if (suspended_nav_message_.get())
+    suspended_nav_message_.reset();
+  navigations_suspended_ = false;
+}
+
 void RenderViewHost::FirePageBeforeUnload(bool for_cross_site_transition) {
   if (!IsRenderViewLive()) {
     // This RenderViewHost doesn't have a live renderer, so just skip running
     // the onbeforeunload handler.
     is_waiting_for_beforeunload_ack_ = true;  // Checked by OnMsgShouldCloseACK.
     unload_ack_is_for_cross_site_transition_ = for_cross_site_transition;
     OnMsgShouldCloseACK(true);
     return;
   }
 
@@ skipping 12 matching lines @@
   } else {
     // Start the hang monitor in case the renderer hangs in the beforeunload
     // handler.
     is_waiting_for_beforeunload_ack_ = true;
     unload_ack_is_for_cross_site_transition_ = for_cross_site_transition;
     StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
     Send(new ViewMsg_ShouldClose(routing_id()));
   }
 }
 
-void RenderViewHost::ClosePage(bool for_cross_site_transition,
-                               int new_render_process_host_id,
-                               int new_request_id) {
-  // This will be set back to false in OnClosePageACK, just before we close the
-  // tab or replace it with a pending RVH.  There are some cases (such as 204
-  // errors) where we'll continue to show this RVH.
+void RenderViewHost::SwapOut(int new_render_process_host_id,
+                             int new_request_id) {
+  // Start filtering IPC messages to avoid confusing the delegate.  This will
+  // prevent any dialogs from appearing during unload handlers, but we've
+  // already decided to silence them in crbug.com/68780.  We will set it back
+  // to false in SetNavigationsSuspended if we swap back in.
+  is_swapped_out_ = true;
+
+  // This will be set back to false in OnSwapOutACK, just before we replace
+  // this RVH with the pending RVH.
   is_waiting_for_unload_ack_ = true;
   // Start the hang monitor in case the renderer hangs in the unload handler.
   StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
 
-  ViewMsg_ClosePage_Params params;
+  ViewMsg_SwapOut_Params params;
   params.closing_process_id = process()->id();
   params.closing_route_id = routing_id();
-  params.for_cross_site_transition = for_cross_site_transition;
   params.new_render_process_host_id = new_render_process_host_id;
   params.new_request_id = new_request_id;
   if (IsRenderViewLive()) {
+    Send(new ViewMsg_SwapOut(routing_id(), params));
+  } else {
+    // This RenderViewHost doesn't have a live renderer, so just skip the unload
+    // event.  We must notify the ResourceDispatcherHost on the IO thread,
+    // which we will do through the RenderProcessHost's widget helper.
+    process()->CrossSiteSwapOutACK(params);
+  }
+}
+
+void RenderViewHost::OnSwapOutACK() {
+  // Stop the hang monitor now that the unload handler has finished.
+  StopHangMonitorTimeout();
+  is_waiting_for_unload_ack_ = false;
+}
+
+void RenderViewHost::ClosePage() {
+  // Start the hang monitor in case the renderer hangs in the unload handler.
+  is_waiting_for_unload_ack_ = true;
+  StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
+
+  if (IsRenderViewLive()) {
+    // TODO(creis): Should this be moved to Shutdown?  It may not be called for
+    // RenderViewHosts that have been swapped out.
     NotificationService::current()->Notify(
         NotificationType::RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW,
         Source<RenderViewHost>(this),
         NotificationService::NoDetails());
 
-    Send(new ViewMsg_ClosePage(routing_id(), params));
+    Send(new ViewMsg_ClosePage(routing_id()));
   } else {
-    // This RenderViewHost doesn't have a live renderer, so just skip closing
-    // the page.  We must notify the ResourceDispatcherHost on the IO thread,
-    // which we will do through the RenderProcessHost's widget helper.
-    process()->CrossSiteClosePageACK(params);
-  }
-}
-
-void RenderViewHost::OnClosePageACK(bool for_cross_site_transition) {
-  StopHangMonitorTimeout();
-  is_waiting_for_unload_ack_ = false;
-
-  // If this ClosePageACK is not for a cross-site transition, then it is for an
-  // attempt to close the tab.  We have now finished the unload handler and can
-  // proceed with closing the tab.
-  if (!for_cross_site_transition) {
+    // This RenderViewHost doesn't have a live renderer, so just skip the unload
+    // event and close the page.
     ClosePageIgnoringUnloadEvents();
   }
 }
 
 void RenderViewHost::ClosePageIgnoringUnloadEvents() {
   StopHangMonitorTimeout();
   is_waiting_for_beforeunload_ack_ = false;
   is_waiting_for_unload_ack_ = false;
 
   sudden_termination_allowed_ = true;
@@ skipping 394 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateTargetURL, OnMsgUpdateTargetURL)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Snapshot, OnMsgScreenshot)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateInspectorSetting,
                         OnUpdateInspectorSetting)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Close, OnMsgClose)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestMove, OnMsgRequestMove)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidStartLoading, OnMsgDidStartLoading)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidStopLoading, OnMsgDidStopLoading)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidChangeLoadProgress,
                         OnMsgDidChangeLoadProgress)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidStartProvisionalLoadForFrame,
+                        OnMsgDidStartProvisionalLoadForFrame)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidRedirectProvisionalLoad,
+                        OnMsgDidRedirectProvisionalLoad)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidFailProvisionalLoadWithError,
+                        OnMsgDidFailProvisionalLoadWithError)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidLoadResourceFromMemoryCache,
+                        OnMsgDidLoadResourceFromMemoryCache)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidDisplayInsecureContent,
+                        OnMsgDidDisplayInsecureContent)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidRunInsecureContent,
+                        OnMsgDidRunInsecureContent)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentLoadedInFrame,
+                        OnMsgDocumentLoadedInFrame)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidFinishLoad, OnMsgDidFinishLoad)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateContentRestrictions,
+                        OnMsgUpdateContentRestrictions)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentAvailableInMainFrame,
                         OnMsgDocumentAvailableInMainFrame)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentOnLoadCompletedInMainFrame,
                         OnMsgDocumentOnLoadCompletedInMainFrame)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ContextMenu, OnMsgContextMenu)
     IPC_MESSAGE_HANDLER(ViewHostMsg_OpenURL, OnMsgOpenURL)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidContentsPreferredSizeChange,
                         OnMsgDidContentsPreferredSizeChange)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DomOperationResponse,
                         OnMsgDomOperationResponse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_WebUISend, OnMsgWebUISend)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardMessageToExternalHost,
                         OnMsgForwardMessageToExternalHost)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetTooltipText, OnMsgSetTooltipText)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_RunJavaScriptMessage,
                                     OnMsgRunJavaScriptMessage)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_RunBeforeUnloadConfirm,
                                     OnMsgRunBeforeUnloadConfirm)
     IPC_MESSAGE_HANDLER(DragHostMsg_StartDragging, OnMsgStartDragging)
     IPC_MESSAGE_HANDLER(DragHostMsg_UpdateDragCursor, OnUpdateDragCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_TakeFocus, OnTakeFocus)
     IPC_MESSAGE_HANDLER(ViewHostMsg_AddMessageToConsole, OnAddMessageToConsole)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ShouldClose_ACK, OnMsgShouldCloseACK)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_ClosePage_ACK, OnMsgClosePageACK)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectionChanged, OnMsgSelectionChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_AccessibilityNotifications,
                         OnAccessibilityNotifications)
     IPC_MESSAGE_HANDLER(ViewHostMsg_OnCSSInserted, OnCSSInserted)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ContentBlocked, OnContentBlocked)
     IPC_MESSAGE_HANDLER(ViewHostMsg_AppCacheAccessed, OnAppCacheAccessed)
     IPC_MESSAGE_HANDLER(ViewHostMsg_WebDatabaseAccessed, OnWebDatabaseAccessed)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FocusedNodeChanged, OnMsgFocusedNodeChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateZoomLimits, OnUpdateZoomLimits)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ScriptEvalResponse, OnScriptEvalResponse)
@@ skipping 36 matching lines @@
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (!view)
     return;
 
   view->CreateNewWindow(route_id, params);
 }
 
 void RenderViewHost::CreateNewWidget(int route_id,
                                      WebKit::WebPopupType popup_type) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)

[Matt Perry, 2011/04/28 22:48:20]

rather than adding these checks in every message handler (which will be hard to
maintain as new messages are introduced), what about this:
- add a CanProcessMessageWhileSwappedOut method that has a whitelist of all the
allowed messages
- in RenderViewHost::OnMessageReceived, check if the RVH is swapped out. if so,
pass the message to the above method, and stop processing if it says no.
- revert the changes to the RVHD and tab_contents for processing these messages
specially.

The ordering of the check is important. I think you'll want to do the
swapped_out check before calling the RVH's delegates or observers.

[Charlie Reis, 2011/04/29 17:53:53]

That's a great idea-- thanks.  Now there's only a couple places (where we want
the ACKs to be sent) that we have to filter like this.

New patch uploaded.

     view->CreateNewWidget(route_id, popup_type);
 }
 
 void RenderViewHost::CreateNewFullscreenWidget(int route_id) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
     view->CreateNewFullscreenWidget(route_id);
 }
 
 void RenderViewHost::OnMsgShowView(int route_id,
                                    WindowOpenDisposition disposition,
                                    const gfx::Rect& initial_pos,
                                    bool user_gesture) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view) {
-    view->ShowCreatedWindow(route_id, disposition, initial_pos, user_gesture);
+    if (!is_swapped_out_)
+      view->ShowCreatedWindow(route_id, disposition, initial_pos, user_gesture);
     Send(new ViewMsg_Move_ACK(route_id));
   }
 }
 
 void RenderViewHost::OnMsgShowWidget(int route_id,
                                      const gfx::Rect& initial_pos) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view) {
-    view->ShowCreatedWidget(route_id, initial_pos);
+    if (!is_swapped_out_)
+      view->ShowCreatedWidget(route_id, initial_pos);
     Send(new ViewMsg_Move_ACK(route_id));
   }
 }
 
 void RenderViewHost::OnMsgShowFullscreenWidget(int route_id) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view) {
-    view->ShowCreatedFullscreenWidget(route_id);
+    if (!is_swapped_out_)
+      view->ShowCreatedFullscreenWidget(route_id);
     Send(new ViewMsg_Move_ACK(route_id));
   }
 }
 
 void RenderViewHost::OnMsgRunModal(IPC::Message* reply_msg) {
   DCHECK(!run_modal_reply_msg_);
   run_modal_reply_msg_ = reply_msg;
 
   // TODO(darin): Bug 1107929: Need to inform our delegate to show this view in
   // an app-modal fashion.
@@ skipping 58 matching lines @@
   }
 
   // If we're waiting for an unload ack from this renderer and we receive a
   // Navigate message, then the renderer was navigating before it received the
   // unload request.  It will either respond to the unload request soon or our
   // timer will expire.  Either way, we should ignore this message, because we
   // have already committed to closing this renderer.
   if (is_waiting_for_unload_ack_)
     return;
 
+  // If this RVH has been swapped out, ignore the navigation.
+  if (is_swapped_out_)
+    return;
+
   const int renderer_id = process()->id();
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
   // Without this check, an evil renderer can trick the browser into creating
   // a navigation entry for a banned URL.  If the user clicks the back button
   // followed by the forward button (or clicks reload, or round-trips through
   // session restore, etc), we'll think that the browser commanded the
   // renderer to load the URL and grant the renderer the privileges to request
   // the URL.  To prevent this attack, we block the renderer from inserting
   // banned URLs into the navigation controller in the first place.
   FilterURL(policy, renderer_id, &validated_params.url);
   FilterURL(policy, renderer_id, &validated_params.referrer);
   for (std::vector<GURL>::iterator it(validated_params.redirects.begin());
       it != validated_params.redirects.end(); ++it) {
     FilterURL(policy, renderer_id, &(*it));
   }
   FilterURL(policy, renderer_id, &validated_params.searchable_form_url);
   FilterURL(policy, renderer_id, &validated_params.password_form.origin);
   FilterURL(policy, renderer_id, &validated_params.password_form.action);
 
   delegate_->DidNavigate(this, validated_params);
 }
 
 void RenderViewHost::OnMsgUpdateState(int32 page_id,
                                       const std::string& state) {
+  // We allow UpdateState messages even from swapped out renderers.
   delegate_->UpdateState(this, page_id, state);
 }
 
 void RenderViewHost::OnMsgUpdateTitle(int32 page_id,
                                       const std::wstring& title) {
+  if (is_swapped_out_)
+    return;
+
   if (title.length() > content::kMaxTitleChars) {
     NOTREACHED() << "Renderer sent too many characters in title.";
     return;
   }
   delegate_->UpdateTitle(this, page_id, title);
 }
 
 void RenderViewHost::OnMsgUpdateEncoding(const std::string& encoding_name) {
-  delegate_->UpdateEncoding(this, encoding_name);
+  if (!is_swapped_out_)
+    delegate_->UpdateEncoding(this, encoding_name);
 }
 
 void RenderViewHost::OnMsgUpdateTargetURL(int32 page_id,
                                           const GURL& url) {
-  delegate_->UpdateTargetURL(page_id, url);
+  if (!is_swapped_out_)
+    delegate_->UpdateTargetURL(page_id, url);
 
   // Send a notification back to the renderer that we are ready to
   // receive more target urls.
   Send(new ViewMsg_UpdateTargetURL_ACK(routing_id()));
 }
 
 void RenderViewHost::OnMsgScreenshot(const SkBitmap& bitmap) {
   NotificationService::current()->Notify(
       NotificationType::TAB_SNAPSHOT_TAKEN,
       Source<RenderViewHost>(this),
       Details<const SkBitmap>(&bitmap));
 }
 
 void RenderViewHost::OnUpdateInspectorSetting(
     const std::string& key, const std::string& value) {
-  delegate_->UpdateInspectorSetting(key, value);
+  if (!is_swapped_out_)
+    delegate_->UpdateInspectorSetting(key, value);
 }
 
 void RenderViewHost::OnMsgClose() {
   // If the renderer is telling us to close, it has already run the unload
-  // events, and we can take the fast path.
+  // events, and we can take the fast path.  We allow this even from swapped
+  // out renderers.
   ClosePageIgnoringUnloadEvents();
 }
 
 void RenderViewHost::OnMsgRequestMove(const gfx::Rect& pos) {
-  delegate_->RequestMove(pos);
+  if (!is_swapped_out_)
+    delegate_->RequestMove(pos);
   Send(new ViewMsg_Move_ACK(routing_id()));
 }
 
 void RenderViewHost::OnMsgDidStartLoading() {
-  delegate_->DidStartLoading();
+  if (!is_swapped_out_)
+    delegate_->DidStartLoading();
 }
 
 void RenderViewHost::OnMsgDidStopLoading() {
-  delegate_->DidStopLoading();
+  if (!is_swapped_out_)
+    delegate_->DidStopLoading();
 }
 
 void RenderViewHost::OnMsgDidChangeLoadProgress(double load_progress) {
-  delegate_->DidChangeLoadProgress(load_progress);
+  if (!is_swapped_out_)
+    delegate_->DidChangeLoadProgress(load_progress);
+}
+
+void RenderViewHost::OnMsgDidStartProvisionalLoadForFrame(int64 frame_id,
+                                                          bool is_main_frame,
+                                                          const GURL& url) {
+  if (!is_swapped_out_)
+    delegate_->DidStartProvisionalLoadForFrame(frame_id, is_main_frame, url);
+}
+
+void RenderViewHost::OnMsgDidRedirectProvisionalLoad(int32 page_id,
+                                                     const GURL& source_url,
+                                                     const GURL& target_url) {
+  if (!is_swapped_out_)
+    delegate_->DidRedirectProvisionalLoad(page_id, source_url, target_url);
+}
+
+void RenderViewHost::OnMsgDidFailProvisionalLoadWithError(
+    int64 frame_id,
+    bool is_main_frame,
+    int error_code,
+    const GURL& url,
+    bool showing_repost_interstitial) {
+  if (!is_swapped_out_) {
+    delegate_->DidFailProvisionalLoadWithError(frame_id, is_main_frame,
+                                               error_code, url,
+                                               showing_repost_interstitial);
+  }
+}
+
+void RenderViewHost::OnMsgDidLoadResourceFromMemoryCache(
+    const GURL& url,
+    const std::string& security_info) {
+  if (!is_swapped_out_)
+    delegate_->DidLoadResourceFromMemoryCache(url, security_info);
+}
+
+void RenderViewHost::OnMsgDidDisplayInsecureContent() {
+  if (!is_swapped_out_)
+    delegate_->DidDisplayInsecureContent();
+}
+
+void RenderViewHost::OnMsgDidRunInsecureContent(
+    const std::string& security_origin, const GURL& target_url) {
+  if (!is_swapped_out_)
+    delegate_->DidRunInsecureContent(security_origin, target_url);
+}
+
+void RenderViewHost::OnMsgDocumentLoadedInFrame(int64 frame_id) {
+  if (!is_swapped_out_)
+    delegate_->DocumentLoadedInFrame(frame_id);
+}
+
+void RenderViewHost::OnMsgDidFinishLoad(int64 frame_id) {
+  if (!is_swapped_out_)
+    delegate_->DidFinishLoad(frame_id);
+}
+
+void RenderViewHost::OnMsgUpdateContentRestrictions(int restrictions) {
+  if (!is_swapped_out_)
+    delegate_->UpdateContentRestrictions(restrictions);
 }
 
 void RenderViewHost::OnMsgDocumentAvailableInMainFrame() {
-  delegate_->DocumentAvailableInMainFrame(this);
+  if (!is_swapped_out_)
+    delegate_->DocumentAvailableInMainFrame(this);
 }
 
 void RenderViewHost::OnMsgDocumentOnLoadCompletedInMainFrame(int32 page_id) {
-  delegate_->DocumentOnLoadCompletedInMainFrame(this, page_id);
+  if (!is_swapped_out_)
+    delegate_->DocumentOnLoadCompletedInMainFrame(this, page_id);
 }
 
 void RenderViewHost::OnMsgContextMenu(const ContextMenuParams& params) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (!view)
+  if (!view || is_swapped_out_)
     return;
 
   // Validate the URLs in |params|.  If the renderer can't request the URLs
   // directly, don't show them in the context menu.
   ContextMenuParams validated_params(params);
   int renderer_id = process()->id();
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
 
   // We don't validate |unfiltered_link_url| so that this field can be used
   // when users want to copy the original link URL.
   FilterURL(policy, renderer_id, &validated_params.link_url);
   FilterURL(policy, renderer_id, &validated_params.src_url);
   FilterURL(policy, renderer_id, &validated_params.page_url);
   FilterURL(policy, renderer_id, &validated_params.frame_url);
 
   view->ShowContextMenu(validated_params);
 }
 
 void RenderViewHost::OnMsgOpenURL(const GURL& url,
                                   const GURL& referrer,
                                   WindowOpenDisposition disposition) {
+  if (is_swapped_out_)
+    return;
+
   GURL validated_url(url);
   FilterURL(ChildProcessSecurityPolicy::GetInstance(),
             process()->id(), &validated_url);
 
   delegate_->RequestOpenURL(validated_url, referrer, disposition);
 }
 
 void RenderViewHost::OnMsgDidContentsPreferredSizeChange(
     const gfx::Size& new_size) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (!view)
+  if (!view || is_swapped_out_)
     return;
   view->UpdatePreferredSize(new_size);
 }
 
 void RenderViewHost::OnMsgDomOperationResponse(
     const std::string& json_string, int automation_id) {
+  // We allow this even when swapped out.
   delegate_->DomOperationResponse(json_string, automation_id);
 
   // We also fire a notification for more loosely-coupled use cases.
   DomOperationNotificationDetails details(json_string, automation_id);
   NotificationService::current()->Notify(
       NotificationType::DOM_OPERATION_RESPONSE, Source<RenderViewHost>(this),
       Details<DomOperationNotificationDetails>(&details));
 }
 
 void RenderViewHost::OnMsgWebUISend(
     const GURL& source_url, const std::string& message,
     const std::string& content) {
   if (!ChildProcessSecurityPolicy::GetInstance()->
           HasWebUIBindings(process()->id())) {
     NOTREACHED() << "Blocked unauthorized use of WebUIBindings.";
     return;
   }
 
   scoped_ptr<Value> value;
   if (!content.empty()) {
     value.reset(base::JSONReader::Read(content, false));
     if (!value.get() || !value->IsType(Value::TYPE_LIST)) {
       // The page sent us something that we didn't understand.
       // This probably indicates a programming error.
       NOTREACHED() << "Invalid JSON argument in OnMsgWebUISend.";
       return;
     }
   }
 
+  if (is_swapped_out_)
+    return;
+
   ExtensionHostMsg_DomMessage_Params params;
   params.name = message;
   if (value.get())
     params.arguments.Swap(static_cast<ListValue*>(value.get()));
   params.source_url = source_url;
   // WebUI doesn't use these values yet.
   // TODO(aa): When WebUI is ported to ExtensionFunctionDispatcher, send real
   // values here.
   params.request_id = -1;
   params.has_callback = false;
   params.user_gesture = false;
   delegate_->ProcessWebUIMessage(params);
 }
 
 void RenderViewHost::OnMsgForwardMessageToExternalHost(
     const std::string& message, const std::string& origin,
     const std::string& target) {
-  delegate_->ProcessExternalHostMessage(message, origin, target);
+  if (!is_swapped_out_)
+    delegate_->ProcessExternalHostMessage(message, origin, target);
 }
 
 void RenderViewHost::DisassociateFromPopupCount() {
   Send(new ViewMsg_DisassociateFromPopupCount(routing_id()));
 }
 
 void RenderViewHost::OnMsgSetTooltipText(
     const std::wstring& tooltip_text,
     WebTextDirection text_direction_hint) {
+  if (is_swapped_out_)
+    return;
+
   // First, add directionality marks around tooltip text if necessary.
   // A naive solution would be to simply always wrap the text. However, on
   // windows, Unicode directional embedding characters can't be displayed on
   // systems that lack RTL fonts and are instead displayed as empty squares.
   //
   // To get around this we only wrap the string when we deem it necessary i.e.
   // when the locale direction is different than the tooltip direction hint.
   //
   // Currently, we use element's directionality as the tooltip direction hint.
   // An alternate solution would be to set the overall directionality based on
@@ skipping 10 matching lines @@
                !base::i18n::IsRTL()) {
       // Force the tooltip to have RTL directionality.
       base::i18n::WrapStringWithRTLFormatting(&wrapped_tooltip_text);
     }
   }
   if (view())
     view()->SetTooltipText(UTF16ToWide(wrapped_tooltip_text));
 }
 
 void RenderViewHost::OnMsgSelectionChanged(const std::string& text) {
-  if (view())
+  if (view() && !is_swapped_out_)
     view()->SelectionChanged(text);
 }
 
 void RenderViewHost::OnMsgRunJavaScriptMessage(
     const std::wstring& message,
     const std::wstring& default_prompt,
     const GURL& frame_url,
     const int flags,
     IPC::Message* reply_msg) {
   // While a JS message dialog is showing, tabs in the same process shouldn't
   // process input events.
   process()->set_ignore_input_events(true);
   StopHangMonitorTimeout();
-  delegate_->RunJavaScriptMessage(message, default_prompt, frame_url, flags,
-                                  reply_msg,
+  delegate_->RunJavaScriptMessage(this, message, default_prompt, frame_url,
+                                  flags, reply_msg,
                                   &are_javascript_messages_suppressed_);
 }
 
 void RenderViewHost::OnMsgRunBeforeUnloadConfirm(const GURL& frame_url,
                                                  const std::wstring& message,
                                                  IPC::Message* reply_msg) {
   // While a JS before unload dialog is showing, tabs in the same process
   // shouldn't process input events.
   process()->set_ignore_input_events(true);
   StopHangMonitorTimeout();
-  delegate_->RunBeforeUnloadConfirm(message, reply_msg);
+  delegate_->RunBeforeUnloadConfirm(this, message, reply_msg);
 }
 
 void RenderViewHost::MediaPlayerActionAt(const gfx::Point& location,
                                          const WebMediaPlayerAction& action) {
   // TODO(ajwong): Which thread should run this?  Does it matter?
   Send(new ViewMsg_MediaPlayerActionAt(routing_id(), location, action));
 }
 
 void RenderViewHost::ContextMenuClosed(
     const webkit_glue::CustomContextMenuContext& custom_context) {
   Send(new ViewMsg_ContextMenuClosed(routing_id(), custom_context));
 }
 
 void RenderViewHost::OnMsgStartDragging(
     const WebDropData& drop_data,
     WebDragOperationsMask drag_operations_mask,
     const SkBitmap& image,
     const gfx::Point& image_offset) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
       view->StartDragging(drop_data, drag_operations_mask, image, image_offset);
 }
 
 void RenderViewHost::OnUpdateDragCursor(WebDragOperation current_op) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
     view->UpdateDragCursor(current_op);
 }
 
 void RenderViewHost::OnTakeFocus(bool reverse) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
     view->TakeFocus(reverse);
 }
 
 void RenderViewHost::OnAddMessageToConsole(int32 level,
                                            const std::wstring& message,
                                            int32 line_no,
                                            const std::wstring& source_id) {
+  if (is_swapped_out_)
+    return;
+
   // Pass through log level only on WebUI pages to limit console spew.
   int32 resolved_level =
       BindingsPolicy::is_web_ui_enabled(enabled_bindings_) ? level : 0;
 
   logging::LogMessage("CONSOLE", line_no, resolved_level).stream() << "\"" <<
       message << "\", source: " << source_id << " (" << line_no << ")";
 }
 
 void RenderViewHost::AddObserver(RenderViewHostObserver* observer) {
   observers_.AddObserver(observer);
@@ skipping 10 matching lines @@
 }
 
 void RenderViewHost::UnhandledKeyboardEvent(
     const NativeWebKeyboardEvent& event) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
     view->HandleKeyboardEvent(event);
 }
 
 void RenderViewHost::OnUserGesture() {
-  delegate_->OnUserGesture();
+  if (is_swapped_out_)
+    delegate_->OnUserGesture();
 }
 
 void RenderViewHost::GetAllSavableResourceLinksForCurrentPage(
     const GURL& page_url) {
   Send(new ViewMsg_GetAllSavableResourceLinksForCurrentPage(routing_id(),
                                                             page_url));
 }
 
 void RenderViewHost::GetSerializedHtmlDataForCurrentPageWithLocalLinks(
     const std::vector<GURL>& links,
     const std::vector<FilePath>& local_paths,
     const FilePath& local_directory_name) {
   Send(new ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks(
       routing_id(), links, local_paths, local_directory_name));
 }
 
 void RenderViewHost::OnMsgShouldCloseACK(bool proceed) {
   StopHangMonitorTimeout();
   // If this renderer navigated while the beforeunload request was in flight, we
   // may have cleared this state in OnMsgNavigate, in which case we can ignore
   // this message.
-  if (!is_waiting_for_beforeunload_ack_)
+  if (!is_waiting_for_beforeunload_ack_ || is_swapped_out_)
     return;
 
   is_waiting_for_beforeunload_ack_ = false;
 
   RenderViewHostDelegate::RendererManagement* management_delegate =
       delegate_->GetRendererManagementDelegate();
   if (management_delegate) {
     management_delegate->ShouldClosePage(
         unload_ack_is_for_cross_site_transition_, proceed);
   }
 }
 
+void RenderViewHost::OnMsgClosePageACK() {
+  // We allow this even while swapped out.
+  ClosePageIgnoringUnloadEvents();
+}
+
 void RenderViewHost::WindowMoveOrResizeStarted() {
   Send(new ViewMsg_MoveOrResizeStarted(routing_id()));
 }
 
 void RenderViewHost::NotifyRendererUnresponsive() {
   delegate_->RendererUnresponsive(
       this, is_waiting_for_beforeunload_ack_ || is_waiting_for_unload_ack_);
 }
 
 void RenderViewHost::NotifyRendererResponsive() {
   delegate_->RendererResponsive(this);
 }
 
 void RenderViewHost::OnMsgFocusedNodeChanged(bool is_editable_node) {
-  delegate_->FocusedNodeChanged(is_editable_node);
+  if (!is_swapped_out_)
+    delegate_->FocusedNodeChanged(is_editable_node);
 }
 
 void RenderViewHost::OnMsgFocus() {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
     view->Activate();
 }
 
 void RenderViewHost::OnMsgBlur() {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
     view->Deactivate();
 }
 
 void RenderViewHost::ForwardMouseEvent(
     const WebKit::WebMouseEvent& mouse_event) {
 
   // We make a copy of the mouse event because
   // RenderWidgetHost::ForwardMouseEvent will delete |mouse_event|.
   WebKit::WebMouseEvent event_copy(mouse_event);
   RenderWidgetHost::ForwardMouseEvent(event_copy);
@@ skipping 18 matching lines @@
         view->HandleMouseUp();
       default:
         // For now, we don't care about the rest.
         break;
     }
   }
 }
 
 void RenderViewHost::OnMouseActivate() {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view)
+  if (view && !is_swapped_out_)
     view->HandleMouseActivate();
 }
 
 void RenderViewHost::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   if (ignore_input_events()) {
     if (key_event.type == WebInputEvent::RawKeyDown)
       delegate_->OnIgnoredUIEvent();
     return;
   }
@@ skipping 97 matching lines @@
     *url = GURL();
   }
 }
 
 void RenderViewHost::JavaScriptStressTestControl(int cmd, int param) {
   Send(new ViewMsg_JavaScriptStressTestControl(routing_id(), cmd, param));
 }
 
 void RenderViewHost::OnAccessibilityNotifications(
     const std::vector<ViewHostMsg_AccessibilityNotification_Params>& params) {
-  if (view())
+  if (view() && !is_swapped_out_)
     view()->OnAccessibilityNotifications(params);
 
   if (!params.empty()) {
     for (unsigned i = 0; i < params.size(); i++) {
       const ViewHostMsg_AccessibilityNotification_Params& param = params[i];
 
       if (param.notification_type ==
               ViewHostMsg_AccessibilityNotification_Type::
                   NOTIFICATION_TYPE_LOAD_COMPLETE) {
         // TODO(ctguil): Remove when mac processes OnAccessibilityNotifications.
         if (view())
           view()->UpdateAccessibilityTree(param.acc_obj);
 
         if (save_accessibility_tree_for_testing_)
           accessibility_tree_ = param.acc_obj;
       }
     }
 
     NotificationService::current()->Notify(
         NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED,
         Source<RenderViewHost>(this),
         NotificationService::NoDetails());
   }
 
   AccessibilityNotificationsAck();
 }
 
 void RenderViewHost::OnCSSInserted() {
-  delegate_->DidInsertCSS();
+  if (!is_swapped_out_)
+    delegate_->DidInsertCSS();
 }
 
 void RenderViewHost::OnContentBlocked(ContentSettingsType type,
                                       const std::string& resource_identifier) {
   RenderViewHostDelegate::ContentSettings* content_settings_delegate =
       delegate_->GetContentSettingsDelegate();
-  if (content_settings_delegate)
+  if (content_settings_delegate && !is_swapped_out_)
     content_settings_delegate->OnContentBlocked(type, resource_identifier);
 }
 
 void RenderViewHost::OnAppCacheAccessed(const GURL& manifest_url,
                                         bool blocked_by_policy) {
   RenderViewHostDelegate::ContentSettings* content_settings_delegate =
       delegate_->GetContentSettingsDelegate();
-  if (content_settings_delegate)
+  if (content_settings_delegate && !is_swapped_out_)
     content_settings_delegate->OnAppCacheAccessed(manifest_url,
                                                   blocked_by_policy);
 }
 
 void RenderViewHost::OnWebDatabaseAccessed(const GURL& url,
                                            const string16& name,
                                            const string16& display_name,
                                            unsigned long estimated_size,
                                            bool blocked_by_policy) {
   RenderViewHostDelegate::ContentSettings* content_settings_delegate =
       delegate_->GetContentSettingsDelegate();
-  if (content_settings_delegate)
+  if (content_settings_delegate && !is_swapped_out_)
     content_settings_delegate->OnWebDatabaseAccessed(
         url, name, display_name, estimated_size, blocked_by_policy);
 }
 
 void RenderViewHost::OnUpdateZoomLimits(int minimum_percent,
                                         int maximum_percent,
                                         bool remember) {
-  delegate_->UpdateZoomLimits(minimum_percent, maximum_percent, remember);
+  if (!is_swapped_out_)
+    delegate_->UpdateZoomLimits(minimum_percent, maximum_percent, remember);
 }
 
 void RenderViewHost::OnScriptEvalResponse(int id, const ListValue& result) {
   Value* result_value;
   if (!result.Get(0, &result_value)) {
     // Programming error or rogue renderer.
     NOTREACHED() << "Got bad arguments for OnScriptEvalResponse";
     return;
   }
+  if (is_swapped_out_)
+    return;
+
   std::pair<int, Value*> details(id, result_value);
   NotificationService::current()->Notify(
       NotificationType::EXECUTE_JAVASCRIPT_RESULT,
       Source<RenderViewHost>(this),
       Details<std::pair<int, Value*> >(&details));
 }
 
 #if defined(OS_MACOSX)
 void RenderViewHost::OnMsgShowPopup(
     const ViewHostMsg_ShowPopup_Params& params) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
-  if (view) {
+  if (view && !is_swapped_out_) {
     view->ShowPopupMenu(params.bounds,
                         params.item_height,
                         params.item_font_size,
                         params.selected_item,
                         params.popup_items,
                         params.right_aligned);
   }
 }
 #endif
 
@@ skipping 11 matching lines @@
     LOG(DFATAL) << "Invalid checked state " << checked_state;
     return;
   }
 
   CommandState state;
   state.is_enabled = is_enabled;
   state.checked_state =
       static_cast<RenderViewCommandCheckedState>(checked_state);
   command_states_[static_cast<RenderViewCommand>(command)] = state;
 }