Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
-    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
+    rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 
-    This class provides all functionality needed for loading images, style sheets and html
-    pages from the web. It has a memory cache for these objects.
+    This class provides all functionality needed for loading images, style
+    sheets and html pages from the web. It has a memory cache for these objects.
 */
 
 #include "core/fetch/ResourceFetcher.h"
 
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "core/fetch/CrossOriginAccessControl.h"
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
@@ skipping 78 matching lines @@
       // Also parser-blocking scripts (set explicitly in loadPriority)
       return ResourceLoadPriorityVeryHigh;
     case Resource::XSLStyleSheet:
       DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::Raw:
     case Resource::ImportResource:
     case Resource::Script:
       // Also visible resources/images (set explicitly in loadPriority)
       return ResourceLoadPriorityHigh;
     case Resource::Manifest:
-      // Also late-body scripts discovered by the preload scanner (set explicitly in loadPriority)
+      // Also late-body scripts discovered by the preload scanner (set
+      // explicitly in loadPriority)
       return ResourceLoadPriorityMedium;
     case Resource::Image:
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::SVGDocument:
       // Also async scripts (set explicitly in loadPriority)
       return ResourceLoadPriorityLow;
     case Resource::LinkPrefetch:
       return ResourceLoadPriorityVeryLow;
   }
 
   NOTREACHED();
   return ResourceLoadPriorityUnresolved;
 }
 
 ResourceLoadPriority ResourceFetcher::computeLoadPriority(
     Resource::Type type,
     const FetchRequest& request,
     ResourcePriority::VisibilityStatus visibility) {
   ResourceLoadPriority priority = typeToPriority(type);
 
   // Visible resources (images in practice) get a boost to High priority.
   if (visibility == ResourcePriority::Visible)
     priority = ResourceLoadPriorityHigh;
 
-  // Resources before the first image are considered "early" in the document
-  // and resources after the first image are "late" in the document.  Important to
+  // Resources before the first image are considered "early" in the document and
+  // resources after the first image are "late" in the document.  Important to
   // note that this is based on when the preload scanner discovers a resource
-  // for the most part so the main parser may not have reached the image element yet.
+  // for the most part so the main parser may not have reached the image element
+  // yet.
   if (type == Resource::Image)
     m_imageFetched = true;
 
   if (FetchRequest::IdleLoad == request.defer()) {
     priority = ResourceLoadPriorityVeryLow;
   } else if (type == Resource::Script) {
     // Special handling for scripts.
-    // Default/Parser-Blocking/Preload early in document: High (set in typeToPriority)
+    // Default/Parser-Blocking/Preload early in document: High (set in
+    // typeToPriority)
     // Async/Defer: Low Priority (applies to both preload and parser-inserted)
     // Preload late in document: Medium
     if (FetchRequest::LazyLoad == request.defer())
       priority = ResourceLoadPriorityLow;
     else if (request.forPreload() && m_imageFetched)
       priority = ResourceLoadPriorityMedium;
   } else if (FetchRequest::LazyLoad == request.defer()) {
     priority = ResourceLoadPriorityVeryLow;
   }
 
-  // A manually set priority acts as a floor. This is used to ensure that synchronous requests
-  // are always given the highest possible priority, as well as to ensure that there isn't priority
-  // churn if images move in and out of the viewport, or is displayed more than once, both in and out
-  // of the viewport.
+  // A manually set priority acts as a floor. This is used to ensure that
+  // synchronous requests are always given the highest possible priority, as
+  // well as to ensure that there isn't priority churn if images move in and out
+  // of the viewport, or is displayed more than once, both in and out of the
+  // viewport.
   return std::max(context().modifyPriorityForExperiments(priority),
                   request.resourceRequest().priority());
 }
 
 static void populateResourceTiming(ResourceTimingInfo* info,
                                    Resource* resource) {
   info->setInitialRequest(resource->resourceRequest());
   info->setFinalResponse(resource->response());
 }
 
 static WebURLRequest::RequestContext requestContextFromType(
     bool isMainFrame,
     Resource::Type type) {
   switch (type) {
     case Resource::MainResource:
       if (!isMainFrame)
         return WebURLRequest::RequestContextIframe;
-      // FIXME: Change this to a context frame type (once we introduce them): http://fetch.spec.whatwg.org/#concept-request-context-frame-type
+      // FIXME: Change this to a context frame type (once we introduce them):
+      // http://fetch.spec.whatwg.org/#concept-request-context-frame-type
       return WebURLRequest::RequestContextHyperlink;
     case Resource::XSLStyleSheet:
       DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::CSSStyleSheet:
       return WebURLRequest::RequestContextStyle;
     case Resource::Script:
       return WebURLRequest::RequestContextScript;
     case Resource::Font:
       return WebURLRequest::RequestContextFont;
     case Resource::Image:
@@ skipping 48 matching lines @@
                             FetchRequest::UseDefaultOriginRestrictionForType))
     return false;
 
   SecurityOrigin* sourceOrigin = resource->options().securityOrigin.get();
   if (!sourceOrigin)
     sourceOrigin = context().getSecurityOrigin();
 
   if (sourceOrigin->canRequestNoSuborigin(response.url()))
     return true;
 
-  // Use the original response instead of the 304 response for a successful revaldiation.
+  // Use the original response instead of the 304 response for a successful
+  // revaldiation.
   const ResourceResponse& responseForAccessControl =
       (resource->isCacheValidator() && response.httpStatusCode() == 304)
           ? resource->response()
           : response;
   String errorDescription;
   if (!passesAccessControlCheck(
           responseForAccessControl, resource->options().allowCredentials,
           sourceOrigin, errorDescription,
           resource->lastResourceRequest().requestContext())) {
     resource->setCORSFailed();
@@ skipping 39 matching lines @@
       !m_validatedURLs.contains(resource->url()))
     context().dispatchDidLoadResourceFromMemoryCache(
         identifier, resource, request.resourceRequest().frameType(),
         request.resourceRequest().requestContext());
 
   if (isStaticData)
     return;
 
   if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() &&
       !m_validatedURLs.contains(request.resourceRequest().url())) {
-    // Resources loaded from memory cache should be reported the first time they're used.
+    // Resources loaded from memory cache should be reported the first time
+    // they're used.
     std::unique_ptr<ResourceTimingInfo> info = ResourceTimingInfo::create(
         request.options().initiatorInfo.name, monotonicallyIncreasingTime(),
         resource->getType() == Resource::MainResource);
     populateResourceTiming(info.get(), resource);
     info->clearLoadTimings();
     info->setLoadFinishTime(info->initialTime());
     m_scheduledResourceTimingReports.append(std::move(info));
     if (!m_resourceTimingReportTimer.isActive())
       m_resourceTimingReportTimer.startOneShot(0, BLINK_FROM_HERE);
   }
@@ skipping 10 matching lines @@
   return value;
 }
 
 Resource* ResourceFetcher::resourceForStaticData(
     const FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData) {
   const KURL& url = request.resourceRequest().url();
   DCHECK(url.protocolIsData() || substituteData.isValid() || m_archive);
 
-  // TODO(japhet): We only send main resource data: urls through WebURLLoader for the benefit of
-  // a service worker test (RenderViewImplTest.ServiceWorkerNetworkProviderSetup), which is at a
-  // layer where it isn't easy to mock out a network load. It uses data: urls to emulate the
-  // behavior it wants to test, which would otherwise be reserved for network loads.
+  // TODO(japhet): We only send main resource data: urls through WebURLLoader
+  // for the benefit of a service worker test
+  // (RenderViewImplTest.ServiceWorkerNetworkProviderSetup), which is at a layer
+  // where it isn't easy to mock out a network load. It uses data: urls to
+  // emulate the behavior it wants to test, which would otherwise be reserved
+  // for network loads.
   if (!m_archive && !substituteData.isValid() &&
       (factory.type() == Resource::MainResource ||
        factory.type() == Resource::Raw))
     return nullptr;
 
   const String cacheIdentifier = getCacheIdentifier();
   if (Resource* oldResource =
           memoryCache()->resourceForURL(url, cacheIdentifier)) {
-    // There's no reason to re-parse if we saved the data from the previous parse.
+    // There's no reason to re-parse if we saved the data from the previous
+    // parse.
     if (request.options().dataBufferingPolicy != DoNotBufferData)
       return oldResource;
     memoryCache()->remove(oldResource);
   }
 
   WebString mimetype;
   WebString charset;
   RefPtr<SharedBuffer> data;
   if (substituteData.isValid()) {
     mimetype = substituteData.mimeType();
@@ skipping 33 matching lines @@
 
   if (!substituteData.isValid())
     memoryCache()->add(resource);
 
   return resource;
 }
 
 void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(
     Resource* resource,
     const FetchRequest& request) {
-  // TODO(yoav): Test that non-blocking resources (video/audio/track) continue to not-block even after being preloaded and discovered.
+  // TODO(yoav): Test that non-blocking resources (video/audio/track) continue
+  // to not-block even after being preloaded and discovered.
   if (resource && resource->loader() &&
       resource->isLoadEventBlockingResourceType() &&
       resource->isLinkPreload() && !request.forPreload()) {
     m_nonBlockingLoaders.remove(resource->loader());
     m_loaders.add(resource->loader());
   }
 }
 
 void ResourceFetcher::updateMemoryCacheStats(Resource* resource,
                                              RevalidationPolicy policy,
                                              const FetchRequest& request,
                                              const ResourceFactory& factory,
                                              bool isStaticData) const {
   if (isStaticData)
     return;
 
   if (request.forPreload()) {
     DEFINE_RESOURCE_HISTOGRAM("Preload.");
   } else {
     DEFINE_RESOURCE_HISTOGRAM("");
   }
 
-  // Aims to count Resource only referenced from MemoryCache (i.e. what
-  // would be dead if MemoryCache holds weak references to Resource).
-  // Currently we check references to Resource from ResourceClient and
-  // |m_preloads| only, because they are major sources of references.
+  // Aims to count Resource only referenced from MemoryCache (i.e. what would be
+  // dead if MemoryCache holds weak references to Resource). Currently we check
+  // references to Resource from ResourceClient and |m_preloads| only, because
+  // they are major sources of references.
   if (resource && !resource->isAlive() &&
       (!m_preloads || !m_preloads->contains(resource))) {
     DEFINE_RESOURCE_HISTOGRAM("Dead.");
   }
 }
 
 Resource* ResourceFetcher::requestResource(
     FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData) {
@@ skipping 49 matching lines @@
       activityLogger->logEvent("blinkRequestResource", argv.size(),
                                argv.data());
     }
   }
 
   bool isDataUrl = request.resourceRequest().url().protocolIsData();
   bool isStaticData = isDataUrl || substituteData.isValid() || m_archive;
   Resource* resource(nullptr);
   if (isStaticData) {
     resource = resourceForStaticData(request, factory, substituteData);
-    // Abort the request if the archive doesn't contain the resource, except
-    // in the case of data URLs which might have resources such as fonts
-    // that need to be decoded only on demand.  These data URLs are allowed
-    // to be processed using the normal ResourceFetcher machinery.
+    // Abort the request if the archive doesn't contain the resource, except in
+    // the case of data URLs which might have resources such as fonts that need
+    // to be decoded only on demand.  These data URLs are allowed to be
+    // processed using the normal ResourceFetcher machinery.
     if (!resource && !isDataUrl && m_archive)
       return nullptr;
   }
   if (!resource)
     resource =
         memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
 
-  // See if we can use an existing resource from the cache. If so, we need to move it to be load blocking.
+  // See if we can use an existing resource from the cache. If so, we need to
+  // move it to be load blocking.
   moveCachedNonBlockingResourceToBlocking(resource, request);
 
   const RevalidationPolicy policy = determineRevalidationPolicy(
       factory.type(), request, resource, isStaticData);
   TRACE_EVENT_INSTANT1("blink", "ResourceFetcher::determineRevalidationPolicy",
                        TRACE_EVENT_SCOPE_THREAD, "revalidationPolicy", policy);
 
   updateMemoryCacheStats(resource, policy, request, factory, isStaticData);
 
   request.mutableResourceRequest().setAllowStoredCredentials(
@@ skipping 23 matching lines @@
     return nullptr;
   }
 
   if (!resource->isAlive())
     m_deadStatsRecorder.update(policy);
 
   if (policy != Use)
     resource->setIdentifier(identifier);
 
   if (!request.forPreload() || policy != Use) {
-    // When issuing another request for a resource that is already in-flight make
-    // sure to not demote the priority of the in-flight request. If the new request
-    // isn't at the same priority as the in-flight request, only allow promotions.
-    // This can happen when a visible image's priority is increased and then another
-    // reference to the image is parsed (which would be at a lower priority).
+    // When issuing another request for a resource that is already in-flight
+    // make sure to not demote the priority of the in-flight request. If the new
+    // request isn't at the same priority as the in-flight request, only allow
+    // promotions. This can happen when a visible image's priority is increased
+    // and then another reference to the image is parsed (which would be at a
+    // lower priority).
     if (request.resourceRequest().priority() >
         resource->resourceRequest().priority())
       resource->didChangePriority(request.resourceRequest().priority(), 0);
   }
 
   // If only the fragment identifiers differ, it is the same resource.
   DCHECK(equalIgnoringFragmentIdentifier(resource->url(), request.url()));
   requestLoadStarted(
       identifier, resource, request,
       policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork,
       isStaticData);
   m_documentResources.set(
       MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), resource);
 
   // Returns with an existing resource if the resource does not need to start
-  // loading immediately.
-  // If revalidation policy was determined as |Revalidate|, the resource was
-  // already initialized for the revalidation here, but won't start loading.
+  // loading immediately. If revalidation policy was determined as |Revalidate|,
+  // the resource was already initialized for the revalidation here, but won't
+  // start loading.
   if (!resourceNeedsLoad(resource, request, policy))
     return resource;
 
   if (!startLoad(resource))
     return nullptr;
   DCHECK(!resource->errorOccurred() ||
          request.options().synchronousPolicy == RequestSynchronously);
   return resource;
 }
 
@@ skipping 127 matching lines @@
                                              Resource* existingResource,
                                              bool isStaticData) const {
   const ResourceRequest& request = fetchRequest.resourceRequest();
 
   if (!existingResource)
     return Load;
 
   // Checks if the resource has an explicit policy about integrity metadata.
   // Currently only applies to ScriptResources.
   //
-  // This is necessary because ScriptResource objects do not keep the raw
-  // data around after the source is accessed once, so if the resource is
-  // accessed from the MemoryCache for a second time, there is no way to redo
-  // an integrity check.
+  // This is necessary because ScriptResource objects do not keep the raw data
+  // around after the source is accessed once, so if the resource is accessed
+  // from the MemoryCache for a second time, there is no way to redo an
+  // integrity check.
   //
-  // Thus, Blink implements a scheme where it caches the integrity
-  // information for a ScriptResource after the first time it is checked, and
-  // if there is another request for that resource, with the same integrity
-  // metadata, Blink skips the integrity calculation. However, if the
-  // integrity metadata is a mismatch, the MemoryCache must be skipped here,
-  // and a new request for the resource must be made to get the raw data.
-  // This is expected to be an uncommon case, however, as it implies two
-  // same-origin requests to the same resource, but with different integrity
-  // metadata.
+  // Thus, Blink implements a scheme where it caches the integrity information
+  // for a ScriptResource after the first time it is checked, and if there is
+  // another request for that resource, with the same integrity metadata, Blink
+  // skips the integrity calculation. However, if the integrity metadata is a
+  // mismatch, the MemoryCache must be skipped here, and a new request for the
+  // resource must be made to get the raw data. This is expected to be an
+  // uncommon case, however, as it implies two same-origin requests to the same
+  // resource, but with different integrity metadata.
   RecordSriResourceIntegrityMismatchEvent(CheckingForIntegrityMismatch);
   if (existingResource->mustRefetchDueToIntegrityMetadata(fetchRequest)) {
     RecordSriResourceIntegrityMismatchEvent(RefetchDueToIntegrityMismatch);
     return Reload;
   }
 
   // Service Worker's CORS fallback message must not be cached.
   if (existingResource->response().wasFallbackRequiredByServiceWorker())
     return Reload;
 
   // We already have a preload going for this URL.
   if (fetchRequest.forPreload() && existingResource->isPreloaded())
     return Use;
 
   // If the same URL has been loaded as a different type, we need to reload.
   if (existingResource->getType() != type) {
     // FIXME: If existingResource is a Preload and the new type is LinkPrefetch
     // We really should discard the new prefetch since the preload has more
     // specific type information! crbug.com/379893
     // fast/dom/HTMLLinkElement/link-and-subresource-test hits this case.
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to type mismatch.";
     return Reload;
   }
 
-  // Do not load from cache if images are not enabled.
-  // There are two general cases:
-  // 1. Images are disabled. Don't ever load images, even if the image is
-  //    cached or it is a data: url. In this case, we "Reload" the image,
-  //    then defer it with resourceNeedsLoad() so that it never actually
-  //    goes to the network.
-  // 2. Images are enabled, but not loaded automatically. In this case, we
-  //    will Use cached resources or data: urls, but will similarly fall back
-  //    to a deferred network load if we don't have the data available
-  //    without a network request. We check allowImage() here, which is
-  //    affected by m_imagesEnabled but not m_autoLoadImages, in order to
-  //    allow for this differing behavior.
+  // Do not load from cache if images are not enabled. There are two general
+  // cases:
+  //
+  // 1. Images are disabled. Don't ever load images, even if the image is cached
+  // or it is a data: url. In this case, we "Reload" the image, then defer it
+  // with resourceNeedsLoad() so that it never actually goes to the network.
+  //
+  // 2. Images are enabled, but not loaded automatically. In this case, we will
+  // Use cached resources or data: urls, but will similarly fall back to a
+  // deferred network load if we don't have the data available without a network
+  // request. We check allowImage() here, which is affected by m_imagesEnabled
+  // but not m_autoLoadImages, in order to allow for this differing behavior.
+  //
   // TODO(japhet): Can we get rid of one of these settings?
   if (existingResource->isImage() &&
       !context().allowImage(m_imagesEnabled, existingResource->url()))
     return Reload;
 
-  // Never use cache entries for downloadToFile / useStreamOnResponse
-  // requests. The data will be delivered through other paths.
+  // Never use cache entries for downloadToFile / useStreamOnResponse requests.
+  // The data will be delivered through other paths.
   if (request.downloadToFile() || request.useStreamOnResponse())
     return Reload;
 
-  // Never reuse opaque responses from a service worker for requests that
-  // are not no-cors. https://crbug.com/625575
+  // Never reuse opaque responses from a service worker for requests that are
+  // not no-cors. https://crbug.com/625575
   if (existingResource->response().wasFetchedViaServiceWorker() &&
       existingResource->response().serviceWorkerResponseType() ==
           WebServiceWorkerResponseTypeOpaque &&
       request.fetchRequestMode() != WebURLRequest::FetchRequestModeNoCORS)
     return Reload;
 
   // If resource was populated from a SubstituteData load or data: url, use it.
   if (isStaticData)
     return Use;
 
   if (!existingResource->canReuse(request))
     return Reload;
 
-  // Certain requests (e.g., XHRs) might have manually set headers that require revalidation.
-  // In theory, this should be a Revalidate case. In practice, the MemoryCache revalidation path assumes a whole bunch
-  // of things about how revalidation works that manual headers violate, so punt to Reload instead.
+  // Certain requests (e.g., XHRs) might have manually set headers that require
+  // revalidation. In theory, this should be a Revalidate case. In practice, the
+  // MemoryCache revalidation path assumes a whole bunch of things about how
+  // revalidation works that manual headers violate, so punt to Reload instead.
   //
-  // Similarly, a request with manually added revalidation headers can lead
-  // to a 304 response for a request that wasn't flagged as a revalidation
-  // attempt. Normally, successful revalidation will maintain the original
-  // response's status code, but for a manual revalidation the response code
-  // remains 304. In this case, the Resource likely has insufficient context
-  // to provide a useful cache hit or revalidation.
-  // See http://crbug.com/643659
+  // Similarly, a request with manually added revalidation headers can lead to a
+  // 304 response for a request that wasn't flagged as a revalidation attempt.
+  // Normally, successful revalidation will maintain the original response's
+  // status code, but for a manual revalidation the response code remains 304.
+  // In this case, the Resource likely has insufficient context to provide a
+  // useful cache hit or revalidation. See http://crbug.com/643659
   if (request.isConditional() ||
       existingResource->response().httpStatusCode() == 304)
     return Reload;
 
   // Don't try to reuse an in-progress async request for a new sync request.
   if (fetchRequest.options().synchronousPolicy == RequestSynchronously &&
       existingResource->isLoading())
     return Reload;
 
   // Don't reload resources while pasting.
@@ skipping 12 matching lines @@
   if (cachePolicy == CachePolicyHistoryBuffer)
     return Use;
 
   // Don't reuse resources with Cache-control: no-store.
   if (existingResource->hasCacheControlNoStoreHeader()) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to Cache-control: no-store.";
     return Reload;
   }
 
-  // If credentials were sent with the previous request and won't be
-  // with this one, or vice versa, re-fetch the resource.
+  // If credentials were sent with the previous request and won't be with this
+  // one, or vice versa, re-fetch the resource.
   //
   // This helps with the case where the server sends back
-  // "Access-Control-Allow-Origin: *" all the time, but some of the
-  // client's requests are made without CORS and some with.
+  // "Access-Control-Allow-Origin: *" all the time, but some of the client's
+  // requests are made without CORS and some with.
   if (existingResource->resourceRequest().allowStoredCredentials() !=
       request.allowStoredCredentials()) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to difference in credentials "
                                  "settings.";
     return Reload;
   }
 
-  // During the initial load, avoid loading the same resource multiple times for a single document,
-  // even if the cache policies would tell us to.
-  // We also group loads of the same resource together.
-  // Raw resources are exempted, as XHRs fall into this category and may have user-set Cache-Control:
-  // headers or other factors that require separate requests.
+  // During the initial load, avoid loading the same resource multiple times for
+  // a single document, even if the cache policies would tell us to. We also
+  // group loads of the same resource together. Raw resources are exempted, as
+  // XHRs fall into this category and may have user-set Cache-Control: headers
+  // or other factors that require separate requests.
   if (type != Resource::Raw) {
     if (!context().isLoadComplete() &&
         m_validatedURLs.contains(existingResource->url()))
       return Use;
     if (existingResource->isLoading())
       return Use;
   }
 
   if (request.getCachePolicy() == WebCachePolicy::BypassingCache)
     return Reload;
 
   // CachePolicyReload always reloads
   if (cachePolicy == CachePolicyReload) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to CachePolicyReload.";
     return Reload;
   }
 
   // We'll try to reload the resource if it failed last time.
   if (existingResource->errorOccurred()) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::"
                                  "determineRevalidationPolicye reloading due "
                                  "to resource being in the error state";
     return Reload;
   }
 
-  // List of available images logic allows images to be re-used without cache validation. We restrict this only to images
-  // from memory cache which are the same as the version in the current document.
+  // List of available images logic allows images to be re-used without cache
+  // validation. We restrict this only to images from memory cache which are the
+  // same as the version in the current document.
   if (type == Resource::Image &&
       existingResource == cachedResource(request.url()))
     return Use;
 
   // Defer to the browser process cache for Vary header handling.
   if (existingResource->hasVaryHeader())
     return Reload;
 
-  // If any of the redirects in the chain to loading the resource were not cacheable, we cannot reuse our cached resource.
+  // If any of the redirects in the chain to loading the resource were not
+  // cacheable, we cannot reuse our cached resource.
   if (!existingResource->canReuseRedirectChain()) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to an uncacheable redirect";
     return Reload;
   }
 
-  // Check if the cache headers requires us to revalidate (cache expiration for example).
+  // Check if the cache headers requires us to revalidate (cache expiration for
+  // example).
   if (cachePolicy == CachePolicyRevalidate ||
       existingResource->mustRevalidateDueToCacheHeaders() ||
       request.cacheControlContainsNoCache()) {
-    // See if the resource has usable ETag or Last-modified headers.
-    // If the page is controlled by the ServiceWorker, we choose the Reload policy because the revalidation headers should not be exposed to the ServiceWorker.(crbug.com/429570)
+    // See if the resource has usable ETag or Last-modified headers. If the page
+    // is controlled by the ServiceWorker, we choose the Reload policy because
+    // the revalidation headers should not be exposed to the
+    // ServiceWorker.(crbug.com/429570)
     if (existingResource->canUseCacheValidator() &&
         !context().isControlledByServiceWorker()) {
-      // If the resource is already a cache validator but not started yet,
-      // the |Use| policy should be applied to subsequent requests.
+      // If the resource is already a cache validator but not started yet, the
+      // |Use| policy should be applied to subsequent requests.
       if (existingResource->isCacheValidator()) {
         DCHECK(existingResource->stillNeedsLoad());
         return Use;
       }
       return Revalidate;
     }
 
     // No, must reload.
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to missing cache validators.";
@@ skipping 125 matching lines @@
   return m_archive ? m_archive->mainResource() : nullptr;
 }
 
 void ResourceFetcher::didFinishLoading(Resource* resource,
                                        double finishTime,
                                        int64_t encodedDataLength,
                                        DidFinishLoadingReason finishReason) {
   TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource->identifier());
   DCHECK(resource);
 
-  // When loading a multipart resource, make the loader non-block when
-  // finishing loading the first part.
+  // When loading a multipart resource, make the loader non-block when finishing
+  // loading the first part.
   if (finishReason == DidFinishFirstPartInMultipart)
     moveResourceLoaderToNonBlocking(resource->loader());
   else
     removeResourceLoader(resource->loader());
   DCHECK(!m_loaders.contains(resource->loader()));
   DCHECK(finishReason == DidFinishFirstPartInMultipart ||
          !m_nonBlockingLoaders.contains(resource->loader()));
 
   if (std::unique_ptr<ResourceTimingInfo> info =
           m_resourceTimingInfoMap.take(resource)) {
     if (resource->response().isHTTP() &&
         resource->response().httpStatusCode() < 400) {
       populateResourceTiming(info.get(), resource);
       info->setLoadFinishTime(finishTime);
       // encodedDataLength == -1 means "not available".
       // TODO(ricea): Find cases where it is not available but the
-      // PerformanceResourceTiming spec requires it to be available and
-      // fix them.
+      // PerformanceResourceTiming spec requires it to be available and fix
+      // them.
       info->addFinalTransferSize(encodedDataLength == -1 ? 0
                                                          : encodedDataLength);
       if (resource->options().requestInitiatorContext == DocumentContext)
         context().addResourceTiming(*info);
       resource->reportResourceTimingToClients(*info);
     }
   }
   context().dispatchDidFinishLoading(resource->identifier(), finishTime,
                                      encodedDataLength);
   if (finishReason == DidFinishLoading)
@@ skipping 19 matching lines @@
   // |rawHandle|'s ownership is transferred to the callee.
   std::unique_ptr<WebDataConsumerHandle> handle = wrapUnique(rawHandle);
 
   if (response.wasFetchedViaServiceWorker()) {
     if (resource->options().corsEnabled == IsCORSEnabled &&
         response.wasFallbackRequiredByServiceWorker()) {
       ResourceRequest request = resource->lastResourceRequest();
       DCHECK_EQ(request.skipServiceWorker(),
                 WebURLRequest::SkipServiceWorker::None);
       // This code handles the case when a regular controlling service worker
-      // doesn't handle a cross origin request. When this happens we still
-      // want to give foreign fetch a chance to handle the request, so
-      // only skip the controlling service worker for the fallback request.
-      // This is currently safe because of http://crbug.com/604084 the
+      // doesn't handle a cross origin request. When this happens we still want
+      // to give foreign fetch a chance to handle the request, so only skip the
+      // controlling service worker for the fallback request. This is currently
+      // safe because of http://crbug.com/604084 the
       // wasFallbackRequiredByServiceWorker flag is never set when foreign fetch
       // handled a request.
       request.setSkipServiceWorker(
           WebURLRequest::SkipServiceWorker::Controlling);
       resource->loader()->restartForServiceWorkerFallback(request);
       return;
     }
 
-    // If the response is fetched via ServiceWorker, the original URL of the response could be different from the URL of the request.
-    // We check the URL not to load the resources which are forbidden by the page CSP.
+    // If the response is fetched via ServiceWorker, the original URL of the
+    // response could be different from the URL of the request. We check the URL
+    // not to load the resources which are forbidden by the page CSP.
     // https://w3c.github.io/webappsec-csp/#should-block-response
     const KURL& originalURL = response.originalURLViaServiceWorker();
     if (!originalURL.isEmpty() &&
         !context().allowResponse(resource->getType(),
                                  resource->resourceRequest(), originalURL,
                                  resource->options())) {
       resource->loader()->didFail(
           nullptr, ResourceError::cancelledDueToAccessCheckError(originalURL));
       return;
     }
@@ skipping 47 matching lines @@
   DCHECK(resource->stillNeedsLoad());
   if (!context().shouldLoadNewResource(resource->getType())) {
     memoryCache()->remove(resource);
     return false;
   }
 
   ResourceRequest request(resource->resourceRequest());
   willSendRequest(resource->identifier(), request, ResourceResponse(),
                   resource->options());
 
-  // Resource requests from suborigins should not be intercepted by the
-  // service worker of the physical origin. This has the effect that, for
-  // now, suborigins do not work with service workers. See
+  // Resource requests from suborigins should not be intercepted by the service
+  // worker of the physical origin. This has the effect that, for now,
+  // suborigins do not work with service workers. See
   // https://w3c.github.io/webappsec-suborigins/.
   SecurityOrigin* sourceOrigin = context().getSecurityOrigin();
   if (sourceOrigin && sourceOrigin->hasSuborigin())
     request.setSkipServiceWorker(WebURLRequest::SkipServiceWorker::All);
 
   ResourceLoader* loader = ResourceLoader::create(this, resource);
   if (resource->shouldBlockLoadEvent())
     m_loaders.add(loader);
   else
     m_nonBlockingLoaders.add(loader);
@@ skipping 328 matching lines @@
   visitor->trace(m_context);
   visitor->trace(m_archive);
   visitor->trace(m_loaders);
   visitor->trace(m_nonBlockingLoaders);
   visitor->trace(m_documentResources);
   visitor->trace(m_preloads);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink