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();
 
-  return lifetime <= GetCurrentAge(request_time, response_time, current_time);
+  // From RFC 2616 section 13.2.3:

[darin (slow to review), 2014/02/26 05:51:07]

hmm, I personally like exposing the current age calculation as a primitive
method on this class, but I suppose if we don't need it elsewhere, then it
doesn't strictly speaking need to be a separate method.

[gavinp, 2014/02/26 17:12:28]

I like exposing it too. But we can't calculate current_age because we don't have
a current_time. The spec is pretty silent on what to call this thing I've been
calling freshness_origin. In the definition of "freshness lifetime" in RFC 2616
1.3, it's called the time of "generation of a response" which doesn't suggest a
good name. In the discussion in 13.2.3, it's not named either.

How about "corrected response time" as the name? That's never used in the RFC,
but it's in keeping with the other nomenclature?

+  //
+  // 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;
+  //
+
+  // 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;
+
+  // From the age calculation algorithm above, we can derive the freshness
+  // origin, the |now| for which |current_age = 0|. Substituting into the
+  // RFC 2616 13.2.3 equations and simplifying:
+  //
+  //   0 = corrected_initial_age + resident_time
+  //
+  //   corrected_initial_age + freshness_origin - response_time = 0
+  //
+  //   freshness_origin = response_time - corrected_initial_age
+
+  Time freshness_origin = response_time - corrected_initial_age;
+  return freshness_origin + lifetime;
 }
 
 // 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 53 matching lines @@
     }
   }
 
   // These responses are implicitly fresh (unless otherwise overruled):
   if (response_code_ == 300 || response_code_ == 301 || response_code_ == 410)
     return TimeDelta::Max();
 
   return TimeDelta();  // 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 {
-  // 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;
-}
-
 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;
   while (EnumerateHeader(&iter, name, &value)) {
     if (value.size() > kMaxAgePrefixLen) {
@@ skipping 363 matching lines @@
   iter = NULL;
   while (EnumerateHeader(&iter, "via", &value))
     if (value == kDeprecatedChromeProxyViaValue)
       return true;
 
   return false;
 }
 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 
 }  // namespace net