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

webkit/media/cache_util_unittest.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/stringprintf.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLResponse.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using WebKit::WebString;
+using WebKit::WebURLResponse;
+
+namespace webkit_media {
+
+// Inputs & expected output for GetReasonsForUncacheability.
+struct GRFUTestCase {
+  WebURLResponse::HTTPVersion version;
+  int status_code;
+  const char* headers;
+  const char* expected_reasons;
+};
+
+// Create a new WebURLResponse object.
+static WebURLResponse CreateResponse(const GRFUTestCase& test) {
+  WebURLResponse response;
+  response.initialize();
+  response.setHTTPVersion(test.version);
+  response.setHTTPStatusCode(test.status_code);
+  std::vector<std::string> lines;
+  Tokenize(test.headers, "\n", &lines);
+  for (size_t i = 0; i < lines.size(); ++i) {
+    size_t colon = lines[i].find(": ");
+    response.addHTTPHeaderField(
+        WebString::fromUTF8(lines[i].substr(0, colon)),
+        WebString::fromUTF8(lines[i].substr(colon + 2)));
+  }
+  return response;
+}
+
+TEST(CacheUtilTest, GetReasonsForUncacheability) {
+  const GRFUTestCase tests[] = {
+    {
+      WebURLResponse::HTTP_1_1, 206, "ETag: 'fooblort'", ""
+    },
+    {
+      WebURLResponse::HTTP_1_1, 206, "", "3"
+    },
+    {
+      WebURLResponse::HTTP_1_0, 206, "", "2,3"
+    },
+    {
+      WebURLResponse::HTTP_1_1, 200, "cache-control: max-age=42", "4"
+    },
+    {
+      WebURLResponse::HTTP_1_1, 200,
+      "Date: Tue, 22 May 2012 23:46:08 GMT\n"
+      "Expires: Tue, 22 May 2012 23:56:08 GMT", "5"
+    },
+    {
+      WebURLResponse::HTTP_1_1, 200, "cache-control: must-revalidate", "6"
+    },
+    {
+      WebURLResponse::HTTP_1_1, 200, "cache-control: no-cache", "7"
+    },
+    {
+      WebURLResponse::HTTP_1_1, 200, "cache-control: no-store", "8"
+    },
+    {
+      WebURLResponse::HTTP_1_1, 200,
+      "cache-control: no-cache\ncache-control: no-store", "7,8"
+    },
+  };
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    SCOPED_TRACE(StringPrintf("case: %zu, version: %d, code: %d, headers: %s",
+                              i, tests[i].version, tests[i].status_code,
+                              tests[i].headers));
+    std::vector<UncacheableReason> reasons =

[darin (slow to review), 2012/05/23 20:35:01]

just an observation, but if you instead defined the reasons as bit-masks, then
you wouldn't have to hard-code string literals above that match the numeric
values of the enums.  you could instead write expressions like kNoCache |
kNoStore, which would be a lot more readable!

[Ami GONE FROM CHROMIUM, 2012/05/23 21:36:50]

True, but the reason I didn't do that is because that makes UMA-reporting more
expensive.  With 8 reasons now, that requires 256 buckets, doubling whenever a
reason is added.
Of course that also makes UMA reporting more informative (combinations are
counted instead of individual reasons) but also more difficult to use
(individual reasons have to be summed out of the combinations).
In summary: I thought about it, but decided not to :)

+        GetReasonsForUncacheability(CreateResponse(tests[i]));
+    std::string reasons_str;
+    for (size_t r = 0; r < reasons.size(); ++r) {
+      reasons_str.append(base::IntToString(reasons[r]));
+      if (r + 1 < reasons.size())
+        reasons_str.append(",");
+    }
+    EXPECT_EQ(tests[i].expected_reasons, reasons_str);
+  }
+}
+
+}  // namespace webkit_media