Merge CrossSiteResourceHandler and NavigationResourceThrottle

content/browser/frame_host/navigation_handle_impl.h

 // Copyright 2015 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_NAVIGATION_HANDLE_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_NAVIGATION_HANDLE_IMPL_H_
 
 #include "content/public/browser/navigation_handle.h"
 
 #include <stddef.h>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/content_export.h"
+#include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_data.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/ssl_status.h"
 #include "content/public/common/request_context_type.h"
 #include "url/gurl.h"
 
 struct FrameHostMsg_DidCommitProvisionalLoad_Params;
 
 namespace content {
 
 class NavigatorDelegate;
 class ResourceRequestBodyImpl;
+class SiteInstance;
 
 // This class keeps track of a single navigation. It is created upon receipt of
 // a DidStartProvisionalLoad IPC in a RenderFrameHost. The RenderFrameHost owns
 // the newly created NavigationHandleImpl as long as the navigation is ongoing.
 // The NavigationHandleImpl in the RenderFrameHost will be reset when the
 // navigation stops, that is if one of the following events happen:
 //   - The RenderFrameHost receives a DidStartProvisionalLoad IPC for a new
 //   navigation (see below for special cases where the DidStartProvisionalLoad
 //   message does not indicate the start of a new navigation).
 //   - The RenderFrameHost stops loading.
@@ skipping 103 matching lines @@
 
   // Returns whether the navigation is currently being transferred from one
   // RenderFrameHost to another. In particular, a DidStartProvisionalLoad IPC
   // for the navigation URL, received in the new RenderFrameHost, should not
   // indicate the start of a new navigation in that case.
   bool is_transferring() const { return is_transferring_; }
   void set_is_transferring(bool is_transferring) {
     is_transferring_ = is_transferring;
   }
 
-  // Updates the RenderFrameHost that is about to commit the navigation. This
-  // is used during transfer navigations.
-  void set_render_frame_host(RenderFrameHostImpl* render_frame_host) {
-    render_frame_host_ = render_frame_host;
-  }
-
   // Returns the POST body associated with this navigation.  This will be
   // null for GET and/or other non-POST requests (or if a response to a POST
   // request was a redirect that changed the method to GET - for example 302).
   const scoped_refptr<ResourceRequestBodyImpl>& resource_request_body() const {
     return resource_request_body_;
   }
 
   typedef base::Callback<void(NavigationThrottle::ThrottleCheckResult)>
       ThrottleChecksFinishedCallback;
 
@@ skipping 21 matching lines @@
       bool new_is_external_protocol,
       scoped_refptr<net::HttpResponseHeaders> response_headers,
       const ThrottleChecksFinishedCallback& callback);
 
   // Called when the URLRequest has delivered response headers and metadata.
   // |callback| will be called when all throttle checks have completed,
   // allowing the caller to cancel the navigation or let it proceed.
   // NavigationHandle will not call |callback| with a result of DEFER.
   // If the result is PROCEED, then 'ReadyToCommitNavigation' will be called
   // with |render_frame_host| and |response_headers| just before calling
-  // |callback|.
+  // |callback|. Should a transfer navigation happen, |transfer_callback| will
+  // be run on the IO thread.
+  // PlzNavigate: transfer navigations are not possible.
   void WillProcessResponse(
       RenderFrameHostImpl* render_frame_host,
       scoped_refptr<net::HttpResponseHeaders> response_headers,
       const SSLStatus& ssl_status,
+      const GlobalRequestID& request_id,
+      bool should_replace_current_entry,
+      bool is_download,
+      bool is_stream,
+      const base::Closure& transfer_callback,
       const ThrottleChecksFinishedCallback& callback);
 
   // Returns the FrameTreeNode this navigation is happening in.
   FrameTreeNode* frame_tree_node() { return frame_tree_node_; }
 
   // Called when the navigation is ready to be committed in
   // |render_frame_host|. This will update the |state_| and inform the
   // delegate.
   void ReadyToCommitNavigation(RenderFrameHostImpl* render_frame_host);
 
   // Called when the navigation was committed in |render_frame_host|. This will
   // update the |state_|.
   void DidCommitNavigation(
       const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
       bool same_page,
       RenderFrameHostImpl* render_frame_host);
 
   // Called during commit. Takes ownership of the embedder's NavigationData
   // instance. This NavigationData may have been cloned prior to being added
   // here.
   void set_navigation_data(std::unique_ptr<NavigationData> navigation_data) {
     navigation_data_ = std::move(navigation_data);
   }
 
   SSLStatus ssl_status() { return ssl_status_; }
 
+  const GlobalRequestID& request_id() const { return request_id_; }

[Charlie Reis, 2016/09/16 21:19:26]

Please comment about the timeline that this is valid.  How soon after the
request is created is it set?  Is it always set, or only for transfers?  (I'm
talking with Rohit about a case that might want to use this.)

[clamy, 2016/09/20 15:57:22]

Done. Added a DCHECK as well. As explained in the todo, this could potentially
be initialized earlier (though there may be some issues in PlzNavigate).

+
+  // Called when the navigation is transferred to a SiteInstance.
+  void TransferToSiteInstance(SiteInstance* site_instance);
+
+  // Called when a RenderFrameHost has been created for the SiteInstance the
+  // navigation is transferred to.
+  void TransferToRenderFrameHost(RenderFrameHostImpl* render_frame_host);
+
  private:
   friend class NavigationHandleImplTest;
 
   // Used to track the state the navigation is currently in.
   enum State {
     INITIAL = 0,
     WILL_SEND_REQUEST,
     DEFERRING_START,
     WILL_REDIRECT_REQUEST,
     DEFERRING_REDIRECT,
@@ skipping 10 matching lines @@
                        bool is_renderer_initiated,
                        bool is_synchronous,
                        bool is_srcdoc,
                        const base::TimeTicks& navigation_start,
                        int pending_nav_entry_id);
 
   NavigationThrottle::ThrottleCheckResult CheckWillStartRequest();
   NavigationThrottle::ThrottleCheckResult CheckWillRedirectRequest();
   NavigationThrottle::ThrottleCheckResult CheckWillProcessResponse();
 
+  // Called when WillProcessResponse checks are done, to find the final
+  // RenderFrameHost for the navigation. Returns true if the navigation should

[Charlie Reis, 2016/09/16 21:19:26]

Can you mention a case when it would return false?  I'm not sure I understand
why this would abort at first glance.  (That sounds more like something
MaybeTransferAndProceed would do.)

[clamy, 2016/09/20 15:57:22]

Updated the comment following the naming change suggested in the .cc file.

+  // proceed.
+  bool FindFinalRenderFrameHost();
+
+  // Check whether the navigation should be transferred. Returns false if the
+  // transfer attempt results in the destruction of this NavigationHandle.
+  bool MaybeTransferAndProceed();
+
   // Helper function to run and reset the |complete_callback_|. This marks the
   // end of a round of NavigationThrottleChecks.
   void RunCompleteCallback(NavigationThrottle::ThrottleCheckResult result);
 
   // Used in tests.
   State state() const { return state_; }
 
   // Populates |throttles_| with the throttles for this navigation.
   void RegisterNavigationThrottles();
 
   // See NavigationHandle for a description of those member variables.
   GURL url_;
   Referrer sanitized_referrer_;
   bool has_user_gesture_;
   ui::PageTransition transition_;
   bool is_external_protocol_;
   net::Error net_error_code_;
   RenderFrameHostImpl* render_frame_host_;
   const bool is_renderer_initiated_;
   bool is_same_page_;
   const bool is_synchronous_;
   const bool is_srcdoc_;
   bool was_redirected_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
 
+  // The original url of the navigation. This may differ from |url_| if the
+  // navigation encounters redirects.
+  const GURL original_url_;
+
   // The HTTP method used for the navigation.
   std::string method_;
 
   // The POST body associated with this navigation.  This will be null for GET
   // and/or other non-POST requests (or if a response to a POST request was a
   // redirect that changed the method to GET - for example 302).
   scoped_refptr<ResourceRequestBodyImpl> resource_request_body_;
 
   // The state the navigation is in.
   State state_;
@@ skipping 21 matching lines @@
   RequestContextType request_context_type_;
 
   // This callback will be run when all throttle checks have been performed.
   ThrottleChecksFinishedCallback complete_callback_;
 
   // Embedder data tied to this navigation.
   std::unique_ptr<NavigationData> navigation_data_;
 
   SSLStatus ssl_status_;
 
+  // The id of the URLRequest tied to this navigation.
+  GlobalRequestID request_id_;
+
+  // Whether the current NavigationEntry should be replaced upon commit.
+  bool should_replace_current_entry_;

[Charlie Reis, 2016/09/16 21:19:26]

I'm curious, why did these become necessary in the new approach?

[clamy, 2016/09/20 15:57:22]

Most of them are data that was contained in the CrossSiteTransferringRequest.
Since I'm removing this class, I need to include them in the NavigationHandle,
which now plays a role very similar to the CrossSiteTransferringRequest.

is_download_ and is_stream_ are needed to check whether we should attempt to
transfer or not.

[Charlie Reis, 2016/09/21 03:31:47]

CrossSiteTransferringRequest only had the GlobalRequestID.  I was curious about
should_replace_current_entry_ and redirect_chain_, but it looks like those used
to be posted from CrossSiteResourceHandler to RFHM::OnCrossSiteResponse, and now
we pass them in from here.  Seems reasonable.

+
+  // The chain of redirects.
+  std::vector<GURL> redirect_chain_;
+
+  // A callback to run on the IO thread if the navigation transfers.
+  base::Closure transfer_callback_;
+
+  // Whether the navigation ended up being a download or a stream.
+  bool is_download_;
+  bool is_stream_;
+
+  base::WeakPtrFactory<NavigationHandleImpl> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(NavigationHandleImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_NAVIGATION_HANDLE_IMPL_H_