Fix HTTPCacheTransaction conditionalization header check.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
@@ skipping 279 matching lines @@
   static bool not_modified_;
   static bool modified_;
   static bool bad_200_;
   DISALLOW_COPY_AND_ASSIGN(RangeTransactionServer);
 };
 bool RangeTransactionServer::not_modified_ = false;
 bool RangeTransactionServer::modified_ = false;
 bool RangeTransactionServer::bad_200_ = false;
 
 // A dummy extra header that must be preserved on a given request.
-#define EXTRA_HEADER "Extra: header"
+
+// EXTRA_HEADER_LINE doesn't include a line terminator because it
+// will be passed to AddHeaderFromString() which doesn't accept them.
+#define EXTRA_HEADER_LINE "Extra: header"
+
+// EXTRA_HEADER contains a line terminator, as expected by
+// AddHeadersFromString() (_not_ AddHeaderFromString()).
+#define EXTRA_HEADER EXTRA_HEADER_LINE "\r\n"
+
 static const char kExtraHeaderKey[] = "Extra";
 
 // Static.
 void RangeTransactionServer::RangeHandler(const net::HttpRequestInfo* request,
                                           std::string* response_status,
                                           std::string* response_headers,
                                           std::string* response_data) {
   if (request->extra_headers.IsEmpty()) {
     response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
     response_data->clear();
@@ skipping 494 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests LOAD_PREFERRING_CACHE in the presence of vary headers.
 TEST(HttpCache, SimpleGET_LoadPreferringCache_VaryMatch) {
   MockHttpCache cache;
 
   // Write to the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.request_headers = "Foo: bar\n";
+  transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers = "Cache-Control: max-age=10000\n"
                                  "Vary: Foo\n";
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Read from the cache.
   transaction.load_flags |= net::LOAD_PREFERRING_CACHE;
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests LOAD_PREFERRING_CACHE in the presence of vary headers.
 TEST(HttpCache, SimpleGET_LoadPreferringCache_VaryMismatch) {
   MockHttpCache cache;
 
   // Write to the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.request_headers = "Foo: bar\n";
+  transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers = "Cache-Control: max-age=10000\n"
                                  "Vary: Foo\n";
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Attempt to read from the cache... this is a vary mismatch that must reach
   // the network again.
   transaction.load_flags |= net::LOAD_PREFERRING_CACHE;
-  transaction.request_headers = "Foo: none\n";
+  transaction.request_headers = "Foo: none\r\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   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 LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
 // network success
@@ skipping 180 matching lines @@
 }
 
 TEST(HttpCache, SimpleGET_LoadBypassCache_Implicit) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.request_headers = "pragma: no-cache";
+  transaction.request_headers = "pragma: no-cache\r\n";
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimpleGET_LoadBypassCache_Implicit2) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.request_headers = "cache-control: no-cache";
+  transaction.request_headers = "cache-control: no-cache\r\n";
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimpleGET_LoadValidateCache) {
   MockHttpCache cache;
@@ skipping 22 matching lines @@
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // read from the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // force this transaction to validate the cache
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.request_headers = "cache-control: max-age=0";
+  transaction.request_headers = "cache-control: max-age=0\r\n";
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 static void PreserveRequestHeaders_Handler(
     const net::HttpRequestInfo* request,
@@ skipping 829 matching lines @@
     response_data->assign(kTypicalGET_Transaction.data);
   }
 }
 
 // Tests revalidation after a vary match.
 TEST(HttpCache, SimpleGET_LoadValidateCache_VaryMatch) {
   MockHttpCache cache;
 
   // Write to the cache.
   MockTransaction transaction(kTypicalGET_Transaction);
-  transaction.request_headers = "Foo: bar\n";
+  transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=0\n"
       "Vary: Foo\n";
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Read from the cache.
   RevalidationServer server;
   transaction.handler = server.Handler;
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_TRUE(server.EtagUsed());
   EXPECT_TRUE(server.LastModifiedUsed());
   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 revalidation after a vary mismatch if etag is present.
 TEST(HttpCache, SimpleGET_LoadValidateCache_VaryMismatch) {
   MockHttpCache cache;
 
   // Write to the cache.
   MockTransaction transaction(kTypicalGET_Transaction);
-  transaction.request_headers = "Foo: bar\n";
+  transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=0\n"
       "Vary: Foo\n";
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Read from the cache and revalidate the entry.
   RevalidationServer server;
   transaction.handler = server.Handler;
-  transaction.request_headers = "Foo: none\n";
+  transaction.request_headers = "Foo: none\r\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_TRUE(server.EtagUsed());
   EXPECT_FALSE(server.LastModifiedUsed());
   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 lack of revalidation after a vary mismatch and no etag.
 TEST(HttpCache, SimpleGET_LoadDontValidateCache_VaryMismatch) {
   MockHttpCache cache;
 
   // Write to the cache.
   MockTransaction transaction(kTypicalGET_Transaction);
-  transaction.request_headers = "Foo: bar\n";
+  transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Cache-Control: max-age=0\n"
       "Vary: Foo\n";
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Read from the cache and don't revalidate the entry.
   RevalidationServer server;
   transaction.handler = server.Handler;
-  transaction.request_headers = "Foo: none\n";
+  transaction.request_headers = "Foo: none\r\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_FALSE(server.EtagUsed());
   EXPECT_FALSE(server.LastModifiedUsed());
   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);
 }
 
@@ skipping 38 matching lines @@
   // Write to the cache.
   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());
 
   // Get the same URL again, but use a byte range request.
   transaction.load_flags = net::LOAD_VALIDATE_CACHE;
   transaction.handler = ETagGet_UnconditionalRequest_Handler;
-  transaction.request_headers = "Range: bytes = 5-";
+  transaction.request_headers = "Range: bytes = 5-\r\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 static void ETagGet_ConditionalRequest_NoStore_Handler(
     const net::HttpRequestInfo* request,
     std::string* response_status,
@@ skipping 159 matching lines @@
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   const char* extra_headers =
-      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse2, extra_headers);
 }
 
 // Check that when an "if-none-match" header is attached
 // to the request, the result updates the cached entry.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache2) {
   // First network response for |kUrl|.
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Etag: \"ETAG1\"\n"
     "Expires: Wed, 7 Sep 2033 21:46:42 GMT\n",  // Should never expire.
     "body1"
   };
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"ETAG2\"\n"
     "Expires: Wed, 7 Sep 2033 21:46:42 GMT\n",  // Should never expire.
     "body2"
   };
 
-  const char* extra_headers = "If-None-Match: \"ETAG1\"\n";
+  const char* extra_headers = "If-None-Match: \"ETAG1\"\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse2, extra_headers);
 }
 
 // Check that when an "if-modified-since" header is attached
 // to a request, the 304 (not modified result) result updates the cached
 // headers, and the 304 response is returned rather than the cached response.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache3) {
   // First network response for |kUrl|.
@@ skipping 16 matching lines @@
 
   static const Response kCachedResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Server: server2\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "body1"
   };
 
   const char* extra_headers =
-      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kCachedResponse2, extra_headers);
 }
 
 // Test that when doing an externally conditionalized if-modified-since
 // and there is no corresponding cache entry, a new cache entry is NOT
 // created (304 response).
 TEST(HttpCache, ConditionalizedRequestUpdatesCache4) {
   MockHttpCache cache;
 
   const char* kUrl = "http://foobar.com/main.css";
 
   static const Response kNetResponse = {
     "HTTP/1.1 304 Not Modified",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     ""
   };
 
   const char* kExtraRequestHeaders =
-      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
 
   // We will control the network layer's responses for |kUrl| using
   // |mock_network_response|.
   MockTransaction mock_network_response = { 0 };
   mock_network_response.url = kUrl;
   AddMockTransaction(&mock_network_response);
 
   MockTransaction request = { 0 };
   request.url = kUrl;
   request.method = "GET";
@@ skipping 23 matching lines @@
   const char* kUrl = "http://foobar.com/main.css";
 
   static const Response kNetResponse = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "foobar!!!"
   };
 
   const char* kExtraRequestHeaders =
-      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
 
   // We will control the network layer's responses for |kUrl| using
   // |mock_network_response|.
   MockTransaction mock_network_response = { 0 };
   mock_network_response.url = kUrl;
   AddMockTransaction(&mock_network_response);
 
   MockTransaction request = { 0 };
   request.url = kUrl;
   request.method = "GET";
@@ skipping 32 matching lines @@
     "HTTP/1.1 304 Not Modified",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Server: server2\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     ""
   };
 
   // This is two days in the future from the original response's last-modified
   // date!
   const char* kExtraRequestHeaders =
-      "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\n";
+      "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 // Test that when doing an externally conditionalized if-none-match
 // if the etag does not match the cache entry's etag, then we do not use the
 // response (304) to update the cache.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache7) {
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Etag: \"Foo1\"\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "body1"
   };
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 304 Not Modified",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     ""
   };
 
   // Different etag from original response.
-  const char* kExtraRequestHeaders = "If-None-Match: \"Foo2\"\n";
+  const char* kExtraRequestHeaders = "If-None-Match: \"Foo2\"\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 // Test that doing an externally conditionalized request with both if-none-match
 // and if-modified-since updates the cache.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache8) {
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
@@ skipping 35 matching lines @@
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   // The etag doesn't match what we have stored.
   const char* kExtraRequestHeaders =
-      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n"
-      "If-None-Match: \"Foo2\"\n";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n"
+      "If-None-Match: \"Foo2\"\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 // Test that doing an externally conditionalized request with both if-none-match
 // and if-modified-since does not update the cache with only one match.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache10) {
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Etag: \"Foo1\"\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "body1"
   };
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   // The modification date doesn't match what we have stored.
   const char* kExtraRequestHeaders =
-      "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\n"
-      "If-None-Match: \"Foo1\"\n";
+      "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\r\n"
+      "If-None-Match: \"Foo1\"\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
-}
-
-// Test that doing an externally conditionalized request with two conflicting
-// headers does not update the cache.
-TEST(HttpCache, ConditionalizedRequestUpdatesCache11) {
-  static const Response kNetResponse1 = {
-    "HTTP/1.1 200 OK",
-    "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
-    "Etag: \"Foo1\"\n"
-    "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
-    "body1"
-  };
-
-  // Second network response for |kUrl|.
-  static const Response kNetResponse2 = {
-    "HTTP/1.1 200 OK",
-    "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
-    "Etag: \"Foo2\"\n"
-    "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
-    "body2"
-  };
-
-  // Two dates, the second matches what we have stored.
-  const char* kExtraRequestHeaders =
-      "If-Modified-Since: Mon, 04 Feb 2008 22:38:21 GMT\n"
-      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n";
-
-  ConditionalizedRequestUpdatesCacheHelper(
-      kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 TEST(HttpCache, UrlContainingHash) {
   MockHttpCache cache;
 
   // Do a typical GET request -- should write an entry into our cache.
   MockTransaction trans(kTypicalGET_Transaction);
   RunTransactionTest(cache.http_cache(), trans);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
@@ skipping 499 matching lines @@
   // want to cache these, but we'll still have cases where skipping the cache
   // makes sense, so we want to make sure that it works properly.
 
   RunTransactionTest(cache.http_cache(), kRangeGET_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());
 
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.request_headers = "If-None-Match: foo";
+  transaction.request_headers = "If-None-Match: foo\r\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-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT";
+      "If-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT\r\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());
 }
 
 // Test that we skip the cache for range requests that include a validation
 // header.
 TEST(HttpCache, RangeGET_SkipsCache2) {
   MockHttpCache cache;
 
   MockTransaction transaction(kRangeGET_Transaction);
   transaction.request_headers = "If-None-Match: foo\r\n"
                                 EXTRA_HEADER
-                                "\r\nRange: bytes = 40-49";
+                                "Range: bytes = 40-49\r\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\r\n"
       EXTRA_HEADER
-      "\r\nRange: bytes = 40-49";
+      "Range: bytes = 40-49\r\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\r\n"
                                 EXTRA_HEADER
-                                "\r\nRange: bytes = 40-49\n";
+                                "Range: bytes = 40-49\r\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;
@@ skipping 2141 matching lines @@
   MockTransaction mock_network_response = { 0 };
   mock_network_response.url = kUrl;
 
   AddMockTransaction(&mock_network_response);
 
   // Request |kUrl|, causing |kNetResponse1| to be written to the cache.
 
   MockTransaction request = { 0 };
   request.url = kUrl;
   request.method = "GET";
-  request.request_headers = "";
+  request.request_headers = "\r\n";
   request.data = kData;
 
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     kData
   };
 
   kNetResponse1.AssignTo(&mock_network_response);
@@ skipping 292 matching lines @@
   EXPECT_TRUE(truncated);
   entry->Close();
 }
 
 // Tests that we handle truncated enries when StopCaching is called.
 TEST(HttpCache, StopCachingTruncatedEntry) {
   MockHttpCache cache;
   net::TestCompletionCallback callback;
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.extra_headers.Clear();
-  request.extra_headers.AddHeaderFromString(EXTRA_HEADER);
+  request.extra_headers.AddHeaderFromString(EXTRA_HEADER_LINE);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   {
@@ skipping 176 matching lines @@
   trans->SetPriority(net::HIGHEST);
   // Should trigger a new network transaction and pick up the new
   // priority.
   ReadAndVerifyTransaction(trans.get(), transaction);
 
   EXPECT_EQ(net::HIGHEST,
             cache.network_layer()->last_create_transaction_priority());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }