Add GetExpirationTimes() to HttpResponseHeader.

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"
@@ skipping 887 matching lines @@
           response_code == 303 ||
           response_code == 307);
 }
 
 // From RFC 2616 section 13.2.4:
 //
 // The calculation to determine if a response has expired is quite simple:
 //
 //   response_is_fresh = (freshness_lifetime > current_age)
 //
+// Into this equation, we substitute |current_age = now - freshness_origin|,
+// giving:
+//
+//   response_is_fresh = (freshness_lifetime > now - freshness_origin)
+//
+//   response_is_fresh = (freshness_lifetime + freshness_origin > now)
+//
+// And we call this quantity |freshness_lifetime + freshness_origin| the
+// freshness_expiry.
+//
 // Of course, there are other factors that can force a response to always be
 // validated or re-fetched.
 //
-bool HttpResponseHeaders::RequiresValidation(const Time& request_time,
-                                             const Time& response_time,
-                                             const Time& current_time) const {
-  TimeDelta lifetime =
-      GetFreshnessLifetime(response_time);
-  if (lifetime == TimeDelta())
-    return true;
+Time HttpResponseHeaders::GetFreshnessExpiry(Time request_time,
+                                             Time response_time) const {
+  TimeDelta lifetime;
+  bool finite_lifetime;
+  GetFreshnessLifetime(response_time, &lifetime, &finite_lifetime);
+  if (!finite_lifetime)
+    return Time::Max();
+  Time origin = GetFreshnessOrigin(request_time, response_time);
+  return origin + lifetime;
+}
 
-  return lifetime <= GetCurrentAge(request_time, response_time, current_time);
+bool HttpResponseHeaders::RequiresValidation(base::Time request_time,
+                                             base::Time response_time,
+                                             base::Time current_time) const {
+  return GetFreshnessExpiry(request_time, response_time) <= current_time;
 }
 
+
 // 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
 //
-TimeDelta HttpResponseHeaders::GetFreshnessLifetime(
-    const Time& response_time) const {
+void HttpResponseHeaders::GetFreshnessLifetime(
+    Time response_time,
+    TimeDelta* finite_freshness_lifetime,
+    bool* was_finite) const {
+  *finite_freshness_lifetime = TimeDelta();
+  *was_finite = true;
+
   // 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") ||
       HasHeaderValue("vary", "*"))  // see RFC 2616 section 13.6
-    return TimeDelta();  // not fresh
+    return;  // not fresh
 
   // NOTE: "Cache-Control: max-age" overrides Expires, so we only check the
   // Expires header after checking for max-age in GetFreshnessLifetime.  This
   // is important since "Expires: <date in the past>" means not fresh, but
   // it should not trump a max-age value.
 
-  TimeDelta max_age_value;
-  if (GetMaxAgeValue(&max_age_value))
-    return max_age_value;
+  if (GetMaxAgeValue(finite_freshness_lifetime))
+    return;
 
   // 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)
-      return expires_value - date_value;
-
-    return TimeDelta();  // not fresh
+      *finite_freshness_lifetime = expires_value - date_value;
+    return;
   }
 
   // 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.
   //   ...
   //   A response received with any other status code (e.g. status codes 302
@@ skipping 11 matching lines @@
   //   the cached response is stale.)
   //
   if ((response_code_ == 200 || response_code_ == 203 ||
        response_code_ == 206) &&
       !HasHeaderValue("cache-control", "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 past!
       if (last_modified_value <= date_value)
-        return (date_value - last_modified_value) / 10;
+        *finite_freshness_lifetime = (date_value - last_modified_value) / 10;
+      return;
     }
   }
 
   // These responses are implicitly fresh (unless otherwise overruled):
-  if (response_code_ == 300 || response_code_ == 301 || response_code_ == 410)
-    return TimeDelta::FromMicroseconds(kint64max);

[gavinp, 2014/02/13 17:37:59]

This line is an abstraction violation that skates very close to using undefined
behaviour. There's no good way to test for this value in a TimeDelta, and so it
can't be used for time math. The current code works because no call site adds a
FreshnessLifetime to another time or time delta. That's a lucky break. The tests
for this CL failed because they do such adds, which overflow a base::Time and
have an undefined result. There's no good way to test for this without violating
abstractions even more. It's bad that this line is here, but it would be worse
to add more of this stuff.

This is why we had to change the signature of GetFreshnessLifetime() to have the
bool. I am not a fan of the signature that resulted from this change either. It
is too cryptic.

A better solution is to add, to base::TimeDelta, an idea of Max()/is_max() like
exists for base::Time(). I'm pursing this change in
https://chromiumcodereview.appspot.com/163413004/ which edits this line as
https://chromiumcodereview.appspot.com/163413004/diff/220001/net/http/http_re...
.

I'm rebasing this CL on top of that CL, so we can remove all changes to
GetFreshnessLifetime() from this CL.

+  if (response_code_ == 300 || response_code_ == 301 || response_code_ == 410) {
+    *was_finite = false;
+    return;
+  }
 
-  return TimeDelta();  // not fresh
+  return;  // not fresh.
 }
 
 // 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
 //    *              this response.
 //    * date_value
 //    *      is the value of the origin server's Date: header
 //    * request_time
 //    *      is the (local) time when the cache made the request
 //    *              that resulted in this cached response
 //    * response_time
 //    *      is the (local) time when the cache received the
 //    *              response
 //    * now
 //    *      is the current (local) time
 //    */
 //   apparent_age = max(0, response_time - date_value);
 //   corrected_received_age = max(apparent_age, age_value);
 //   response_delay = response_time - request_time;
 //   corrected_initial_age = corrected_received_age + response_delay;
 //   resident_time = now - response_time;
 //   current_age   = corrected_initial_age + resident_time;
 //
-TimeDelta HttpResponseHeaders::GetCurrentAge(const Time& request_time,
-                                             const Time& response_time,
-                                             const Time& current_time) const {
+// From this, we can derive the freshness origin, the time at which the
+// current_age = 0 and solve for now (aka freshness_origin):
+//
+//   corrected_initial_age + resident_time = 0
+//   corrected_initial_age + freshness_origin - response_time = 0
+//   freshness_origin = response_time - corrected_initial_age
+//
+Time HttpResponseHeaders::GetFreshnessOrigin(Time request_time,
+                                             Time response_time) const {
   // 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;
 
   // If there is no Age header, then assume age is zero.  GetAgeValue does not
   // modify its out param if the value does not exist.
   TimeDelta age_value;
   GetAgeValue(&age_value);
 
   TimeDelta apparent_age = std::max(TimeDelta(), response_time - date_value);
   TimeDelta corrected_received_age = std::max(apparent_age, age_value);
   TimeDelta response_delay = response_time - request_time;
   TimeDelta corrected_initial_age = corrected_received_age + response_delay;
-  TimeDelta resident_time = current_time - response_time;
-  TimeDelta current_age = corrected_initial_age + resident_time;
 
-  return current_age;
+  return response_time - corrected_initial_age;
 }
 
 bool HttpResponseHeaders::GetMaxAgeValue(TimeDelta* result) const {
   std::string name = "cache-control";
   std::string value;
 
   const char kMaxAgePrefix[] = "max-age=";
   const size_t kMaxAgePrefixLen = arraysize(kMaxAgePrefix) - 1;
 
   void* iter = NULL;
@@ skipping 340 matching lines @@
 
   // Next, look for 'bypass'.
   if (GetChromeProxyBypassDuration("bypass=", &proxy_info->bypass_duration))
     return true;
 
   return false;
 }
 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 
 }  // namespace net