Add a NavigationThrottle to the public content/ interface

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 "content/browser/frame_host/navigator_delegate.h"
 #include "net/url_request/redirect_info.h"
 
 namespace content {
 
 // static
 scoped_ptr<NavigationHandleImpl> NavigationHandleImpl::Create(
     const GURL& url,
+    const GURL& validated_url,
     const bool is_main_frame,
     NavigatorDelegate* delegate) {
   return scoped_ptr<NavigationHandleImpl>(
-      new NavigationHandleImpl(url, is_main_frame, delegate));
+      new NavigationHandleImpl(url, validated_url, is_main_frame, delegate));
 }
 
 NavigationHandleImpl::NavigationHandleImpl(const GURL& url,
+                                           const GURL& validated_url,
                                            const bool is_main_frame,
                                            NavigatorDelegate* delegate)
     : url_(url),
+      validated_url_(validated_url),
+      is_main_frame_(is_main_frame),
+      is_post_(false),
+      has_user_gesture_(false),
+      transition_(ui::PAGE_TRANSITION_LINK),
+      is_external_protocol_(false),
       net_error_code_(net::OK),
       state_(DID_START),
-      is_main_frame_(is_main_frame),
       is_transferring_(false),
       delegate_(delegate) {
   delegate_->DidStartNavigation(this);
 }
 
 NavigationHandleImpl::~NavigationHandleImpl() {
   delegate_->DidFinishNavigation(this);
 }
 
 const GURL& NavigationHandleImpl::GetURL() const {
   return url_;
 }
 
+const GURL& NavigationHandleImpl::GetValidatedURL() const {
+  return validated_url_;
+}
+
+bool NavigationHandleImpl::IsInMainFrame() const {
+  return is_main_frame_;
+}
+
+bool NavigationHandleImpl::IsPost() const {
+  DCHECK(state_ != DID_START)
+      << "This accessor should not be called before the request is started.";
+  return is_post_;
+}
+
+const Referrer& NavigationHandleImpl::GetSanitizedReferrer() const {
+  DCHECK(state_ != DID_START)
+      << "This accessor should not be called before the request is started.";
+  return sanitized_referrer_;
+}
+
+bool NavigationHandleImpl::HasUserGesture() const {
+  DCHECK(state_ != DID_START)
+      << "This accessor should not be called before the request is started.";
+  return has_user_gesture_;
+}
+
+ui::PageTransition NavigationHandleImpl::GetPageTransition() const {
+  DCHECK(state_ != DID_START)
+      << "This accessor should not be called before the request is started.";
+  return transition_;
+}
+
+bool NavigationHandleImpl::IsExternalProtocol() const {
+  DCHECK(state_ != DID_START)
+      << "This accessor should not be called before the request is started.";
+  return is_external_protocol_;
+}
+
 net::Error NavigationHandleImpl::GetNetErrorCode() const {
   return net_error_code_;
 }
 
-bool NavigationHandleImpl::IsInMainFrame() const {
-  return is_main_frame_;
-}
-
 bool NavigationHandleImpl::HasCommittedDocument() const {
   return state_ == DID_COMMIT;
 }
 
 bool NavigationHandleImpl::HasCommittedErrorPage() const {
   return state_ == DID_COMMIT_ERROR_PAGE;
 }
 
+void NavigationHandleImpl::RegisterThrottle(
+    scoped_ptr<NavigationThrottle> navigation_throttle) {
+  throttles_.push_back(navigation_throttle.Pass());
+}
+
+NavigationThrottle::ThrottleCheckResult NavigationHandleImpl::WillStartRequest(
+    bool is_post,
+    const Referrer& sanitized_referrer,
+    bool has_user_gesture,
+    ui::PageTransition transition,
+    bool is_external_protocol) {
+  // Update the navigation parameters.
+  is_post_ = is_post;
+  sanitized_referrer_ = sanitized_referrer;
+  has_user_gesture_ = has_user_gesture;
+  transition_ = transition;
+  is_external_protocol_ = is_external_protocol;
+
+  state_ = WILL_SEND_REQUEST;
+
+  // Register the navigation throttles.
+  delegate_->AddNavigationThrottles(this);
+
+  // Have each throttle be notified of the request.
+  for (auto it = throttles_.begin(); it != throttles_.end(); ++it) {
+    NavigationThrottle::ThrottleCheckResult result = (*it)->WillStartRequest();
+    if (result == NavigationThrottle::CANCEL_AND_IGNORE)
+      return NavigationThrottle::CANCEL_AND_IGNORE;
+  }
+  return NavigationThrottle::PROCEED;
+}
+
+NavigationThrottle::ThrottleCheckResult
+NavigationHandleImpl::WillRedirectRequest(const GURL& new_url,
+                                          const GURL& new_validated_url,
+                                          bool new_method_is_post,
+                                          const GURL& new_referrer_url,
+                                          bool new_is_external_protocol) {
+  // Update the navigation parameters.
+  url_ = new_url;
+  validated_url_ = new_validated_url;
+  is_post_ = new_method_is_post;
+  sanitized_referrer_.url = new_referrer_url;
+  sanitized_referrer_ = Referrer::SanitizeForRequest(url_, sanitized_referrer_);
+  is_external_protocol_ = new_is_external_protocol;
+
+  state_ = WILL_REDIRECT_REQUEST;

[nasko, 2015/09/04 00:01:52]

Why did we lose the state update?

[clamy, 2015/09/04 12:59:14]

davidben@ noticed we were not doing anything useful with this state and
suggested we remove it. It's true that we don't use it right now, so I removed
it with the idea of re-adding it later if needed.

+
+  // Have each throttle be notified of the request.
+  for (auto it = throttles_.begin(); it != throttles_.end(); ++it) {
+    NavigationThrottle::ThrottleCheckResult result =
+        (*it)->WillRedirectRequest();
+    if (result == NavigationThrottle::CANCEL_AND_IGNORE)
+      return NavigationThrottle::CANCEL_AND_IGNORE;
+  }
+  return NavigationThrottle::PROCEED;
+}
+
 void NavigationHandleImpl::DidRedirectNavigation(const GURL& new_url) {
   url_ = new_url;
   delegate_->DidRedirectNavigation(this);
 }
 
 void NavigationHandleImpl::DidCommitNavigation() {
   state_ = net_error_code_ == net::OK ? DID_COMMIT : DID_COMMIT_ERROR_PAGE;
   delegate_->DidCommitNavigation(this);
 }
 
 }  // namespace content