Have the unload event execute in background on cross-site navigations

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>
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process/kill.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/drag_event_source_info.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/common/javascript_message_type.h"
@@ skipping 35 matching lines @@
 
 namespace content {
 
 class BrowserMediaPlayerManager;
 class ChildProcessSecurityPolicyImpl;
 class PageState;
 class RenderWidgetHostDelegate;
 class SessionStorageNamespace;
 class SessionStorageNamespaceImpl;
 class TestRenderViewHost;
+class TimeoutMonitor;
 struct ContextMenuParams;
 struct FileChooserParams;
 struct Referrer;
 struct ShowDesktopNotificationHostMsgParams;
 
 #if defined(COMPILER_MSVC)
 // RenderViewHostImpl is the bottom of a diamond-shaped hierarchy,
 // with RenderWidgetHost at the root. VS warns when methods from the
 // root are overridden in only one of the base classes and not both
 // (in this case, RenderWidgetHostImpl provides implementations of
@@ skipping 15 matching lines @@
 //
 // Right now, the concept of page navigation (both top level and frame) exists
 // in the WebContentsImpl still, so if you instantiate one of these elsewhere,
 // you will not be able to traverse pages back and forward. We need to determine
 // if we want to bring that and other functionality down into this object so it
 // can be shared by others.
 class CONTENT_EXPORT RenderViewHostImpl
     : public RenderViewHost,
       public RenderWidgetHostImpl {
  public:
+  enum RenderViewHostImplState {

[nasko, 2014/01/23 23:34:58]

Having a good comment for each of those states will be awesome. Since this is
hard to understand area, anything we can do to help our future selves will be
great!

[clamy, 2014/01/24 17:01:54]

Done.

+    RVH_STATE_LIVE = 0,

[nasko, 2014/01/23 23:34:58]

nit: Drop the RVH_ prefix, as this is already accessed through
RenderViewHostImpl:: prefix.

[clamy, 2014/01/24 17:01:54]

Done.

+    RVH_STATE_WAITING_FOR_UNLOAD_ACK,
+    RVH_STATE_WAITING_FOR_COMMIT,
+    RVH_STATE_WAITING_FOR_CLOSE,
+    RVH_STATE_PENDING_SWAP_OUT,
+    RVH_STATE_PENDING_SHUTDOWN,
+    RVH_STATE_SWAPPED_OUT,
+  };
+  // Helper function to determine whether the RVH state should contribute to the
+  // number of active views of a SiteInstance or not.
+  static bool IsRVHStateActive(RenderViewHostImplState rvh_state);
+
   // Convenience function, just like RenderViewHost::FromID.
   static RenderViewHostImpl* FromID(int render_process_id, int render_view_id);
 
   // |routing_id| could be a valid route id, or it could be MSG_ROUTING_NONE, in
   // which case RenderWidgetHost will create a new one.  |swapped_out| indicates
   // whether the view should initially be swapped out (e.g., for an opener
   // frame being rendered by another process). |hidden| indicates whether the
   // view is initially hidden or visible.
   //
   // The |session_storage_namespace| parameter allows multiple render views and
@@ skipping 163 matching lines @@
   // RenderViewHost.
   void CancelSuspendedNavigations();
 
   // Whether the initial empty page of this view has been accessed by another
   // page, making it unsafe to show the pending URL.  Always false after the
   // first commit.
   bool has_accessed_initial_document() {
     return has_accessed_initial_document_;
   }
 
-  // Whether this RenderViewHost has been swapped out to be displayed by a
-  // different process.
-  bool is_swapped_out() const { return is_swapped_out_; }

[nasko, 2014/01/23 23:34:58]

nit: This might be useful method to keep around as an easy way to check for
swapped out state.

[clamy, 2014/01/24 17:01:54]

Do we want it to return true only for STATE_SWAPPED_OUT, or include
STATE_PENDING_SWAP_OUT as well? When the RVH is in STATE_PENDING_SWAP_OUT, it is
stored in the map of swapped_out_hosts in the RenderFrameHostManager (though it
does not filter all IPCs as in STATE_SWAPPED_OUT).

[nasko, 2014/01/27 19:09:51]

Based on the replaced usages, it looks that returning only true for
STATE_SWAPPED_OUT is the best thing. Also, it will match the name and be
conceptually simple.

[clamy, 2014/01/28 12:27:21]

Done.

+  // The current state of this RVH.
+  RenderViewHostImplState rvh_state() const { return rvh_state_; }
 
   // Called on the pending RenderViewHost when the network response is ready to
   // commit.  We should ensure that the old RenderViewHost runs its unload
   // handler and determine whether a transfer to a different RenderViewHost is
   // needed.
   void OnCrossSiteResponse(
       const GlobalRequestID& global_request_id,
       bool is_transfer,
       const std::vector<GURL>& transfer_url_chain,
       const Referrer& referrer,
@@ skipping 12 matching lines @@
   // 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).
   void SwapOut();
 
   // 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();
+  // Called when the RenderFrameHostManager has swapped in a new
+  // RenderFrameHost. Should |this| RVH switch to the pending shutdown state,
+  // |pending_delete_on_swap_out| will be executed upon reception of the
+  // SwapOutACK, or when the unload timer times out.
+  void WasSwappedOut(const base::Closure& pending_delete_on_swap_out);
+
+  // Set |this| as pending shutdown. |on_swap_out| will be called
+  // when the swap out ack is received, or when the unload timer times out.
+  void SetPendingShutdown(const base::Closure& on_swap_out);
 
   // 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();
@@ skipping 113 matching lines @@
       const base::Closure& callback);
   void SetAccessibilityLoadCompleteCallbackForTesting(
       const base::Closure& callback);
   void SetAccessibilityOtherCallbackForTesting(
       const base::Closure& callback);
 
   bool is_waiting_for_beforeunload_ack() {
     return is_waiting_for_beforeunload_ack_;
   }
 
-  bool is_waiting_for_unload_ack() {
-    return is_waiting_for_unload_ack_;
-  }
+  // Whether the RVH is waiting for the unload ack from the renderer.
+  bool IsWaitingForUnloadACK() const;
 
   // Returns whether the given URL is allowed to commit in the current process.
   // This is a more conservative check than RenderProcessHost::FilterURL, since
   // it will be used to kill processes that commit unauthorized URLs.
   bool CanCommitURL(const GURL& url);
 
   // Update the FrameTree to use this RenderViewHost's main frame
   // RenderFrameHost. Called when the RenderViewHost is committed.
   //
   // TODO(ajwong): Remove once RenderViewHost no longer owns the main frame
   // RenderFrameHost.
   void AttachToFrameTree();
 
   // The following IPC handlers are public so RenderFrameHost can call them,
   // while we transition the code to not use RenderViewHost.
   //
   // TODO(nasko): Remove those methods once we are done moving navigation
   // into RenderFrameHost.
   void OnDidStartProvisionalLoadForFrame(int64 frame_id,
                                          int64 parent_frame_id,
                                          bool main_frame,
                                          const GURL& url);
 
+  // Increases the refcounting on this RVH. This is done by the FrameTree on
+  // creation of a RenderFrameHost.
+  void increment_ref_count() { ++ref_count_; }
+
+  // Decreases the refcounting on this RVH. This is done by the FrameTree on
+  // destruction of a RenderFrameHost.
+  void decrement_ref_count() { --ref_count_; }
+
+  // Returns the refcount on this RVH, that is the number of RenderFrameHosts
+  // currently using it.
+  int ref_count() { return ref_count_; }
+
   // NOTE: Do not add functions that just send an IPC message that are called in
   // one or two places. Have the caller send the IPC message directly (unless
   // the caller places are in different platforms, in which case it's better
   // to keep them consistent).
 
  protected:
   // RenderWidgetHost protected overrides.
   virtual void OnUserGesture() OVERRIDE;
   virtual void NotifyRendererUnresponsive() OVERRIDE;
   virtual void NotifyRendererResponsive() OVERRIDE;
@@ skipping 96 matching lines @@
 
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   void OnShowPopup(const ViewHostMsg_ShowPopup_Params& params);
 #endif
 
  private:
   friend class TestRenderViewHost;
   FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, BasicRenderFrameHost);
   FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, RoutingIdSane);
 
-  // Sets whether this RenderViewHost is swapped out in favor of another,
-  // and clears any waiting state that is no longer relevant.
-  void SetSwappedOut(bool is_swapped_out);
+  // Updates the state of this RenderViewHost and clears any waiting state
+  // that is no longer relevant.
+  void SetRVHState(RenderViewHostImplState rvh_state);

[nasko, 2014/01/23 23:34:58]

nit: Why not just SetState? The method is already called on RVH object, so that
part is redundant.

[clamy, 2014/01/24 17:01:54]

Done.

 
   bool CanAccessFilesOfPageState(const PageState& state) const;
 
+  // The number of RenderFrameHost which have a pointer to this RVH.

[nasko, 2014/01/23 23:34:58]

nit: s/pointer/reference/

[clamy, 2014/01/24 17:01:54]

Done.

+  int ref_count_;

[nasko, 2014/01/23 23:34:58]

The name implies generic ref count, which this isn't. Maybe call it
frames_ref_count_?

[clamy, 2014/01/24 17:01:54]

Done.

+
   // Our delegate, which wants to know about changes in the RenderView.
   RenderViewHostDelegate* delegate_;
 
   // The SiteInstance associated with this RenderViewHost.  All pages drawn
   // in this RenderViewHost are part of this SiteInstance.  Should not change
   // over time.
   scoped_refptr<SiteInstanceImpl> instance_;
 
   // true if we are currently waiting for a response for drag context
   // information.
@@ skipping 14 matching lines @@
   // navigation, because WebContentsImpl will destroy the pending RVH and create
   // a new one if a second navigation occurs.
   scoped_ptr<ViewMsg_Navigate_Params> suspended_nav_params_;
 
   // Whether the initial empty page of this view has been accessed by another
   // page, making it unsafe to show the pending URL.  Usually false unless
   // another window tries to modify the blank page.  Always false after the
   // first commit.
   bool has_accessed_initial_document_;
 
-  // Whether this RenderViewHost is currently swapped out, such that the view is
-  // being rendered by another process.
-  bool is_swapped_out_;
+  // The current state of this RVH.
+  RenderViewHostImplState rvh_state_;
 
   // The frame id of the main (top level) frame. This value is set on the
   // initial navigation of a RenderView and reset when the RenderView's
   // process is terminated (in RenderProcessGone).
   // TODO(creis): Remove this when we switch to routing IDs for frames.
   int64 main_frame_id_;
 
   // Routing ID for the main frame's RenderFrameHost.
   int main_frame_routing_id_;
 
   // If we were asked to RunModal, then this will hold the reply_msg that we
   // must return to the renderer to unblock it.
   IPC::Message* run_modal_reply_msg_;
   // This will hold the routing id of the RenderView that opened us.
   int run_modal_opener_id_;
 
   // Set to true when there is a pending ViewMsg_ShouldClose message.  This
   // ensures we don't spam the renderer with multiple beforeunload requests.
-  // When either this value or is_waiting_for_unload_ack_ is true, the value of
+  // When either this value or IsWaitingForUnloadACK is true, the value of
   // unload_ack_is_for_cross_site_transition_ indicates whether this is for a
   // cross-site transition or a tab close attempt.
   bool is_waiting_for_beforeunload_ack_;
 
-  // Set to true when there is a pending ViewMsg_Close message.  Also see
-  // is_waiting_for_beforeunload_ack_, unload_ack_is_for_cross_site_transition_.
-  bool is_waiting_for_unload_ack_;
-
-  // Set to true when waiting for ViewHostMsg_SwapOut_ACK has timed out.
-  bool has_timed_out_on_unload_;
-
   // Valid only when is_waiting_for_beforeunload_ack_ or
-  // is_waiting_for_unload_ack_ is true.  This tells us if the unload request
+  // IsWaitingForUnloadACK is true.  This tells us if the unload request
   // is for closing the entire tab ( = false), or only this RenderViewHost in
   // the case of a cross-site transition ( = true).
   bool unload_ack_is_for_cross_site_transition_;
 
   bool are_javascript_messages_suppressed_;
 
   // The mapping of pending javascript calls created by
   // ExecuteJavascriptInWebFrameCallbackResult and their corresponding
   // callbacks.
   std::map<int, JavascriptResultCallback> javascript_callbacks_;
@@ skipping 14 matching lines @@
   base::TimeTicks send_should_close_start_time_;
 
   // Set to true if we requested the on screen keyboard to be displayed.
   bool virtual_keyboard_requested_;
 
 #if defined(OS_ANDROID)
   // Manages all the android mediaplayer objects and handling IPCs for video.
   scoped_ptr<BrowserMediaPlayerManager> media_player_manager_;
 #endif
 
+  // Used to shutdown this RVH when the unload event is taking too long to
+  // execute.
+  scoped_ptr<TimeoutMonitor> unload_event_monitor_timeout_;
+
+  // Called after receiving the swap out ack when the RVH is in state pending
+  // shutdown. Also called if the unload timer times out.
+  base::Closure pending_shutdown_on_swap_out_;
+
+  base::WeakPtrFactory<RenderViewHostImpl> weak_factory_;
+
   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_