NavigationThrottle: allow customization of net::Error when blocking

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/logging.h"
 #include "content/browser/appcache/appcache_navigation_handle.h"
@@ skipping 336 matching lines @@
     result = CheckWillRedirectRequest();
   } else {
     result = CheckWillProcessResponse();
 
     // If the navigation is about to proceed after having been deferred while
     // processing the response, then it's ready to commit. Determine which
     // RenderFrameHost should render the response, based on its site (after any
     // redirects).
     // Note: if MaybeTransferAndProceed returns false, this means that this
     // NavigationHandle was deleted, so return immediately.
-    if (result == NavigationThrottle::PROCEED && !MaybeTransferAndProceed())
+    if (result.action() == NavigationThrottle::PROCEED &&
+        !MaybeTransferAndProceed())
       return;
   }
 
-  if (result != NavigationThrottle::DEFER) {
+  if (result.action() != NavigationThrottle::DEFER) {
     TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                  "Resuming");
     RunCompleteCallback(result);
   }
 }
 
 void NavigationHandleImpl::CancelDeferredNavigation(
     NavigationThrottle::ThrottleCheckResult result) {
   DCHECK(state_ == DEFERRING_START ||
          state_ == DEFERRING_REDIRECT ||
          state_ == DEFERRING_RESPONSE);
-  DCHECK(result == NavigationThrottle::CANCEL_AND_IGNORE ||
-         result == NavigationThrottle::CANCEL);
+  DCHECK(result.action() == NavigationThrottle::CANCEL_AND_IGNORE ||
+         result.action() == NavigationThrottle::CANCEL);
   TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                "CancelDeferredNavigation");
   state_ = CANCELING;
   RunCompleteCallback(result);
 }
 
 void NavigationHandleImpl::RegisterThrottleForTesting(
     std::unique_ptr<NavigationThrottle> navigation_throttle) {
   throttles_.push_back(std::move(navigation_throttle));
 }
@@ skipping 177 matching lines @@
 
   RegisterNavigationThrottles();
 
   if (IsBrowserSideNavigationEnabled())
     navigation_ui_data_ = GetDelegate()->GetNavigationUIData(this);
 
   // Notify each throttle of the request.
   NavigationThrottle::ThrottleCheckResult result = CheckWillStartRequest();
 
   // If the navigation is not deferred, run the callback.
-  if (result != NavigationThrottle::DEFER) {
+  if (result.action() != NavigationThrottle::DEFER) {
     TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
-                                 "StartRequest", "result", result);
+                                 "StartRequest", "result", result.action());
     RunCompleteCallback(result);
   }
 }
 
 void NavigationHandleImpl::WillRedirectRequest(
     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,
@@ skipping 27 matching lines @@
   if (IsSelfReferentialURL()) {
     state_ = CANCELING;
     RunCompleteCallback(NavigationThrottle::CANCEL);
     return;
   }
 
   // Notify each throttle of the request.
   NavigationThrottle::ThrottleCheckResult result = CheckWillRedirectRequest();
 
   // If the navigation is not deferred, run the callback.
-  if (result != NavigationThrottle::DEFER) {
+  if (result.action() != NavigationThrottle::DEFER) {
     TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
-                                 "RedirectRequest", "result", result);
+                                 "RedirectRequest", "result", result.action());
     RunCompleteCallback(result);
   }
 }
 
 void NavigationHandleImpl::WillProcessResponse(
     RenderFrameHostImpl* render_frame_host,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     net::HttpResponseInfo::ConnectionInfo connection_info,
     const SSLStatus& ssl_status,
     const GlobalRequestID& request_id,
@@ skipping 19 matching lines @@
   transfer_callback_ = transfer_callback;
 
   // Notify each throttle of the response.
   NavigationThrottle::ThrottleCheckResult result = CheckWillProcessResponse();
 
   // If the navigation is done processing the response, then it's ready to
   // commit. Determine which RenderFrameHost should render the response, based
   // on its site (after any redirects).
   // Note: if MaybeTransferAndProceed returns false, this means that this
   // NavigationHandle was deleted, so return immediately.
-  if (result == NavigationThrottle::PROCEED && !MaybeTransferAndProceed())
+  if (result.action() == NavigationThrottle::PROCEED &&
+      !MaybeTransferAndProceed())
     return;
 
   // If the navigation is not deferred, run the callback.
-  if (result != NavigationThrottle::DEFER) {
+  if (result.action() != NavigationThrottle::DEFER) {
     TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
-                                 "ProcessResponse", "result", result);
+                                 "ProcessResponse", "result", result.action());
     RunCompleteCallback(result);
   }
 }
 
 void NavigationHandleImpl::ReadyToCommitNavigation(
     RenderFrameHostImpl* render_frame_host) {
   TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                "ReadyToCommitNavigation");
 
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
@@ skipping 62 matching lines @@
 NavigationHandleImpl::CheckWillStartRequest() {
   DCHECK(state_ == WILL_SEND_REQUEST || state_ == DEFERRING_START);
   DCHECK(state_ != WILL_SEND_REQUEST || next_index_ == 0);
   DCHECK(state_ != DEFERRING_START || next_index_ != 0);
   for (size_t i = next_index_; i < throttles_.size(); ++i) {
     NavigationThrottle::ThrottleCheckResult result =
         throttles_[i]->WillStartRequest();
     TRACE_EVENT_ASYNC_STEP_INTO0(
         "navigation", "NavigationHandle", this,
         base::StringPrintf("CheckWillStartRequest: %s: %d",
-                           throttles_[i]->GetNameForLogging(), result));
-    switch (result) {
+                           throttles_[i]->GetNameForLogging(),
+                           result.action()));
+    switch (result.action()) {
       case NavigationThrottle::PROCEED:
         continue;
 
       case NavigationThrottle::BLOCK_REQUEST:
       case NavigationThrottle::CANCEL:
       case NavigationThrottle::CANCEL_AND_IGNORE:
         state_ = CANCELING;
         return result;
 
       case NavigationThrottle::DEFER:
@@ skipping 16 matching lines @@
   DCHECK(state_ == WILL_REDIRECT_REQUEST || state_ == DEFERRING_REDIRECT);
   DCHECK(state_ != WILL_REDIRECT_REQUEST || next_index_ == 0);
   DCHECK(state_ != DEFERRING_REDIRECT || next_index_ != 0);
 
   for (size_t i = next_index_; i < throttles_.size(); ++i) {
     NavigationThrottle::ThrottleCheckResult result =
         throttles_[i]->WillRedirectRequest();
     TRACE_EVENT_ASYNC_STEP_INTO0(
         "navigation", "NavigationHandle", this,
         base::StringPrintf("CheckWillRedirectRequest: %s: %d",
-                           throttles_[i]->GetNameForLogging(), result));
-    switch (result) {
+                           throttles_[i]->GetNameForLogging(),
+                           result.action()));
+    switch (result.action()) {
       case NavigationThrottle::PROCEED:
         continue;
 
       case NavigationThrottle::BLOCK_REQUEST:
         CHECK(IsBrowserSideNavigationEnabled())
             << "BLOCK_REQUEST must not be used on redirect without PlzNavigate";
       case NavigationThrottle::CANCEL:
       case NavigationThrottle::CANCEL_AND_IGNORE:
         state_ = CANCELING;
         return result;
@@ skipping 22 matching lines @@
   DCHECK(state_ == WILL_PROCESS_RESPONSE || state_ == DEFERRING_RESPONSE);
   DCHECK(state_ != WILL_PROCESS_RESPONSE || next_index_ == 0);
   DCHECK(state_ != DEFERRING_RESPONSE || next_index_ != 0);
 
   for (size_t i = next_index_; i < throttles_.size(); ++i) {
     NavigationThrottle::ThrottleCheckResult result =
         throttles_[i]->WillProcessResponse();
     TRACE_EVENT_ASYNC_STEP_INTO0(
         "navigation", "NavigationHandle", this,
         base::StringPrintf("CheckWillProcessResponse: %s: %d",
-                           throttles_[i]->GetNameForLogging(), result));
-    switch (result) {
+                           throttles_[i]->GetNameForLogging(),
+                           result.action()));
+    switch (result.action()) {
       case NavigationThrottle::PROCEED:
         continue;
 
       case NavigationThrottle::CANCEL:
       case NavigationThrottle::CANCEL_AND_IGNORE:
       case NavigationThrottle::BLOCK_RESPONSE:
         state_ = CANCELING;
         return result;
 
       case NavigationThrottle::DEFER:
@@ skipping 99 matching lines @@
                                  transition_, should_replace_current_entry_);
     if (!weak_self)
       return false;
   }
 
   return true;
 }
 
 void NavigationHandleImpl::RunCompleteCallback(
     NavigationThrottle::ThrottleCheckResult result) {
-  DCHECK(result != NavigationThrottle::DEFER);
+  DCHECK(result.action() != NavigationThrottle::DEFER);
 
   ThrottleChecksFinishedCallback callback = complete_callback_;
   complete_callback_.Reset();
 
   if (!complete_callback_for_testing_.is_null()) {
     complete_callback_for_testing_.Run(result);
     complete_callback_for_testing_.Reset();
   }
 
   if (!callback.is_null())
@@ skipping 80 matching lines @@
     if (node->current_url().EqualsIgnoringRef(url_)) {
       if (found_self_reference)
         return true;
       found_self_reference = true;
     }
   }
   return false;
 }
 
 }  // namespace content