Initial implementation of Chrome-Freshness header.

net/http/http_cache_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 "net/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 6425 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   // Read bytes 20-29 and 50-59 from the network, bytes 30-49 from the cache.
   transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
   transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
   received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
   EXPECT_EQ(range_response_size * 2, received_bytes);
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
+
+static void CheckResourceFreshnessHeader(const net::HttpRequestInfo* request,
+                                         std::string* response_status,
+                                         std::string* response_headers,
+                                         std::string* response_data) {
+  std::string value;
+  EXPECT_TRUE(
+      request->extra_headers.GetHeader("Chromium-Resource-Freshness", &value));
+  EXPECT_EQ("max-age=3600,stale-while-revalidate=7200,age=10801", value);
+}
+
+// Verify that the Chromium-Resource-Freshness header is sent on a revalidation
+// if the stale-while-revalidate directive was on the response.
+// TODO(ricea): Rename this test when a final name for the header is decided.
+TEST(HttpCache, ResourceFreshnessHeaderSent) {
+  MockHttpCache cache;
+
+  const MockTransaction kStaleWhileRevalidateTransaction = {

[rvargas (doing something else), 2014/07/28 19:24:00]

It may be more clear to use a predefined transaction (kSimpleGET ?) and override
the response headers. That way there is less noise of things that are not
related to the test.

[Adam Rice, 2014/07/29 17:04:45]

Done.

+      "http://www.example.com/stale-while-revalidate",
+      "GET",
+      base::Time(),
+      "",
+      net::LOAD_NORMAL,
+      "HTTP/1.1 200 OK",
+      "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+      "Age: 10801\n"
+      "Cache-Control: max-age=3600,stale-while-revalidate=7200\n",
+      base::Time(),
+      "<title>Testing stale-while-revalidate</title>",
+      TEST_MODE_SYNC_NET_START,
+      NULL,
+      0,
+      net::OK};
+
+  ScopedMockTransaction stale_while_revalidate_transaction(
+      kStaleWhileRevalidateTransaction);
+
+  // Write to the cache.
+  RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+
+  // Send the request again and check that Chromium-Resource-Freshness header is
+  // added.
+  stale_while_revalidate_transaction.handler = CheckResourceFreshnessHeader;
+
+  RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
+
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+}
+
+static void CheckResourceFreshnessAbsent(const net::HttpRequestInfo* request,
+                                         std::string* response_status,
+                                         std::string* response_headers,
+                                         std::string* response_data) {
+  EXPECT_FALSE(request->extra_headers.HasHeader("Chromium-Resource-Freshness"));
+}
+
+// Verify that the Chromium-Resource-Freshness header is not sent when
+// stale-while-revalidate is 0.
+TEST(HttpCache, ResourceFreshnessHeaderNotSent) {
+  MockHttpCache cache;
+
+  const MockTransaction kStaleWhileRevalidateTransaction = {
+      "http://www.example.com/stale-while-revalidate",
+      "GET",
+      base::Time(),
+      "",
+      net::LOAD_NORMAL,
+      "HTTP/1.1 200 OK",
+      "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+      "Age: 10801\n"
+      "Cache-Control: max-age=3600,stale-while-revalidate=0\n",
+      base::Time(),
+      "<title>Testing stale-while-revalidate</title>",
+      TEST_MODE_SYNC_NET_START,
+      NULL,
+      0,
+      net::OK};
+
+  ScopedMockTransaction stale_while_revalidate_transaction(
+      kStaleWhileRevalidateTransaction);
+
+  // Write to the cache.
+  RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+
+  // Send the request again and check that Chromium-Resource-Freshness header is
+  // absent.
+  stale_while_revalidate_transaction.handler = CheckResourceFreshnessAbsent;
+
+  RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
+
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+}