Allow cache reuse of some requests with Cache-Control headers

Source/core/fetch/Resource.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) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
 
     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
@@ skipping 264 matching lines @@
     // RFC2616 13.2.3
     // No compensation for latency as that is not terribly important in practice
     double dateValue = response.date();
     double apparentAge = std::isfinite(dateValue) ? std::max(0., responseTimestamp - dateValue) : 0;
     double ageValue = response.age();
     double correctedReceivedAge = std::isfinite(ageValue) ? std::max(apparentAge, ageValue) : apparentAge;
     double residentTime = currentTime() - responseTimestamp;
     return correctedReceivedAge + residentTime;
 }
 
-static double freshnessLifetime(const ResourceResponse& response, double responseTimestamp)
+static double freshnessLifetime(ResourceResponse& response, double responseTimestamp)
 {
 #if !OS(ANDROID)
     // On desktop, local files should be reloaded in case they change.
     if (response.url().isLocalFile())
         return 0;
 #endif
 
     // Cache other non-http / non-filesystem resources liberally.
     if (!response.url().protocolIsInHTTPFamily()
         && !response.url().protocolIs("filesystem"))
         return std::numeric_limits<double>::max();
 
     // RFC2616 13.2.4
     double maxAgeValue = response.cacheControlMaxAge();
     if (std::isfinite(maxAgeValue))
         return maxAgeValue;
     double expiresValue = response.expires();
     double dateValue = response.date();
     double creationTime = std::isfinite(dateValue) ? dateValue : responseTimestamp;
     if (std::isfinite(expiresValue))
         return expiresValue - creationTime;
     double lastModifiedValue = response.lastModified();
     if (std::isfinite(lastModifiedValue))
         return (creationTime - lastModifiedValue) * 0.1;
     // If no cache headers are present, the specification leaves the decision to the UA. Other browsers seem to opt for 0.
     return 0;
 }
 
-static bool canUseResponse(const ResourceResponse& response, double responseTimestamp)
+static bool canUseResponse(ResourceResponse& response, double responseTimestamp)
 {
     if (response.isNull())
         return false;
 
     // FIXME: Why isn't must-revalidate considered a reason we can't use the response?
     if (response.cacheControlContainsNoCache() || response.cacheControlContainsNoStore())
         return false;
 
     if (response.httpStatusCode() == 303)  {
         // Must not be cached.
@@ skipping 161 matching lines @@
     bool deleted = deleteIfPossible();
     if (!deleted && !hasClients()) {
         memoryCache()->makeDead(this);
         if (!m_switchingClientsToRevalidatedResource)
             allClientsRemoved();
 
         // RFC2616 14.9.2:
         // "no-store: ... MUST make a best-effort attempt to remove the information from volatile storage as promptly as possible"
         // "... History buffers MAY store such responses as part of their normal operation."
         // We allow non-secure content to be reused in history, but we do not allow secure content to be reused.
-        if (response().cacheControlContainsNoStore() && url().protocolIs("https")) {
+        if (hasCacheControlNoStoreHeader() && url().protocolIs("https")) {
             memoryCache()->remove(this);
             memoryCache()->prune();
         } else {
             memoryCache()->prune(this);
         }
     }
     // This object may be dead here.
 }
 
 void Resource::allClientsRemoved()
@@ skipping 228 matching lines @@
 
     if (!m_handleCount) {
         if (deleteIfPossible())
             return;
         unlock();
     } else if (m_handleCount == 1 && memoryCache()->contains(this)) {
         unlock();
     }
 }
 
-bool Resource::canReuseRedirectChain() const
+bool Resource::canReuseRedirectChain()
 {
     for (size_t i = 0; i < m_redirectChain.size(); ++i) {
         if (!canUseResponse(m_redirectChain[i].m_redirectResponse, m_responseTimestamp))
             return false;
+        if (m_redirectChain[i].m_request.cacheControlContainsNoCache() || m_redirectChain[i].m_request.cacheControlContainsNoStore())
+            return false;
     }
     return true;
 }
 
-bool Resource::mustRevalidateDueToCacheHeaders() const
+bool Resource::hasCacheControlNoStoreHeader()
 {
-    return !canUseResponse(m_response, m_responseTimestamp);
+    return m_response.cacheControlContainsNoStore() || m_resourceRequest.cacheControlContainsNoStore();
 }
 
-bool Resource::canUseCacheValidator() const
+bool Resource::mustRevalidateDueToCacheHeaders()
+{
+    return !canUseResponse(m_response, m_responseTimestamp) || m_resourceRequest.cacheControlContainsNoCache() || m_resourceRequest.cacheControlContainsNoStore();
+}
+
+bool Resource::canUseCacheValidator()
 {
     if (m_loading || errorOccurred())
         return false;
 
-    if (m_response.cacheControlContainsNoStore())
+    if (hasCacheControlNoStoreHeader())
         return false;
-    return m_response.hasCacheValidatorFields();
+    return m_response.hasCacheValidatorFields() || m_resourceRequest.hasCacheValidatorFields();
 }
 
 bool Resource::isPurgeable() const
 {
     return m_data && !m_data->isLocked();
 }
 
 bool Resource::wasPurged() const
 {
     return m_wasPurged;
@@ skipping 165 matching lines @@
         return "Shader";
     case Resource::ImportResource:
         return "ImportResource";
     }
     ASSERT_NOT_REACHED();
     return "Unknown";
 }
 #endif // !LOG_DISABLED
 
 }