Reland "Merge of 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 <string>
 
 #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 NavigationUIData;
 class NavigatorDelegate;
 class ResourceRequestBodyImpl;
 class ServiceWorkerContextWrapper;
 class ServiceWorkerNavigationHandle;
+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 171 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_; }
 
+  // This is valid after the network response has started.
+  // TODO(clamy): See if this can be initialized earlier if needed by
+  // non-transfer code. There may be some issues in PlzNavigate, where
+  // WillStartRequest will be called before starting a request on the IO thread.
+  const GlobalRequestID& request_id() const {
+    DCHECK_GE(state_, WILL_PROCESS_RESPONSE);
+    return request_id_;
+  }
+
+  // Called when the navigation is transferred to a different renderer.
+  void Transfer();
+
   NavigationUIData* navigation_ui_data() const {
     return navigation_ui_data_.get();
   }
 
  private:
   friend class NavigationHandleImplTest;
 
   // Used to track the state the navigation is currently in.
   enum State {
     INITIAL = 0,
@@ skipping 15 matching lines @@
                        bool is_synchronous,
                        bool is_srcdoc,
                        const base::TimeTicks& navigation_start,
                        int pending_nav_entry_id,
                        bool started_from_context_menu);
 
   NavigationThrottle::ThrottleCheckResult CheckWillStartRequest();
   NavigationThrottle::ThrottleCheckResult CheckWillRedirectRequest();
   NavigationThrottle::ThrottleCheckResult CheckWillProcessResponse();
 
+  // Called when WillProcessResponse checks are done, to find the final
+  // RenderFrameHost for the navigation. Checks whether the navigation should be
+  // transferred. Returns false if the transfer attempt results in the
+  // destruction of this NavigationHandle and the navigation should no longer
+  // proceed. This can happen when the RenderFrameHostManager determines a
+  // transfer is needed, but WebContentsDelegate::ShouldTransferNavigation
+  // returns false.
+  bool MaybeTransferAndProceed();
+
+  // Helper method for MaybeTransferAndProceed. Returns false if the transfer
+  // attempt results in the destruction of this NavigationHandle.
+  bool MaybeTransferAndProceedInternal();
+
   // 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 30 matching lines @@
 
   // Embedder data from the IO thread tied to this navigation.
   std::unique_ptr<NavigationData> navigation_data_;
 
   // PlzNavigate
   // Embedder data from the UI thread tied to this navigation.
   std::unique_ptr<NavigationUIData> navigation_ui_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_;
+
   // False by default unless the navigation started within a context menu.
   bool started_from_context_menu_;
 
+  base::WeakPtrFactory<NavigationHandleImpl> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(NavigationHandleImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_NAVIGATION_HANDLE_IMPL_H_