NavigationThrottle: allow customization of net::Error when blocking

content/public/browser/navigation_throttle.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_PUBLIC_BROWSER_NAVIGATION_THROTTLE_H_
 #define CONTENT_PUBLIC_BROWSER_NAVIGATION_THROTTLE_H_
 
 #include "content/common/content_export.h"
+#include "net/base/net_errors.h"
 
 namespace content {
 class NavigationHandle;
 
 // A NavigationThrottle tracks and allows interaction with a navigation on the
 // UI thread.
 class CONTENT_EXPORT NavigationThrottle {
  public:
-  // This is returned to the NavigationHandle to allow the navigation to
-  // proceed, or to cancel it.
-  enum ThrottleCheckResult {
+  // Represents what a NavigationThrottle can decide to do to a navigation. Note
+  // that this enum is implicitly convertable to ThrottleCheckResult.
+  enum ThrottleAction {
     // The navigation proceeds uninterrupted.
     PROCEED,
 
     // Defers the navigation until the NavigationThrottle calls
-    // NavigationHandle::Resume or NavigationHandle::CancelDeferredRequest.
-    // If the NavigationHandle is destroyed while the navigation is deferred,
-    // the navigation will be canceled in the network stack.
+    // NavigationHandle::Resume or NavigationHandle::CancelDeferredRequest. If
+    // the NavigationHandle is destroyed while the navigation is deferred, the
+    // navigation will be canceled in the network stack.
     DEFER,
 
     // Cancels the navigation.
     CANCEL,
 
-    // Cancels the navigation and makes the requester of the navigation acts
+    // Cancels the navigation and makes the requester of the navigation act
     // like the request was never made.
     CANCEL_AND_IGNORE,
 
     // Blocks a navigation due to rules asserted before the request is made.
     // This can only be returned from WillStartRequest and also from
     // WillRedirectRequest when PlzNavigate is enabled. This will result in an
-    // error page for net::ERR_BLOCKED_BY_CLIENT being loaded in the frame that
-    // is navigated.
+    // default net_error code of net::ERR_BLOCKED_BY_CLIENT being loaded in
+    // the frame that is navigated.
     BLOCK_REQUEST,
 
     // Blocks a navigation due to rules asserted by a response (for instance,
     // embedding restrictions like 'X-Frame-Options'). This result will only
     // be returned from WillProcessResponse.
     BLOCK_RESPONSE,
   };
 
+  // ThrottleCheckResult, the return value for NavigationThrottle decision
+  // methods, is a ThrottleAction value with an attached net::Error.
+  //
+  // ThrottleCheckResult is implicitly convertible from ThrottleAction, allowing
+  // all of the following examples to work:
+  //
+  //   ThrottleCheckResult WillStartRequest() override {
+  //      // Uses default error for PROCEED (net::OK).
+  //      return PROCEED;
+  //   }
+  //
+  //   ThrottleCheckResult WillStartRequest() override {
+  //      // Uses default error for BLOCK_REQUEST (net::ERR_BLOCKED_BY_CLIENT).
+  //      return BLOCK_REQUEST;
+  //   }
+  //
+  //   ThrottleCheckResult WillStartRequest() override {
+  //      // Identical to previous example (net::ERR_BLOCKED_BY_CLIENT)
+  //      return {BLOCK_REQUEST};
+  //   }
+  //
+  //   ThrottleCheckResult WillStartRequest() override {
+  //      // Uses a custom error code of ERR_FILE_NOT_FOUND.
+  //      return {BLOCK_REQUEST, net::ERR_FILE_NOT_FOUND};
+  //   }
+  class CONTENT_EXPORT ThrottleCheckResult {
+   public:
+    // Construct with just a ThrottleAction, using the default net::Error for
+    // that action.
+    constexpr ThrottleCheckResult(ThrottleAction action)
+        : ThrottleCheckResult(action, GetDefaultNetErrorCode(action)) {}
+
+    // Construct with an action and an error.
+    constexpr ThrottleCheckResult(ThrottleAction action,
+                                  net::Error net_error_code)
+        : action_(action), net_error_code_(net_error_code) {}
+
+    ThrottleAction action() { return action_; }
+    net::Error net_error_code() { return net_error_code_; }
+
+    bool operator==(const NavigationThrottle::ThrottleCheckResult& rhs) const;
+    bool operator!=(const NavigationThrottle::ThrottleCheckResult& rhs) const;
+
+   private:
+    static constexpr net::Error GetDefaultNetErrorCode(ThrottleAction action) {
+      return (action == PROCEED || action == DEFER)
+                 ? net::OK
+                 : ((action == CANCEL || action == CANCEL_AND_IGNORE)
+                        ? net::ERR_ABORTED
+                        : (action == BLOCK_REQUEST
+                               ? net::ERR_BLOCKED_BY_CLIENT
+                               : (action == BLOCK_RESPONSE
+                                      ? net::ERR_BLOCKED_BY_RESPONSE
+                                      : net::ERR_FAILED)));
+    }
+    ThrottleAction action_ : 16;
+    net::Error net_error_code_ : 16;

[nasko, 2017/05/11 18:05:44]

Chatting with dcheng@ over why we want to pack these, he pointed out that MSVC
might not be honoring that.

+  };
+
   NavigationThrottle(NavigationHandle* navigation_handle);
   virtual ~NavigationThrottle();
 
   // Called when a network request is about to be made for this navigation.
   //
   // The implementer is responsible for ensuring that the WebContents this
   // throttle is associated with remain alive during the duration of this
   // method. Failing to do so will result in use-after-free bugs. Should the
   // implementer need to destroy the WebContents, it should return CANCEL,
   // CANCEL_AND_IGNORE or DEFER and perform the destruction asynchronously.
@@ skipping 11 matching lines @@
   // Called when a response's headers and metadata are available.
   //
   // The implementer is responsible for ensuring that the WebContents this
   // throttle is associated with remain alive during the duration of this
   // method. Failing to do so will result in use-after-free bugs. Should the
   // implementer need to destroy the WebContents, it should return CANCEL,
   // CANCEL_AND_IGNORE, or BLOCK_RESPONSE and perform the destruction
   // asynchronously.
   virtual ThrottleCheckResult WillProcessResponse();
 
-  // Returns the name of the throttle for logging purposes. It must not return
-  // nullptr.
+  // Returns the name of the throttle for logging purposes. It must not
+  // return nullptr.
   virtual const char* GetNameForLogging() = 0;
 
   // The NavigationHandle that is tracking the information related to this
   // navigation.
   NavigationHandle* navigation_handle() const { return navigation_handle_; }
 
  private:
   NavigationHandle* navigation_handle_;
 };
 
+#if defined(UNIT_TEST)
+// Test-only operator== to enable assertions like:
+//   EXPECT_EQ(NavigationThrottle::PROCEED, throttle->WillProcessResponse())
+inline bool operator==(NavigationThrottle::ThrottleAction lhs,
+                       const NavigationThrottle::ThrottleCheckResult& rhs) {
+  return NavigationThrottle::ThrottleCheckResult(lhs) == rhs;
+}
+#endif
+
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_NAVIGATION_THROTTLE_H_