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 =  GetFreshnessLifetime(response_time);
+  if (lifetime.is_max())
+    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,

[gavinp, 2014/02/13 18:50:26]

s/base::Time/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 {
+TimeDelta HttpResponseHeaders::GetFreshnessLifetime(Time response_time) const {
   // 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
 
   // NOTE: "Cache-Control: max-age" overrides Expires, so we only check the
@@ skipping 79 matching lines @@
 //    * 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