Http cache: Always preserve extra headers when dealing with...

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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 "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 560 matching lines @@
                            std::string* response_data);
 
  private:
   static bool not_modified_;
   static bool modified_;
   DISALLOW_COPY_AND_ASSIGN(RangeTransactionServer);
 };
 bool RangeTransactionServer::not_modified_ = false;
 bool RangeTransactionServer::modified_ = false;
 
+// A dummy extra header that must be preserved on a given request.
+// TODO(rvargas): Add tests using this without byte ranges.
+#define EXTRA_HEADER "Extra: header\r\n"
+
 // Static.
 void RangeTransactionServer::RangeHandler(const net::HttpRequestInfo* request,
                                           std::string* response_status,
                                           std::string* response_headers,
                                           std::string* response_data) {
   if (request->extra_headers.empty()) {
     response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
     return;
   }
 
+  // We want to make sure we don't delete extra headers.
+  if (request->extra_headers.find(EXTRA_HEADER) == std::string::npos) {
+    response_status->assign("HTTP/1.1 403 Forbidden");
+    return;
+  }
+
   if (not_modified_) {
     response_status->assign("HTTP/1.1 304 Not Modified");
     return;
   }
 
   std::vector<net::HttpByteRange> ranges;
   if (!net::HttpUtil::ParseRanges(request->extra_headers, &ranges) ||
       ranges.size() != 1)
     return;
   // We can handle this range request.
@@ skipping 32 matching lines @@
   } else {
     response_status->assign("HTTP/1.1 304 Not Modified");
     response_data->clear();
   }
 }
 
 const MockTransaction kRangeGET_TransactionOK = {
   "http://www.google.com/range",
   "GET",
   base::Time(),
-  "Range: bytes = 40-49\r\n",
+  "Range: bytes = 40-49\r\n"
+  EXTRA_HEADER,
   net::LOAD_NORMAL,
   "HTTP/1.1 206 Partial Content",
   "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
   "ETag: \"foo\"\n"
   "Accept-Ranges: bytes\n"
   "Content-Length: 10\n",
   base::Time(),
   "rg: 40-49 ",
   TEST_MODE_NORMAL,
   &RangeTransactionServer::RangeHandler,
@@ skipping 1355 matching lines @@
 }
 
 // Test that we skip the cache for range requests that include a validation
 // header.
 TEST(HttpCache, RangeGET_SkipsCache2) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   MockTransaction transaction(kRangeGET_Transaction);
   transaction.request_headers = "If-None-Match: foo\n"
+                                EXTRA_HEADER
                                 "Range: bytes = 40-49\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 
   transaction.request_headers =
       "If-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT\n"
+      EXTRA_HEADER
       "Range: bytes = 40-49\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 
   transaction.request_headers = "If-Range: bla\n"
+                                EXTRA_HEADER
                                 "Range: bytes = 40-49\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that receiving 206 for a regular request is handled correctly.
 TEST(HttpCache, GET_Crazy206) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   // Write to the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
-  transaction.request_headers = "";
+  transaction.request_headers = EXTRA_HEADER;
   transaction.handler = NULL;
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // This should read again from the net.
   RunTransactionTest(cache.http_cache(), transaction);
 
@@ skipping 27 matching lines @@
   EXPECT_TRUE(Verify206Response(headers, 40, 49));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
   MessageLoop::current()->RunAllPending();
 
   // Write to the cache (30-39).
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "Range: bytes = 30-39\r\n";
+  transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
   transaction.data = "rg: 30-39 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 30, 39));
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
   MessageLoop::current()->RunAllPending();
 
   // Write and read from the cache (20-59).
-  transaction.request_headers = "Range: bytes = 20-59\r\n";
+  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 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 20, 59));
   EXPECT_EQ(5, cache.network_layer()->transaction_count());
   EXPECT_EQ(3, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
@@ skipping 67 matching lines @@
 // Tests that we can cache range requests when the start or end is unknown.
 // We start with one suffix request, followed by a request from a given point.
 TEST(HttpCache, UnknownRangeGET_1) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (70-79).
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "Range: bytes = -10\r\n";
+  transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 70, 79));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
   MessageLoop::current()->RunAllPending();
 
   // Write and read from the cache (60-79).
-  transaction.request_headers = "Range: bytes = 60-\r\n";
+  transaction.request_headers = "Range: bytes = 60-\r\n" EXTRA_HEADER;
   transaction.data = "rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 60, 79));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we can cache range requests when the start or end is unknown.
 // We start with one request from a given point, followed by a suffix request.
 // We'll also verify that synchronous cache responses work as intended.
 TEST(HttpCache, UnknownRangeGET_2) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.test_mode = TEST_MODE_SYNC_CACHE_START |
                           TEST_MODE_SYNC_CACHE_READ |
                           TEST_MODE_SYNC_CACHE_WRITE;
   AddMockTransaction(&transaction);
 
   // Write to the cache (70-79).
-  transaction.request_headers = "Range: bytes = 70-\r\n";
+  transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 70, 79));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure we are done with the previous transaction.
   MessageLoop::current()->RunAllPending();
 
   // Write and read from the cache (60-79).
-  transaction.request_headers = "Range: bytes = -20\r\n";
+  transaction.request_headers = "Range: bytes = -20\r\n" EXTRA_HEADER;
   transaction.data = "rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 60, 79));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that receiving Not Modified when asking for an open range doesn't mess
 // up things.
 TEST(HttpCache, UnknownRangeGET_304) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
 
   RangeTransactionServer handler;
   handler.set_not_modified(true);
 
   // Ask for the end of the file, without knowing the length.
-  transaction.request_headers = "Range: bytes = 70-\r\n";
+  transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   // We just bypass the cache.
   EXPECT_EQ(0U, headers.find("HTTP/1.1 304 Not Modified\n"));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RunTransactionTest(cache.http_cache(), transaction);
@@ skipping 13 matching lines @@
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 40, 49));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Write and read from the cache (0-79), when not asked for a range.
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "";
+  transaction.request_headers = EXTRA_HEADER;
   transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49 "
                      "rg: 50-59 rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we can handle non-range requests when we have cached the first
 // part of the object and server replies with 304 (Not Modified).
 TEST(HttpCache, GET_Previous206_NotModified) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "Range: bytes = 0-9\r\n";
+  transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
   transaction.data = "rg: 00-09 ";
   AddMockTransaction(&transaction);
   std::string headers;
 
   // Write to the cache (0-9).
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 0, 9));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Read from the cache (0-9), write and read from cache (10 - 79),
   MockTransaction transaction2(kRangeGET_TransactionOK);
-  transaction2.request_headers = "Foo: bar\r\n";
+  transaction2.request_headers = "Foo: bar\r\n" EXTRA_HEADER;
   transaction2.data = "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49 "
                       "rg: 50-59 rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
 
   EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&transaction);
@@ skipping 134 matching lines @@
 
 // Tests that we can handle a 200 response when dealing with sparse entries.
 TEST(HttpCache, RangeRequestResultsIn200) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (70-79).
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "Range: bytes = -10\r\n";
+  transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 70, 79));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Now we'll issue a request that results in a plain 200 response, but to
   // the to the same URL that we used to store sparse data, and making sure
@@ skipping 29 matching lines @@
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 40, 49));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // A weird request should not delete this entry. Ask for bytes 120-.
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "Range: bytes = 120-\r\n";
+  transaction.request_headers = "Range: bytes = 120-\r\n" EXTRA_HEADER;
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_EQ(0U, headers.find("HTTP/1.1 416 "));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 145 matching lines @@
 
 // Tests that if a server tells us conflicting information about a resource we
 // ignore the response.
 TEST(HttpCache, RangeGET_InvalidResponse3) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.handler = NULL;
-  transaction.request_headers = "Range: bytes = 50-59\r\n";
+  transaction.request_headers = "Range: bytes = 50-59\r\n" EXTRA_HEADER;
   std::string response_headers(transaction.response_headers);
   response_headers.append("Content-Range: bytes 50-59/160\n");
   transaction.response_headers = response_headers.c_str();
   AddMockTransaction(&transaction);
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 50, 59));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 26 matching lines @@
 TEST(HttpCache, RangeGET_LargeValues) {
   // We need a real sparse cache for this test.
   disk_cache::Backend* disk_cache =
       disk_cache::CreateInMemoryCacheBackend(1024 * 1024);
   MockHttpCache cache(disk_cache);
   cache.http_cache()->set_enable_range_support(true);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.handler = NULL;
-  transaction.request_headers = "Range: bytes = 4294967288-4294967297\r\n";
+  transaction.request_headers = "Range: bytes = 4294967288-4294967297\r\n"
+                                EXTRA_HEADER;
   transaction.response_headers =
       "Content-Range: bytes 4294967288-4294967297/4294967299\n"
       "Content-Length: 10\n";
   AddMockTransaction(&transaction);
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   std::string expected(transaction.status);
   expected.append("\n");
   expected.append(transaction.response_headers);
   EXPECT_EQ(expected, headers);
@@ skipping 183 matching lines @@
   EXPECT_TRUE(net::HttpCache::WriteResponseInfo(entry, &response, true, true));
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(100));
   int len = static_cast<int>(base::strlcpy(buf->data(),
                                            "rg: 00-09 rg: 10-19 ", 100));
   EXPECT_EQ(len, entry->WriteData(1, 0, buf, len, NULL, true));
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = "";
+  transaction.request_headers = EXTRA_HEADER;
   transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49 "
                      "rg: 50-59 rg: 60-69 rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   // We update the headers with the ones received while revalidating.
   std::string expected_headers(
       "HTTP/1.1 200 OK\n"
       "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
       "Accept-Ranges: bytes\n"
       "ETag: \"foo\"\n"
@@ skipping 391 matching lines @@
   std::string headers;
   response.headers->GetNormalizedHeaders(&headers);
 
   EXPECT_EQ("HTTP/1.1 200 OK\n"
             "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
             "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
             headers);
 
   RemoveMockTransaction(&mock_network_response);
 }