NavigationThrottle: allow customization of net::Error when blocking

content/browser/loader/navigation_resource_throttle.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/loader/navigation_resource_throttle.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 30 matching lines @@
 
 // Used in unit tests to transfer all navigations.
 bool g_force_transfer = false;
 
 typedef base::Callback<void(NavigationThrottle::ThrottleCheckResult)>
     UIChecksPerformedCallback;
 
 void SendCheckResultToIOThread(UIChecksPerformedCallback callback,
                                NavigationThrottle::ThrottleCheckResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_NE(result, NavigationThrottle::DEFER);
+  DCHECK_NE(result.action(), NavigationThrottle::DEFER);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, result));
 }
 
 // Returns the NavigationHandle to use for a navigation in the frame specified
 // by |render_process_id| and |render_frame_host_id|. If not found, |callback|
 // will be invoked to cancel the request.
 //
 // Note: in unit test |callback| may be invoked with a value of proceed if no
 // handle is found. This happens when
@@ skipping 275 matching lines @@
 }
 
 void NavigationResourceThrottle::set_force_transfer_for_testing(
     bool force_transfer) {
   g_force_transfer = force_transfer;
 }
 
 void NavigationResourceThrottle::OnUIChecksPerformed(
     NavigationThrottle::ThrottleCheckResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_NE(NavigationThrottle::DEFER, result);
+  DCHECK_NE(NavigationThrottle::DEFER, result.action());
   if (in_cross_site_transition_) {
     on_transfer_done_result_ = result;
     return;
   }
 
-  if (result == NavigationThrottle::CANCEL_AND_IGNORE) {
+  if (result.action() == NavigationThrottle::CANCEL_AND_IGNORE) {
+    DCHECK_EQ(net::ERR_ABORTED, result.net_error_code());
     CancelAndIgnore();
-  } else if (result == NavigationThrottle::CANCEL) {
+  } else if (result.action() == NavigationThrottle::CANCEL) {
+    DCHECK_EQ(net::ERR_ABORTED, result.net_error_code());
     Cancel();
-  } else if (result == NavigationThrottle::BLOCK_REQUEST) {
-    CancelWithError(net::ERR_BLOCKED_BY_CLIENT);
-  } else if (result == NavigationThrottle::BLOCK_RESPONSE) {
+  } else if (result.action() == NavigationThrottle::BLOCK_REQUEST) {
+    DCHECK_NE(net::OK, result.net_error_code());
+    CancelWithError(result.net_error_code());
+  } else if (result.action() == NavigationThrottle::BLOCK_RESPONSE) {
+    DCHECK_NE(net::OK, result.net_error_code());
     // TODO(mkwst): If we cancel the main frame request with anything other than
     // 'net::ERR_ABORTED', we'll trigger some special behavior that might not be
     // desirable here (non-POSTs will reload the page, while POST has some logic
     // around reloading to avoid duplicating actions server-side). For the
     // moment, only child frame navigations should be blocked. If we need to
     // block main frame navigations in the future, we'll need to carefully
     // consider the right thing to do here.
     DCHECK(!ResourceRequestInfo::ForRequest(request_)->IsMainFrame());
-    CancelWithError(net::ERR_BLOCKED_BY_RESPONSE);
+    CancelWithError(result.net_error_code());
   } else {
     Resume();
   }
 }
 
 void NavigationResourceThrottle::InitiateTransfer() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   in_cross_site_transition_ = true;
   ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   ResourceDispatcherHostImpl::Get()->MarkAsTransferredNavigation(
       info->GetGlobalRequestID(),
       base::Bind(&NavigationResourceThrottle::OnTransferComplete,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NavigationResourceThrottle::OnTransferComplete() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(in_cross_site_transition_);
   in_cross_site_transition_ = false;
 
   // If the results of the checks on the UI thread are known, unblock the
   // navigation. Otherwise, wait until the callback has executed.
-  if (on_transfer_done_result_ != NavigationThrottle::DEFER) {
+  if (on_transfer_done_result_.action() != NavigationThrottle::DEFER) {
     OnUIChecksPerformed(on_transfer_done_result_);
     on_transfer_done_result_ = NavigationThrottle::DEFER;
   }
 }
 
 }  // namespace content