Suppress pause-and-buffer behavior when the HTTP response won't satisfy future requests via cache.

webkit/media/cache_util.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.
+
+#include "webkit/media/cache_util.h"
+
+#include <string>
+
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "base/time.h"
+#include "net/http/http_util.h"
+#include "net/http/http_version.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLResponse.h"
+
+using base::Time;
+using base::TimeDelta;
+using net::HttpVersion;
+using WebKit::WebURLResponse;
+
+namespace webkit_media {
+
+enum { kHttpOK = 200, kHttpPartialContent = 206 };
+
+std::vector<UncacheableReason> GetReasonsForUncacheability(

[darin (slow to review), 2012/05/23 23:38:43]

the next logical step is to return an integer that is just the union of the
flags.

[Ami GONE FROM CHROMIUM, 2012/05/23 23:44:06]

I think that's a worse API, though.  Don't you?

+    const WebURLResponse& response) {
+  std::vector<UncacheableReason> reasons;
+  const int code = response.httpStatusCode();
+  const int version = response.httpVersion();
+  const HttpVersion http_version =
+      version == WebURLResponse::HTTP_1_1 ? HttpVersion(1, 1) :
+      version == WebURLResponse::HTTP_1_0 ? HttpVersion(1, 0) :
+      version == WebURLResponse::HTTP_0_9 ? HttpVersion(0, 9) :
+      HttpVersion();
+  if (code != kHttpOK && code != kHttpPartialContent)
+    reasons.push_back(kNoData);

[darin (slow to review), 2012/05/23 23:38:43]

reasons |= kNoData;

etc.

+  if (http_version < HttpVersion(1, 1) && code == kHttpPartialContent)
+    reasons.push_back(kPre11PartialResponse);
+  if (code == kHttpPartialContent &&
+      !net::HttpUtil::HasStrongValidators(
+          http_version,
+          response.httpHeaderField("etag").utf8(),
+          response.httpHeaderField("Last-Modified").utf8(),
+          response.httpHeaderField("Date").utf8())) {
+    reasons.push_back(kNoStrongValidatorOnPartialResponse);
+  }
+
+  std::string cache_control_header =
+      response.httpHeaderField("cache-control").utf8();
+  StringToLowerASCII(&cache_control_header);
+  if (cache_control_header.find("no-cache") != std::string::npos)
+    reasons.push_back(kNoCache);
+  if (cache_control_header.find("no-store") != std::string::npos)
+    reasons.push_back(kNoStore);
+  if (cache_control_header.find("must-revalidate") != std::string::npos)
+    reasons.push_back(kHasMustRevalidate);
+
+  const TimeDelta kMinimumAgeForUsefulness =
+      TimeDelta::FromSeconds(3600);  // Arbitrary value.
+
+  const char kMaxAgePrefix[] = "max-age=";
+  const size_t kMaxAgePrefixLen = arraysize(kMaxAgePrefix) - 1;
+  if (LowerCaseEqualsASCII(cache_control_header.begin(),
+                           cache_control_header.begin() + kMaxAgePrefixLen,
+                           kMaxAgePrefix)) {
+    int64 max_age_seconds;
+    base::StringToInt64(
+        base::StringPiece(cache_control_header.begin() + kMaxAgePrefixLen,
+                          cache_control_header.end()),
+        &max_age_seconds);
+    if (TimeDelta::FromSeconds(max_age_seconds) < kMinimumAgeForUsefulness)
+      reasons.push_back(kShortMaxAge);
+  }
+
+  Time date;
+  Time expires;
+  if (Time::FromString(response.httpHeaderField("Date").utf8().data(), &date) &&
+      Time::FromString(response.httpHeaderField("Expires").utf8().data(),
+                       &expires) &&
+      date > Time() && expires > Time() &&
+      (expires - date) < kMinimumAgeForUsefulness) {
+    reasons.push_back(kExpiresTooSoon);
+  }
+
+  return reasons;
+}
+
+}  // namespace webkit_media