Collapse images disallowed by the Safe Browsing Subresource Filter.

third_party/WebKit/Source/core/loader/FrameFetchContext.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 562 matching lines @@
   } else {
     message = "Unsafe attempt to load URL " + url.elidedString() +
               " from frame with URL " + m_document->url().elidedString() +
               ". Domains, protocols and ports must match.\n";
   }
 
   frame()->document()->addConsoleMessage(ConsoleMessage::create(
       SecurityMessageSource, ErrorMessageLevel, message));
 }
 
-bool FrameFetchContext::canRequest(
+ResourceRequestBlockedReason FrameFetchContext::canRequest(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options,
     bool forPreload,
     FetchRequest::OriginRestriction originRestriction) const {
-  ResourceRequestBlockedReason reason =
+  ResourceRequestBlockedReason blockedReason =
       canRequestInternal(type, resourceRequest, url, options, forPreload,
                          originRestriction, resourceRequest.redirectStatus());
-  if (reason != ResourceRequestBlockedReasonNone) {
-    if (!forPreload) {
-      InspectorInstrumentation::didBlockRequest(frame(), resourceRequest,
-                                                masterDocumentLoader(),
-                                                options.initiatorInfo, reason);
-    }
-    return false;
+  if (blockedReason != ResourceRequestBlockedReason::None && !forPreload) {
+    InspectorInstrumentation::didBlockRequest(
+        frame(), resourceRequest, masterDocumentLoader(), options.initiatorInfo,
+        blockedReason);
   }
-  return true;
+  return blockedReason;
 }
 
-bool FrameFetchContext::allowResponse(
+ResourceRequestBlockedReason FrameFetchContext::allowResponse(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options) const {
-  ResourceRequestBlockedReason reason =
+  ResourceRequestBlockedReason blockedReason =
       canRequestInternal(type, resourceRequest, url, options, false,
                          FetchRequest::UseDefaultOriginRestrictionForType,
                          RedirectStatus::FollowedRedirect);
-  if (reason != ResourceRequestBlockedReasonNone) {
-    InspectorInstrumentation::didBlockRequest(frame(), resourceRequest,
-                                              masterDocumentLoader(),
-                                              options.initiatorInfo, reason);
-    return false;
+  if (blockedReason != ResourceRequestBlockedReason::None) {
+    InspectorInstrumentation::didBlockRequest(
+        frame(), resourceRequest, masterDocumentLoader(), options.initiatorInfo,
+        blockedReason);
   }
-  return true;
+  return blockedReason;
 }
 
 ResourceRequestBlockedReason FrameFetchContext::canRequestInternal(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options,
     bool forPreload,
     FetchRequest::OriginRestriction originRestriction,
     ResourceRequest::RedirectStatus redirectStatus) const {
   if (InspectorInstrumentation::shouldBlockRequest(frame(), resourceRequest))
-    return ResourceRequestBlockedReasonInspector;
+    return ResourceRequestBlockedReason::Inspector;
 
   SecurityOrigin* securityOrigin = options.securityOrigin.get();
   if (!securityOrigin && m_document)
     securityOrigin = m_document->getSecurityOrigin();
 
   if (originRestriction != FetchRequest::NoOriginRestriction &&
       securityOrigin && !securityOrigin->canDisplay(url)) {
     if (!forPreload)
       FrameLoader::reportLocalLoadFailed(frame(), url.elidedString());
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::requestResource URL was not "
                                  "allowed by SecurityOrigin::canDisplay";
-    return ResourceRequestBlockedReasonOther;
+    return ResourceRequestBlockedReason::Other;
   }
 
   // Some types of resources can be loaded only from the same origin. Other
   // types of resources, like Images, Scripts, and CSS, can be loaded from
   // any URL.
   switch (type) {
     case Resource::MainResource:
     case Resource::Image:
     case Resource::CSSStyleSheet:
     case Resource::Script:
     case Resource::Font:
     case Resource::Raw:
     case Resource::LinkPrefetch:
     case Resource::TextTrack:
     case Resource::ImportResource:
     case Resource::Media:
     case Resource::Manifest:
       // By default these types of resources can be loaded from any origin.
       // FIXME: Are we sure about Resource::Font?
       if (originRestriction == FetchRequest::RestrictToSameOrigin &&
           !securityOrigin->canRequest(url)) {
         printAccessDeniedMessage(url);
-        return ResourceRequestBlockedReasonOrigin;
+        return ResourceRequestBlockedReason::Origin;
       }
       break;
     case Resource::XSLStyleSheet:
       DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::SVGDocument:
       if (!securityOrigin->canRequest(url)) {
         printAccessDeniedMessage(url);
-        return ResourceRequestBlockedReasonOrigin;
+        return ResourceRequestBlockedReason::Origin;
       }
       break;
   }
 
   // FIXME: Convert this to check the isolated world's Content Security Policy
   // once webkit.org/b/104520 is solved.
   bool shouldBypassMainWorldCSP =
       frame()->script().shouldBypassMainWorldCSP() ||
       options.contentSecurityPolicyOption == DoNotCheckContentSecurityPolicy;
 
   // Don't send CSP messages for preloads, we might never actually display those
   // items.
   ContentSecurityPolicy::ReportingStatus cspReporting =
       forPreload ? ContentSecurityPolicy::SuppressReport
                  : ContentSecurityPolicy::SendReport;
 
   if (m_document) {
     DCHECK(m_document->contentSecurityPolicy());
     if (!shouldBypassMainWorldCSP &&
         !m_document->contentSecurityPolicy()->allowRequest(
             resourceRequest.requestContext(), url,
             options.contentSecurityPolicyNonce, options.integrityMetadata,
             options.parserDisposition, redirectStatus, cspReporting))
-      return ResourceRequestBlockedReasonCSP;
+      return ResourceRequestBlockedReason::CSP;
   }
 
   if (type == Resource::Script || type == Resource::ImportResource) {
     DCHECK(frame());
     if (!frame()->loader().client()->allowScriptFromSource(
             !frame()->settings() || frame()->settings()->scriptEnabled(),
             url)) {
       frame()->loader().client()->didNotAllowScript();
       // TODO(estark): Use a different ResourceRequestBlockedReason here, since
       // this check has nothing to do with CSP. https://crbug.com/600795
-      return ResourceRequestBlockedReasonCSP;
+      return ResourceRequestBlockedReason::CSP;
     }
   } else if (type == Resource::Media || type == Resource::TextTrack) {
     DCHECK(frame());
     if (!frame()->loader().client()->allowMedia(url))
-      return ResourceRequestBlockedReasonOther;
+      return ResourceRequestBlockedReason::Other;
   }
 
   // SVG Images have unique security rules that prevent all subresource requests
   // except for data urls.
   if (type != Resource::MainResource &&
       frame()->chromeClient().isSVGImageChromeClient() && !url.protocolIsData())
-    return ResourceRequestBlockedReasonOrigin;
+    return ResourceRequestBlockedReason::Origin;
 
   // Measure the number of legacy URL schemes ('ftp://') and the number of
   // embedded-credential ('http://user:password@...') resources embedded as
   // subresources. in the hopes that we can block them at some point in the
   // future.
   if (resourceRequest.frameType() != WebURLRequest::FrameTypeTopLevel) {
     DCHECK(frame()->document());
     if (SchemeRegistry::shouldTreatURLSchemeAsLegacy(url.protocol()) &&
         !SchemeRegistry::shouldTreatURLSchemeAsLegacy(
             frame()->document()->getSecurityOrigin()->protocol())) {
       UseCounter::count(frame()->document(),
                         UseCounter::LegacyProtocolEmbeddedAsSubresource);
     }
     if (!url.user().isEmpty() || !url.pass().isEmpty()) {
       UseCounter::count(
           frame()->document(),
           UseCounter::RequestedSubresourceWithEmbeddedCredentials);
     }
   }
 
   // Check for mixed content. We do this second-to-last so that when folks block
   // mixed content with a CSP policy, they don't get a warning. They'll still
   // get a warning in the console about CSP blocking the load.
   MixedContentChecker::ReportingStatus mixedContentReporting =
       forPreload ? MixedContentChecker::SuppressReport
                  : MixedContentChecker::SendReport;
   if (MixedContentChecker::shouldBlockFetch(frame(), resourceRequest, url,
                                             mixedContentReporting))
-    return ResourceRequestBlockedReasonMixedContent;
+    return ResourceRequestBlockedReason::MixedContent;
 
   // Let the client have the final say into whether or not the load should
   // proceed.
   DocumentLoader* documentLoader = masterDocumentLoader();
   if (documentLoader && documentLoader->subresourceFilter() &&
       type != Resource::MainResource && type != Resource::ImportResource &&
       !documentLoader->subresourceFilter()->allowLoad(
           url, resourceRequest.requestContext()))
-    return ResourceRequestBlockedReasonSubresourceFilter;
+    return ResourceRequestBlockedReason::SubresourceFilter;
 
-  return ResourceRequestBlockedReasonNone;
+  return ResourceRequestBlockedReason::None;
 }
 
 bool FrameFetchContext::isControlledByServiceWorker() const {
   DCHECK(m_documentLoader || frame()->loader().documentLoader());
 
   // Service workers are bypassed by suborigins (see
   // https://w3c.github.io/webappsec-suborigins/). Since service worker
   // controllers are assigned based on physical origin, without knowledge of
   // whether the context is in a suborigin, it is necessary to explicitly bypass
   // service workers on a per-request basis. Additionally, it is necessary to
@@ skipping 251 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink