Convert HistoryTabHelper to use the new navigation callbacks.

content/browser/frame_host/navigation_handle_impl.cc

 // 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.
 
 #include "content/browser/frame_host/navigation_handle_impl.h"
 
 #include <iterator>
 
 #include "base/debug/dump_without_crashing.h"
 #include "base/logging.h"
@@ skipping 41 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get())
     rdh->CancelRequest(id.child_id, id.request_id);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<NavigationHandleImpl> NavigationHandleImpl::Create(
     const GURL& url,
+    const std::vector<GURL>& redirect_chain,
     FrameTreeNode* frame_tree_node,
     bool is_renderer_initiated,
     bool is_same_page,
     const base::TimeTicks& navigation_start,
     int pending_nav_entry_id,
     bool started_from_context_menu) {
   return std::unique_ptr<NavigationHandleImpl>(new NavigationHandleImpl(
-      url, frame_tree_node, is_renderer_initiated, is_same_page,
+      url, redirect_chain, frame_tree_node, is_renderer_initiated, is_same_page,
       navigation_start, pending_nav_entry_id,
       started_from_context_menu));
 }
 
 NavigationHandleImpl::NavigationHandleImpl(
     const GURL& url,
+    const std::vector<GURL>& redirect_chain,
     FrameTreeNode* frame_tree_node,
     bool is_renderer_initiated,
     bool is_same_page,
     const base::TimeTicks& navigation_start,
     int pending_nav_entry_id,
     bool started_from_context_menu)
     : url_(url),
       has_user_gesture_(false),
       transition_(ui::PAGE_TRANSITION_LINK),
       is_external_protocol_(false),
       net_error_code_(net::OK),
       render_frame_host_(nullptr),
       is_renderer_initiated_(is_renderer_initiated),
       is_same_page_(is_same_page),
       was_redirected_(false),
+      did_replace_entry_(false),
+      should_update_history_(false),
       connection_info_(net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN),
       original_url_(url),
       state_(INITIAL),
       is_transferring_(false),
       frame_tree_node_(frame_tree_node),
       next_index_(0),
       navigation_start_(navigation_start),
       pending_nav_entry_id_(pending_nav_entry_id),
       request_context_type_(REQUEST_CONTEXT_TYPE_UNSPECIFIED),
       mixed_content_context_type_(blink::WebMixedContentContextType::Blockable),
       should_replace_current_entry_(false),
+      redirect_chain_(redirect_chain),
       is_download_(false),
       is_stream_(false),
       started_from_context_menu_(started_from_context_menu),
       reload_type_(ReloadType::NONE),
       weak_factory_(this) {
   DCHECK(!navigation_start.is_null());
-  redirect_chain_.push_back(url);
+  if (redirect_chain_.empty())
+    redirect_chain_.push_back(url);
 
   starting_site_instance_ =
       frame_tree_node_->current_frame_host()->GetSiteInstance();
 
   if (pending_nav_entry_id_) {
     NavigationControllerImpl* nav_controller =
         static_cast<NavigationControllerImpl*>(
             frame_tree_node_->navigator()->GetController());
     NavigationEntryImpl* nav_entry =
         nav_controller->GetEntryWithUniqueID(pending_nav_entry_id_);
@@ skipping 151 matching lines @@
 }
 
 bool NavigationHandleImpl::HasCommitted() {
   return state_ == DID_COMMIT || state_ == DID_COMMIT_ERROR_PAGE;
 }
 
 bool NavigationHandleImpl::IsErrorPage() {
   return state_ == DID_COMMIT_ERROR_PAGE;
 }
 
+bool NavigationHandleImpl::DidReplaceEntry() {
+  DCHECK(state_ == DID_COMMIT || state_ == DID_COMMIT_ERROR_PAGE);
+  return did_replace_entry_;
+}
+
+bool NavigationHandleImpl::ShouldUpdateHistory() {
+  DCHECK(state_ == DID_COMMIT || state_ == DID_COMMIT_ERROR_PAGE);
+  return should_update_history_;
+}
+
 void NavigationHandleImpl::Resume() {
   if (state_ != DEFERRING_START && state_ != DEFERRING_REDIRECT &&
       state_ != DEFERRING_RESPONSE) {
     return;
   }
 
   NavigationThrottle::ThrottleCheckResult result = NavigationThrottle::DEFER;
   if (state_ == DEFERRING_START) {
     result = CheckWillStartRequest();
   } else if (state_ == DEFERRING_REDIRECT) {
@@ skipping 167 matching lines @@
     RequestContextType request_context_type,
     blink::WebMixedContentContextType mixed_content_context_type,
     const ThrottleChecksFinishedCallback& callback) {
   if (method != "POST")
     DCHECK(!resource_request_body);
 
   // Update the navigation parameters.
   method_ = method;
   if (method_ == "POST")
     resource_request_body_ = resource_request_body;
-  sanitized_referrer_ = sanitized_referrer;
   has_user_gesture_ = has_user_gesture;
   transition_ = transition;
+  if (transition_ & ui::PAGE_TRANSITION_CLIENT_REDIRECT) {

[jam, 2017/01/31 20:24:23]

this mirrors the logic in RenderFrameImpl::SendDidCommitProvisionalLoad, which
would go away once we switch to the new API

+    // If the page contained a client redirect (meta refresh, document.loc...),

[nasko, 2017/02/06 19:07:52]

nit: Don't use ..., spell out the whole word.

+    // set the referrer appropriately.
+    sanitized_referrer_ =
+        Referrer(redirect_chain_[0], sanitized_referrer.policy);
+  } else {
+    sanitized_referrer_ = sanitized_referrer;
+  }
   is_external_protocol_ = is_external_protocol;
   request_context_type_ = request_context_type;
   mixed_content_context_type_ = mixed_content_context_type;
   state_ = WILL_SEND_REQUEST;
   complete_callback_ = callback;
 
   RegisterNavigationThrottles();
 
   if (IsBrowserSideNavigationEnabled())
     navigation_ui_data_ = GetDelegate()->GetNavigationUIData(this);
@@ skipping 10 matching lines @@
     const GURL& new_url,
     const std::string& new_method,
     const GURL& new_referrer_url,
     bool new_is_external_protocol,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     net::HttpResponseInfo::ConnectionInfo connection_info,
     const ThrottleChecksFinishedCallback& callback) {
   // Update the navigation parameters.
   url_ = new_url;
   method_ = new_method;
-  sanitized_referrer_.url = new_referrer_url;
-  sanitized_referrer_ = Referrer::SanitizeForRequest(url_, sanitized_referrer_);
+
+  if (!(transition_ & ui::PAGE_TRANSITION_CLIENT_REDIRECT)) {
+    sanitized_referrer_.url = new_referrer_url;
+    sanitized_referrer_ =
+        Referrer::SanitizeForRequest(url_, sanitized_referrer_);
+  }
+
   is_external_protocol_ = new_is_external_protocol;
   response_headers_ = response_headers;
   connection_info_ = connection_info;
   was_redirected_ = true;
   redirect_chain_.push_back(new_url);
   if (new_method != "POST")
     resource_request_body_ = nullptr;
 
   state_ = WILL_REDIRECT_REQUEST;
   complete_callback_ = callback;
@@ skipping 51 matching lines @@
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
   render_frame_host_ = render_frame_host;
   state_ = READY_TO_COMMIT;
 
   if (!IsRendererDebugURL(url_))
     GetDelegate()->ReadyToCommitNavigation(this);
 }
 
 void NavigationHandleImpl::DidCommitNavigation(
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
-    bool same_page,
+    bool did_replace_entry,
     RenderFrameHostImpl* render_frame_host) {
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
   DCHECK_EQ(frame_tree_node_, render_frame_host->frame_tree_node());
   CHECK_EQ(url_, params.url);
 
+  did_replace_entry_ = did_replace_entry;
   method_ = params.method;
   has_user_gesture_ = (params.gesture == NavigationGestureUser);
   transition_ = params.transition;
+  should_update_history_ = params.should_update_history;
   render_frame_host_ = render_frame_host;
 
   // If an error page reloads, net_error_code might be 200 but we still want to
   // count it as an error page.
   if (params.base_url.spec() == kUnreachableWebDataURL ||
       net_error_code_ != net::OK) {
     state_ = DID_COMMIT_ERROR_PAGE;
   } else {
     state_ = DID_COMMIT;
   }
@@ skipping 242 matching lines @@
       content::AncestorThrottle::MaybeCreateThrottleFor(this);
   if (ancestor_throttle)
     throttles_.push_back(std::move(ancestor_throttle));
 
   throttles_.insert(throttles_.begin(),
                     std::make_move_iterator(throttles_to_register.begin()),
                     std::make_move_iterator(throttles_to_register.end()));
 }
 
 }  // namespace content