Reduce FetchContext::getCachePolicy() callers

third_party/WebKit/Source/platform/loader/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) 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
@@ skipping 665 matching lines @@
   DCHECK(resource->isLoaded());
   DCHECK(resource->canUseCacheValidator());
   DCHECK(!resource->isCacheValidator());
   DCHECK(!context().isControlledByServiceWorker());
 
   const AtomicString& lastModified =
       resource->response().httpHeaderField(HTTPNames::Last_Modified);
   const AtomicString& eTag =
       resource->response().httpHeaderField(HTTPNames::ETag);
   if (!lastModified.isEmpty() || !eTag.isEmpty()) {
-    DCHECK_NE(context().getCachePolicy(), CachePolicyReload);
-    if (context().getCachePolicy() == CachePolicyRevalidate) {
+    DCHECK_NE(WebCachePolicy::BypassingCache,
+              revalidatingRequest.getCachePolicy());
+    if (revalidatingRequest.getCachePolicy() ==
+        WebCachePolicy::ValidatingCacheData) {
       revalidatingRequest.setHTTPHeaderField(HTTPNames::Cache_Control,
                                              "max-age=0");
     }
   }
   if (!lastModified.isEmpty()) {
     revalidatingRequest.setHTTPHeaderField(HTTPNames::If_Modified_Since,
                                            lastModified);
   }
   if (!eTag.isEmpty())
     revalidatingRequest.setHTTPHeaderField(HTTPNames::If_None_Match, eTag);
@@ skipping 158 matching lines @@
   // 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()))
+      !context().allowImage(m_imagesEnabled, existingResource->url())) {
     return Reload;
+  }
 
   // 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
   if (existingResource->response().wasFetchedViaServiceWorker() &&
       existingResource->response().serviceWorkerResponseType() ==
           WebServiceWorkerResponseTypeOpaque &&
-      request.fetchRequestMode() != WebURLRequest::FetchRequestModeNoCORS)
+      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.
   //
   // 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)
+      existingResource->response().httpStatusCode() == 304) {
     return Reload;
+  }
 
   // Don't reload resources while pasting.
   if (m_allowStaleResources)
     return Use;
 
   if (!fetchRequest.options().canReuseRequest(existingResource->options()))
     return Reload;
 
   // Always use preloads.
   if (existingResource->isPreloaded())
     return Use;
 
-  // CachePolicyHistoryBuffer uses the cache no matter what.
-  CachePolicy cachePolicy = context().getCachePolicy();
-  if (cachePolicy == CachePolicyHistoryBuffer)
+  // WebCachePolicy::ReturnCacheDataElseLoad uses the cache no matter what.
+  if (request.getCachePolicy() == WebCachePolicy::ReturnCacheDataElseLoad)
     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
@@ skipping 16 matching lines @@
   // 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) {
+  // WebCachePolicy::BypassingCache always reloads
+  if (request.getCachePolicy() == WebCachePolicy::BypassingCache) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
-                                 "reloading due to CachePolicyReload.";
+                                 "reloading due to "
+                                 "WebCachePolicy::BypassingCache.";
     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";
+    RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
+                                 "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.
   if (type == Resource::Image &&
-      existingResource == cachedResource(request.url()))
+      existingResource == cachedResource(request.url())) {
     return Use;
+  }
 
   if (existingResource->mustReloadDueToVaryHeader(request))
     return Reload;
 
   // 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).
-  if (cachePolicy == CachePolicyRevalidate ||
+  if (request.getCachePolicy() == WebCachePolicy::ValidatingCacheData ||
       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)
     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.
@@ skipping 546 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