Move RenderViewHost swap out state to RenderFrameHost.

content/browser/frame_host/render_frame_host_impl.h

 // Copyright 2013 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_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
+#include "content/browser/site_instance_impl.h"
 #include "content/common/accessibility_mode_enums.h"
 #include "content/common/content_export.h"
 #include "content/common/mojo/service_registry_impl.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/javascript_message_type.h"
 #include "net/http/http_response_headers.h"
 #include "third_party/WebKit/public/platform/WebNotificationPermission.h"
 #include "third_party/WebKit/public/web/WebTextDirection.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/base/page_transition_types.h"
@@ skipping 18 matching lines @@
 
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class FrameTree;
 class FrameTreeNode;
 class RenderFrameHostDelegate;
 class RenderFrameProxyHost;
 class RenderProcessHost;
 class RenderViewHostImpl;
 class RenderWidgetHostImpl;
+class TimeoutMonitor;
 struct ContextMenuParams;
 struct GlobalRequestID;
 struct Referrer;
 struct ShowDesktopNotificationHostMsgParams;
 struct TransitionLayerData;
 
 class CONTENT_EXPORT RenderFrameHostImpl
     : public RenderFrameHost,
       public BrowserAccessibilityDelegate {
  public:
+  // Keeps track of the state of the RenderFrameHostImpl, particularly with
+  // respect to swap out.
+  enum RenderFrameHostImplState {
+    // The standard state for a RFH handling the communication with an active
+    // RenderFrame.
+    STATE_DEFAULT = 0,
+    // The RFH has not received the SwapOutACK yet, but the new page has
+    // committed in a different RFH. The number of active frames of the RFH
+    // SiteInstanceImpl is not zero. Upon reception of the SwapOutACK, the RFH
+    // will be swapped out.
+    STATE_PENDING_SWAP_OUT,
+    // The RFH has not received the SwapOutACK yet, but the new page has
+    // committed in a different RFH. The number of active frames of the RFH
+    // SiteInstanceImpl is zero. Upon reception of the SwapOutACK, the RFH will
+    // be shutdown.
+    STATE_PENDING_SHUTDOWN,
+    // The RFH is swapped out and stored inside a RenderFrameProxyHost, being
+    // used as a placeholder to allow cross-process communication.
+    STATE_SWAPPED_OUT,
+  };
+  // Helper function to determine whether the RFH state should contribute to the
+  // number of active frames of a SiteInstance or not.
+  static bool IsRFHStateActive(RenderFrameHostImplState rfh_state);
+
   static RenderFrameHostImpl* FromID(int process_id, int routing_id);
 
   virtual ~RenderFrameHostImpl();
 
   // RenderFrameHost
   virtual int GetRoutingID() OVERRIDE;
-  virtual SiteInstance* GetSiteInstance() OVERRIDE;
+  virtual SiteInstanceImpl* GetSiteInstance() OVERRIDE;
   virtual RenderProcessHost* GetProcess() OVERRIDE;
   virtual RenderFrameHost* GetParent() OVERRIDE;
   virtual const std::string& GetFrameName() OVERRIDE;
   virtual bool IsCrossProcessSubframe() OVERRIDE;
   virtual GURL GetLastCommittedURL() OVERRIDE;
   virtual gfx::NativeView GetNativeView() OVERRIDE;
   virtual void ExecuteJavaScript(
       const base::string16& javascript) OVERRIDE;
   virtual void ExecuteJavaScript(
       const base::string16& javascript,
@@ skipping 102 matching lines @@
       const TransitionLayerData& transition_data);
 
   // Tells the renderer that this RenderFrame is being swapped out for one in a
   // different renderer process.  It should run its unload handler, move to
   // a blank document and create a RenderFrameProxy to replace the RenderFrame.
   // The renderer should preserve the Proxy object until it exits, in case we
   // come back.  The renderer can exit if it has no other active RenderFrames,
   // but not until WasSwappedOut is called (when it is no longer visible).
   void SwapOut(RenderFrameProxyHost* proxy);
 
-  void OnSwappedOut(bool timed_out);
-  bool is_swapped_out() { return is_swapped_out_; }
-  void set_swapped_out(bool is_swapped_out) {
-    is_swapped_out_ = is_swapped_out;
+  bool is_waiting_for_beforeunload_ack() const {
+    return is_waiting_for_beforeunload_ack_;
   }
 
-  // Sets the RVH for |this| as pending shutdown. |on_swap_out| will be called
-  // when the SwapOutACK is received.
+  // Whether the RFH is waiting for an unload ACK from the renderer.
+  bool IsWaitingForUnloadACK() const;
+
+  // Called when either the SwapOut request has been acknowledged or has timed
+  // out.
+  void OnSwappedOut();
+
+  // Whether this RenderFrameHost has been swapped out to be displayed by a

[nasko, 2014/09/29 20:28:09]

nit: I'm not quite sure I understand the comment. The "to be displayed by a
different process" is probably why. In swapped out state, RFH isn't displayed at
all. The frame represented by FTN is displayed by a different RFH and process.

[Charlie Reis, 2014/09/29 20:49:21]

Oops, I agree.  (I was just moving the old comment from RVH.)  Updated.

+  // different process.
+  bool is_swapped_out() const { return rfh_state_ == STATE_SWAPPED_OUT; }
+
+  // The current state of this RFH.
+  RenderFrameHostImplState rfh_state() const { return rfh_state_; }
+
+  // Set |this| as pending shutdown. |on_swap_out| will be called
+  // when the SwapOutACK is received, or when the unload timer times out.
   void SetPendingShutdown(const base::Closure& on_swap_out);
 
   // Sends the given navigation message. Use this rather than sending it
   // yourself since this does the internal bookkeeping described below. This
   // function takes ownership of the provided message pointer.
   //
   // If a cross-site request is in progress, we may be suspended while waiting
   // for the onbeforeunload handler, so this function might buffer the message
   // rather than sending it.
   void Navigate(const FrameMsg_Navigate_Params& params);
@@ skipping 167 matching lines @@
   void OnAccessibilityEvents(
       const std::vector<AccessibilityHostMsg_EventParams>& params);
   void OnAccessibilityLocationChanges(
       const std::vector<AccessibilityHostMsg_LocationChangeParams>& params);
 
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   void OnShowPopup(const FrameHostMsg_ShowPopup_Params& params);
   void OnHidePopup();
 #endif
 
+  // Updates the state of this RenderFrameHost and clears any waiting state
+  // that is no longer relevant.
+  void SetState(RenderFrameHostImplState rfh_state);
+
   // 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);
 
   void PlatformNotificationPermissionRequestDone(
       int request_id, blink::WebNotificationPermission permission);
 
   // Update the the singleton FrameAccessibility instance with a map
   // from accessibility node id to the frame routing id of a cross-process
@@ skipping 44 matching lines @@
   FrameTreeNode* frame_tree_node_;
 
   // The mapping of pending JavaScript calls created by
   // ExecuteJavaScript and their corresponding callbacks.
   std::map<int, JavaScriptResultCallback> javascript_callbacks_;
 
   // Map from notification_id to a callback to cancel them.
   std::map<int, base::Closure> cancel_notification_callbacks_;
 
   int routing_id_;
-  bool is_swapped_out_;
+
+  // The current state of this RenderFrameHost.
+  RenderFrameHostImplState rfh_state_;
 
   // Tracks whether the RenderFrame for this RenderFrameHost has been created in
   // the renderer process.  Currently only used for subframes.
   // TODO(creis): Use this for main frames as well when RVH goes away.
   bool render_frame_created_;
 
   // Whether we should buffer outgoing Navigate messages rather than sending
   // them. This will be true when a RenderFrameHost is created for a cross-site
   // request, until we hear back from the onbeforeunload handler of the old
   // RenderFrameHost.
   bool navigations_suspended_;
 
   // We only buffer the params for a suspended navigation while this RFH is the
   // pending RenderFrameHost of a RenderFrameHostManager. There will only ever
   // be one suspended navigation, because RenderFrameHostManager will destroy
   // the pending RenderFrameHost and create a new one if a second navigation
   // occurs.
   scoped_ptr<FrameMsg_Navigate_Params> suspended_nav_params_;
 
   // When the last BeforeUnload message was sent.
   base::TimeTicks send_before_unload_start_time_;
 
+  // Set to true when there is a pending FrameMsg_ShouldClose message.  This
+  // ensures we don't spam the renderer with multiple beforeunload requests.
+  // 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.
+  // TODO(clamy): Remove this boolean and add one more state to the state
+  // machine.
+  bool is_waiting_for_beforeunload_ack_;
+
+  // Valid only when is_waiting_for_beforeunload_ack_ or
+  // IsWaitingForUnloadACK is true.  This tells us if the unload request
+  // is for closing the entire tab ( = false), or only this RenderFrameHost in
+  // the case of a cross-site transition ( = true).
+  bool unload_ack_is_for_cross_site_transition_;
+
+  // Used to swap out or shut down this RFH when the unload event is taking too
+  // long to execute, depending on the number of active frames in the
+  // SiteInstance.
+  scoped_ptr<TimeoutMonitor> swapout_event_monitor_timeout_;
+
+  // Called after receiving the SwapOutACK when the RFH is in the pending
+  // shutdown state. Also called if the unload timer times out.
+  base::Closure pending_shutdown_on_swap_out_;
+
   ServiceRegistryImpl service_registry_;
 
   scoped_ptr<BrowserAccessibilityManager> browser_accessibility_manager_;
 
   // Callback when an event is received, for testing.
   base::Callback<void(ui::AXEvent, int)> accessibility_testing_callback_;
   // The most recently received accessibility tree - for testing only.
   scoped_ptr<ui::AXTree> ax_tree_for_testing_;
 
   // NOTE: This must be the last member.
   base::WeakPtrFactory<RenderFrameHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_