NavigationThrottle: allow customization of net::Error when blocking

content/browser/frame_host/mixed_content_navigation_throttle.cc

 // Copyright 2017 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/mixed_content_navigation_throttle.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/render_frame_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/origin_util.h"
 #include "content/public/common/web_preferences.h"
 #include "net/base/url_util.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 #include "url/url_constants.h"
 #include "url/url_util.h"
 
+namespace content {
+
 namespace {
 
-using namespace content;
-
 // Should return the same value as SchemeRegistry::shouldTreatURLSchemeAsSecure.
 bool IsSecureScheme(const std::string& scheme) {
   return base::ContainsValue(url::GetSecureSchemes(), scheme);
 }
 
 // Should return the same value as SecurityOrigin::isLocal and
 // SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled.
 bool ShouldTreatURLSchemeAsCORSEnabled(const GURL& url) {
   return base::ContainsValue(url::GetCORSEnabledSchemes(), url.scheme());
 }
 
 // Should return the same value as SecurityOrigin::isSecure.
 // TODO(carlosk): secure origin checks don't match between content and Blink
-// hence this implementation here instead of a direct call to IsOriginSecure (in
-// origin_util.cc). See https://crbug.com/629059.
-bool IsOriginSecure(const GURL& url) {
+// hence this implementation here instead of a direct call to
+// content::IsOriginSecure (in origin_util.cc). See https://crbug.com/629059.
+bool IsSecureOriginForMixedContent(const GURL& url) {
   if (IsSecureScheme(url.scheme()))
     return true;
 
   if (url.SchemeIsFileSystem() || url.SchemeIsBlob()) {
     // Should use inner URL.
     url::Origin origin(url);
     if (IsSecureScheme(origin.scheme()))
       return true;
   }
 
   return IsOriginWhiteListedTrustworthy(url::Origin(url));
 }
 
 // Should return the same value as the resource URL checks assigned to
 // |isAllowed| made inside MixedContentChecker::isMixedContent.
 bool IsUrlPotentiallySecure(const GURL& url) {
   // blob: and filesystem: URLs never hit the network, and access is restricted
   // to same-origin contexts, so they are not blocked.
-  bool is_secure =
-      url.SchemeIs(url::kBlobScheme) || url.SchemeIs(url::kFileSystemScheme) ||
-      IsOriginSecure(url) || IsPotentiallyTrustworthyOrigin(url::Origin(url));
+  bool is_secure = url.SchemeIs(url::kBlobScheme) ||
+                   url.SchemeIs(url::kFileSystemScheme) ||
+                   IsSecureOriginForMixedContent(url) ||
+                   IsPotentiallyTrustworthyOrigin(url::Origin(url));
 
   // TODO(mkwst): Remove this once the following draft is implemented:
   // https://tools.ietf.org/html/draft-west-let-localhost-be-localhost-03. See:
   // https://crbug.com/691930.
   if (is_secure && url.SchemeIs(url::kHttpScheme) &&
       net::IsLocalHostname(url.HostNoBrackets(), nullptr)) {
     is_secure = false;
   }
 
   return is_secure;
@@ skipping 22 matching lines @@
   params.request_context_type = navigation_handle->request_context_type();
   params.was_allowed = was_allowed;
   params.had_redirect = for_redirect;
   params.source_location = navigation_handle->source_location();
 
   rfh->Send(new FrameMsg_MixedContentFound(rfh->GetRoutingID(), params));
 }
 
 }  // namespace
 
-namespace content {
-
 // static
 std::unique_ptr<NavigationThrottle>
 MixedContentNavigationThrottle::CreateThrottleForNavigation(
     NavigationHandle* navigation_handle) {
   if (IsBrowserSideNavigationEnabled())
     return base::WrapUnique(
         new MixedContentNavigationThrottle(navigation_handle));
   return nullptr;
 }
 
 MixedContentNavigationThrottle::MixedContentNavigationThrottle(
     NavigationHandle* navigation_handle)
     : NavigationThrottle(navigation_handle) {
   DCHECK(IsBrowserSideNavigationEnabled());
 }
 
 MixedContentNavigationThrottle::~MixedContentNavigationThrottle() {}
 
-ThrottleCheckResult MixedContentNavigationThrottle::WillStartRequest() {
+NavigationThrottle::ThrottleCheckResult
+MixedContentNavigationThrottle::WillStartRequest() {
   bool should_block = ShouldBlockNavigation(false);
-  return should_block ? ThrottleCheckResult::CANCEL
-                      : ThrottleCheckResult::PROCEED;
+  return should_block ? CANCEL : PROCEED;
 }
 
-ThrottleCheckResult MixedContentNavigationThrottle::WillRedirectRequest() {
+NavigationThrottle::ThrottleCheckResult
+MixedContentNavigationThrottle::WillRedirectRequest() {
   // Upon redirects the same checks are to be executed as for requests.
   bool should_block = ShouldBlockNavigation(true);
-  return should_block ? ThrottleCheckResult::CANCEL
-                      : ThrottleCheckResult::PROCEED;
+  return should_block ? CANCEL : PROCEED;
 }
 
-ThrottleCheckResult MixedContentNavigationThrottle::WillProcessResponse() {
+NavigationThrottle::ThrottleCheckResult
+MixedContentNavigationThrottle::WillProcessResponse() {
   // TODO(carlosk): At this point we are about to process the request response.
   // So if we ever need to, here/now it is a good moment to check for the final
   // attained security level of the connection. For instance, does it use an
   // outdated protocol? The implementation should be based off
   // MixedContentChecker::handleCertificateError. See https://crbug.com/576270.
-  return ThrottleCheckResult::PROCEED;
+  return PROCEED;
 }
 
 const char* MixedContentNavigationThrottle::GetNameForLogging() {
   return "MixedContentNavigationThrottle";
 }
 
 // Based off of MixedContentChecker::shouldBlockFetch.
 bool MixedContentNavigationThrottle::ShouldBlockNavigation(bool for_redirect) {
   NavigationHandleImpl* handle_impl =
       static_cast<NavigationHandleImpl*>(navigation_handle());
@@ skipping 127 matching lines @@
   // MixedContentChecker::inWhichFrameIs.
   if (mixed_content_node) {
     // We're currently only checking for mixed content in `https://*` contexts.
     // What about other "secure" contexts the SchemeRegistry knows about? We'll
     // use this method to measure the occurrence of non-webby mixed content to
     // make sure we're not breaking the world without realizing it.
     if (mixed_content_node->current_origin().scheme() != url::kHttpsScheme) {
       mixed_content_features_.insert(
           MIXED_CONTENT_IN_NON_HTTPS_FRAME_THAT_RESTRICTS_MIXED_CONTENT);
     }
-  } else if (!IsOriginSecure(url) &&
+  } else if (!IsSecureOriginForMixedContent(url) &&
              (IsSecureScheme(root->current_origin().scheme()) ||
               IsSecureScheme(parent->current_origin().scheme()))) {
     mixed_content_features_.insert(
         MIXED_CONTENT_IN_SECURE_FRAME_THAT_DOES_NOT_RESTRICT_MIXED_CONTENT);
   }
   return mixed_content_node;
 }
 
 void MixedContentNavigationThrottle::MaybeSendBlinkFeatureUsageReport() {
   if (!mixed_content_features_.empty()) {
@@ skipping 50 matching lines @@
 // static
 bool MixedContentNavigationThrottle::IsMixedContentForTesting(
     const GURL& origin_url,
     const GURL& url) {
   const url::Origin origin(origin_url);
   return !IsUrlPotentiallySecure(url) &&
          DoesOriginSchemeRestrictMixedContent(origin);
 }
 
 }  // namespace content