Post-commit fixes for "stale-while-revalidate..."

net/http/http_response_headers.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The rules for header parsing were borrowed from Firefox:
 // http://lxr.mozilla.org/seamonkey/source/netwerk/protocol/http/src/nsHttpResponseHead.cpp
 // The rules for parsing content-types were also borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_response_headers.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
+#include "base/time/time_logging.h"

[mmenke, 2014/10/21 14:22:00]

I wonder about requiring this include - I don't think I've seen anything else
that does this, and I suspect when most people get compile errors on time
comparisons, they'll just switch to ==, instead of looking for a file.

[Adam Rice, 2014/10/23 01:13:02]

True. I got rid of the separate include file.

 #include "base/values.h"
 #include "net/base/escape.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_log_util.h"
 #include "net/http/http_util.h"
 
 using base::StringPiece;
 using base::Time;
 using base::TimeDelta;
 
@@ skipping 926 matching lines @@
 // From RFC 5861 section 3, a stale response may be used while revalidation is
 // performed in the background if
 //
 //   freshness_lifetime + stale_while_revalidate > current_age
 //
 ValidationType HttpResponseHeaders::RequiresValidation(
     const Time& request_time,
     const Time& response_time,
     const Time& current_time) const {
   FreshnessLifetimes lifetimes = GetFreshnessLifetimes(response_time);
-  if (lifetimes.fresh == TimeDelta() && lifetimes.stale == TimeDelta())
+  if (lifetimes.freshness == TimeDelta() && lifetimes.staleness == TimeDelta())
     return VALIDATION_SYNCHRONOUS;
 
   TimeDelta age = GetCurrentAge(request_time, response_time, current_time);
 
-  if (lifetimes.fresh > age)
+  if (lifetimes.freshness > age)
     return VALIDATION_NONE;
 
-  if (lifetimes.fresh + lifetimes.stale > age)
+  if (lifetimes.freshness + lifetimes.staleness > age)
     return VALIDATION_ASYNCHRONOUS;
 
   return VALIDATION_SYNCHRONOUS;
 }
 
 // From RFC 2616 section 13.2.4:
 //
 // The max-age directive takes priority over Expires, so if max-age is present
 // in a response, the calculation is simply:
 //
 //   freshness_lifetime = max_age_value
 //
 // Otherwise, if Expires is present in the response, the calculation is:
 //
 //   freshness_lifetime = expires_value - date_value
 //
 // Note that neither of these calculations is vulnerable to clock skew, since
 // all of the information comes from the origin server.
 //
 // Also, if the response does have a Last-Modified time, the heuristic
 // expiration value SHOULD be no more than some fraction of the interval since
 // that time. A typical setting of this fraction might be 10%:
 //
 //   freshness_lifetime = (date_value - last_modified_value) * 0.10
 //
 // If the stale-while-revalidate directive is present, then it is used to set
-// the |stale| time, unless it overridden by another directive.
+// the |staleness| time, unless it overridden by another directive.
 //
 HttpResponseHeaders::FreshnessLifetimes
 HttpResponseHeaders::GetFreshnessLifetimes(const Time& response_time) const {
   FreshnessLifetimes lifetimes;
   // Check for headers that force a response to never be fresh.  For backwards
   // compat, we treat "Pragma: no-cache" as a synonym for "Cache-Control:
   // no-cache" even though RFC 2616 does not specify it.
   if (HasHeaderValue("cache-control", "no-cache") ||
       HasHeaderValue("cache-control", "no-store") ||
       HasHeaderValue("pragma", "no-cache") ||
       // Vary: * is never usable: see RFC 2616 section 13.6.
       HasHeaderValue("vary", "*")) {
     return lifetimes;
   }
 
   // Cache-Control directive must_revalidate overrides stale-while-revalidate.
   bool must_revalidate = HasHeaderValue("cache-control", "must-revalidate");
 
-  if (must_revalidate || !GetStaleWhileRevalidateValue(&lifetimes.stale))
-    DCHECK(lifetimes.stale == TimeDelta());
+  if (must_revalidate || !GetStaleWhileRevalidateValue(&lifetimes.staleness)) {
+    DCHECK_EQ(TimeDelta(), lifetimes.staleness);
+  }
 
   // NOTE: "Cache-Control: max-age" overrides Expires, so we only check the
   // Expires header after checking for max-age in GetFreshnessLifetimes.  This
   // is important since "Expires: <date in the past>" means not fresh, but
   // it should not trump a max-age value.
-  if (GetMaxAgeValue(&lifetimes.fresh))
+  if (GetMaxAgeValue(&lifetimes.freshness))
     return lifetimes;
 
   // If there is no Date header, then assume that the server response was
   // generated at the time when we received the response.
   Time date_value;
   if (!GetDateValue(&date_value))
     date_value = response_time;
 
   Time expires_value;
   if (GetExpiresValue(&expires_value)) {
     // The expires value can be a date in the past!
     if (expires_value > date_value) {
-      lifetimes.fresh = expires_value - date_value;
+      lifetimes.freshness = expires_value - date_value;
       return lifetimes;
     }
 
-    DCHECK(lifetimes.fresh == TimeDelta());
+    DCHECK_EQ(TimeDelta(), lifetimes.freshness);
     return lifetimes;
   }
 
   // From RFC 2616 section 13.4:
   //
   //   A response received with a status code of 200, 203, 206, 300, 301 or 410
   //   MAY be stored by a cache and used in reply to a subsequent request,
   //   subject to the expiration mechanism, unless a cache-control directive
   //   prohibits caching.
   //   ...
@@ skipping 14 matching lines @@
   // https://datatracker.ietf.org/doc/draft-reschke-http-status-308/ is an
   // experimental RFC that adds 308 permanent redirect as well, for which "any
   // future references ... SHOULD use one of the returned URIs."
   if ((response_code_ == 200 || response_code_ == 203 ||
        response_code_ == 206) && !must_revalidate) {
     // TODO(darin): Implement a smarter heuristic.
     Time last_modified_value;
     if (GetLastModifiedValue(&last_modified_value)) {
       // The last-modified value can be a date in the future!
       if (last_modified_value <= date_value) {
-        lifetimes.fresh = (date_value - last_modified_value) / 10;
+        lifetimes.freshness = (date_value - last_modified_value) / 10;
         return lifetimes;
       }
     }
   }
 
   // These responses are implicitly fresh (unless otherwise overruled):
   if (response_code_ == 300 || response_code_ == 301 || response_code_ == 308 ||
       response_code_ == 410) {
-    lifetimes.fresh = TimeDelta::Max();
-    lifetimes.stale = TimeDelta();  // It should never be stale.
+    lifetimes.freshness = TimeDelta::Max();
+    lifetimes.staleness = TimeDelta();  // It should never be stale.
     return lifetimes;
   }
 
   // Our heuristic freshness estimate for this resource is 0 seconds, in
   // accordance with common browser behaviour. However, stale-while-revalidate
   // may still apply.
-  DCHECK(lifetimes.fresh == TimeDelta());
+  DCHECK_EQ(TimeDelta(), lifetimes.freshness);
   return lifetimes;
 }
 
 // From RFC 2616 section 13.2.3:
 //
 // Summary of age calculation algorithm, when a cache receives a response:
 //
 //   /*
 //    * age_value
 //    *      is the value of Age: header received by the cache with
@@ skipping 332 matching lines @@
   return true;
 }
 
 bool HttpResponseHeaders::IsChunkEncoded() const {
   // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
   return GetHttpVersion() >= HttpVersion(1, 1) &&
       HasHeaderValue("Transfer-Encoding", "chunked");
 }
 
 }  // namespace net