Eliminate SwapOut message parameters, keeping state in RVHM instead.

content/browser/renderer_host/render_view_host_impl.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_IMPL_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 276 matching lines @@
   // Whether this RenderViewHost has been swapped out to be displayed by a
   // different process.
   bool is_swapped_out() const { return is_swapped_out_; }
 
   // Tells the renderer that this RenderView is being swapped out for one in a
   // different renderer process.  It should run its unload handler and move to
   // a blank document.  The renderer should preserve the Frame object until it
   // exits, in case we come back.  The renderer can exit if it has no other
   // active RenderViews, but not until WasSwappedOut is called (when it is no
   // longer visible).
-  //
-  // Please see ViewMsg_SwapOut_Params in view_messages.h for a description
-  // of the parameters.
-  void SwapOut(int new_render_process_host_id, int new_request_id);
+  void SwapOut();
 
-  // Called by ResourceDispatcherHost after the SwapOutACK is received or the
-  // response times out.
-  void OnSwapOutACK(bool timed_out);
+  // Called when either the SwapOut request has been acknowledged or has timed
+  // out.
+  void OnSwappedOut(bool timed_out);
 
   // Called to notify the renderer that it has been visibly swapped out and
   // replaced by another RenderViewHost, after an earlier call to SwapOut.
   // It is now safe for the process to exit if there are no other active
   // RenderViews.
   void WasSwappedOut();
 
   // Close the page ignoring whether it has unload events registers.
   // This is called after the beforeunload and unload events have fired
   // and the user has agreed to continue with closing the page.
   void ClosePageIgnoringUnloadEvents();
 
+  // Returns whether this RenderViewHost has an outstanding cross-site request.
+  // Cleared when we hear the response and start to swap out the old
+  // RenderViewHost, or if we hear a commit here without a network request.
+  bool HasPendingCrossSiteRequest();
+
   // Sets whether this RenderViewHost has an outstanding cross-site request,
   // for which another renderer will need to run an onunload event handler.
   // This is called before the first navigation event for this RenderViewHost,
-  // and again after the corresponding OnCrossSiteResponse.
-  void SetHasPendingCrossSiteRequest(bool has_pending_request, int request_id);
-
-  // Returns the request_id for the pending cross-site request.
-  // This is just needed in case the unload of the current page
-  // hangs, in which case we need to swap to the pending RenderViewHost.
-  int GetPendingRequestId();
+  // and cleared when we hear the response or commit.
+  void SetHasPendingCrossSiteRequest(bool has_pending_request);
 
   // Notifies the RenderView that the JavaScript message that was shown was
   // closed by the user.
   void JavaScriptDialogClosed(IPC::Message* reply_msg,
                               bool success,
                               const string16& user_input);
 
   // Tells the renderer view to focus the first (last if reverse is true) node.
   void SetInitialFocus(bool reverse);
 
@@ skipping 88 matching lines @@
   }
 
   // Set accessibility callbacks.
   void SetAccessibilityLayoutCompleteCallbackForTesting(
       const base::Closure& callback);
   void SetAccessibilityLoadCompleteCallbackForTesting(
       const base::Closure& callback);
   void SetAccessibilityOtherCallbackForTesting(
       const base::Closure& callback);
 
-  bool is_waiting_for_unload_ack_for_testing() {
+  bool is_waiting_for_beforeunload_ack() {
+    return is_waiting_for_beforeunload_ack_;
+  }
+
+  bool is_waiting_for_unload_ack() {
     return is_waiting_for_unload_ack_;
   }
 
   // Returns whether the given URL is allowed to commit in the current process.
   // This is a more conservative check than FilterURL, since it will be used to
   // kill processes that commit unauthorized URLs.
   bool CanCommitURL(const GURL& url);
 
   // Checks that the given renderer can request |url|, if not it sets it to
   // about:blank.
@@ skipping 101 matching lines @@
                              const string16& message,
                              int32 line_no,
                              const string16& source_id);
   void OnUpdateInspectorSetting(const std::string& key,
                                 const std::string& value);
   void OnShouldCloseACK(
       bool proceed,
       const base::TimeTicks& renderer_before_unload_start_time,
       const base::TimeTicks& renderer_before_unload_end_time);
   void OnClosePageACK();
+  void OnSwapOutACK();
   void OnAccessibilityNotifications(
       const std::vector<AccessibilityHostMsg_NotificationParams>& params);
   void OnScriptEvalResponse(int id, const base::ListValue& result);
   void OnDidZoomURL(double zoom_level, bool remember, const GURL& url);
   void OnMediaNotification(int64 player_cookie,
                            bool has_video,
                            bool has_audio,
                            bool is_playing);
   void OnRequestDesktopNotificationPermission(const GURL& origin,
                                               int callback_id);
@@ skipping 37 matching lines @@
   scoped_refptr<SiteInstanceImpl> instance_;
 
   // true if we are currently waiting for a response for drag context
   // information.
   bool waiting_for_drag_context_response_;
 
   // A bitwise OR of bindings types that have been enabled for this RenderView.
   // See BindingsPolicy for details.
   int enabled_bindings_;
 
-  // The request_id for the pending cross-site request. Set to -1 if
-  // there is a pending request, but we have not yet started the unload
-  // for the current page. Set to the request_id value of the pending
-  // request once we have gotten the some data for the pending page
-  // and thus started the unload process.
-  int pending_request_id_;
-
   // Whether we should buffer outgoing Navigate messages rather than sending
   // them.  This will be true when a RenderViewHost is created for a cross-site
   // request, until we hear back from the onbeforeunload handler of the old
   // RenderViewHost.
   bool navigations_suspended_;
 
   // We only buffer the params for a suspended navigation while we have a
   // pending RVH for a WebContentsImpl.  There will only ever be one suspended
   // navigation, because WebContentsImpl will destroy the pending RVH and create
   // a new one if a second navigation occurs.
@@ skipping 91 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostImpl);
 };
 
 #if defined(COMPILER_MSVC)
 #pragma warning(pop)
 #endif
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_IMPL_H_