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/common/request_context_type.h"
 #include "content/public/common/ssl_status.h"
 #include "url/gurl.h"
 
 struct FrameHostMsg_DidCommitProvisionalLoad_Params;
 
 namespace content {
 
@@ skipping 115 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 22 matching lines @@
       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|.
+  // Should a transfer navigation happen, |transfer_callback| will be run on

[nasko, 2016/09/08 00:35:36]

nit: Move to previous line.

[clamy, 2016/09/09 15:06:41]

Done.

+  // 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);
 
@@ skipping 11 matching lines @@
 
   // 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_; }
+
+  // Called when the navigation is transferred to a RenderFrameHost.
+  void TransferredToRenderFrameHost(RenderFrameHostImpl* render_frame_host);

[nasko, 2016/09/08 23:45:39]

The name and the comment implies that the transfer has happened, being past
tense. If I understand it correctly, we call this when we get the response from
the server and are trying to decide whether to transfer or not. When we pick a
different RenderFrameHost to transfer to, this is when we call it. Maybe as
simple as renaming it to TransferToRenderFrameHost, which indicates we want to
transfer to it going forward.

[clamy, 2016/09/09 15:06:41]

Done.

+
  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
+  // proceed.
+  bool GetFinalRenderFrameHost();

[nasko, 2016/09/08 23:45:39]

A GetType method should return Type, not bool. Let's try to find a better name
for this method. 

[clamy, 2016/09/09 15:06:41]

How about FindFinaleFrameHost?

[nasko, 2016/09/09 23:30:27]

sgtm

+
+  // Check whether the navigation should be transferred. Returns false if the
+  // transfer attempt results in the destruction of this NavigationHandle.
+  bool CheckForTransfer();

[nasko, 2016/09/08 23:45:39]

A bool return value from CheckForTransfer reads to me that when returning true
it needs to transfer. Maybe the name of the method should be changed to
something else. 

[clamy, 2016/09/09 15:06:41]

How about MaybeTransferAndProceed? It's not great (so suggestions are welcome),
but I think it conveys better the idea that you should not proceed if you get
false.

[nasko, 2016/09/09 23:30:27]

I think it is definitely better. If I think of anything else, I'll propose it. I
also bet Charlie will have good input on the names of those methods.

+
   // 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_;
+
+  // 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_