Refactor the forPreload flag to mean speculative preload.

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 553 matching lines @@
   value->setString("url", url.getString());
   value->setInteger("priority", priority);
   return value;
 }
 
 void FrameFetchContext::willStartLoadingResource(
     unsigned long identifier,
     ResourceRequest& request,
     Resource::Type type,
     const AtomicString& fetchInitiatorName,
-    bool forPreload) {
+    V8ActivityLoggingPolicy loggingPolicy) {
   TRACE_EVENT_ASYNC_BEGIN1(
       "blink.net", "Resource", identifier, "data",
       loadResourceTraceData(identifier, request.url(), request.priority()));
   prepareRequest(request);
 
   if (!m_documentLoader || m_documentLoader->fetcher()->archive() ||
       !request.url().isValid())
     return;
   if (type == Resource::MainResource) {
     m_documentLoader->applicationCacheHost()->willStartLoadingMainResource(
         request);
   } else {
     m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
   }
-  if (!forPreload) {
+  if (loggingPolicy == V8ActivityLoggingPolicy::Log) {
     V8DOMActivityLogger* activityLogger = nullptr;
     if (fetchInitiatorName == FetchInitiatorTypeNames::xmlhttprequest) {
       activityLogger = V8DOMActivityLogger::currentActivityLogger();
     } else {
       activityLogger =
           V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
     }
 
     if (activityLogger) {
       Vector<String> argv;
@@ skipping 45 matching lines @@
 
   frame()->document()->addConsoleMessage(ConsoleMessage::create(
       SecurityMessageSource, ErrorMessageLevel, message));
 }
 
 ResourceRequestBlockedReason FrameFetchContext::canRequest(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options,
-    bool forPreload,
+    ReportingPolicy reportingPolicy,
     FetchRequest::OriginRestriction originRestriction) const {
   ResourceRequestBlockedReason blockedReason =
-      canRequestInternal(type, resourceRequest, url, options, forPreload,
+      canRequestInternal(type, resourceRequest, url, options, reportingPolicy,
                          originRestriction, resourceRequest.redirectStatus());
-  if (blockedReason != ResourceRequestBlockedReason::None && !forPreload) {
+  if (blockedReason != ResourceRequestBlockedReason::None &&
+      reportingPolicy == ReportingPolicy::Report) {
     InspectorInstrumentation::didBlockRequest(
         frame(), resourceRequest, masterDocumentLoader(), options.initiatorInfo,
         blockedReason);
   }
   return blockedReason;
 }
 
 ResourceRequestBlockedReason FrameFetchContext::allowResponse(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options) const {
-  ResourceRequestBlockedReason blockedReason =
-      canRequestInternal(type, resourceRequest, url, options, false,
-                         FetchRequest::UseDefaultOriginRestrictionForType,
-                         RedirectStatus::FollowedRedirect);
+  ResourceRequestBlockedReason blockedReason = canRequestInternal(
+      type, resourceRequest, url, options, ReportingPolicy::Report,
+      FetchRequest::UseDefaultOriginRestrictionForType,
+      RedirectStatus::FollowedRedirect);
   if (blockedReason != ResourceRequestBlockedReason::None) {
     InspectorInstrumentation::didBlockRequest(
         frame(), resourceRequest, masterDocumentLoader(), options.initiatorInfo,
         blockedReason);
   }
   return blockedReason;
 }
 
 ResourceRequestBlockedReason FrameFetchContext::canRequestInternal(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options,
-    bool forPreload,
+    ReportingPolicy reportingPolicy,
     FetchRequest::OriginRestriction originRestriction,
     ResourceRequest::RedirectStatus redirectStatus) const {
   if (InspectorInstrumentation::shouldBlockRequest(frame(), resourceRequest))
     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)
+    if (reportingPolicy == ReportingPolicy::Report)
       FrameLoader::reportLocalLoadFailed(frame(), url.elidedString());
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::requestResource URL was not "
                                  "allowed by SecurityOrigin::canDisplay";
     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) {
@@ skipping 26 matching lines @@
       }
       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

[yhirano, 2017/02/07 08:34:06]

This comment should be moved to caller now.

[Yoav Weiss, 2017/02/07 09:10:27]

agreed

   // items.

[kinuko, 2017/02/07 08:20:26]

nit: update the comment?

   ContentSecurityPolicy::ReportingStatus cspReporting =
-      forPreload ? ContentSecurityPolicy::SuppressReport
-                 : ContentSecurityPolicy::SendReport;
+      (reportingPolicy == ReportingPolicy::SuppressReporting)
+          ? 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 ResourceRequestBlockedReason::CSP;
   }
@@ skipping 36 matching lines @@
       Deprecation::countDeprecation(
           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;
+      (reportingPolicy == ReportingPolicy::SuppressReporting)
+          ? MixedContentChecker::SuppressReport
+          : MixedContentChecker::SendReport;
   if (MixedContentChecker::shouldBlockFetch(frame(), resourceRequest, url,
                                             mixedContentReporting))
     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(
@@ skipping 265 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink