Roll Chrome into Mojo.

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 167 matching lines @@
                                     net::LoadTimingInfo* load_timing_info) {
   RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
                          NULL, log, load_timing_info, NULL);
 }
 
 void RunTransactionTest(net::HttpCache* cache,
                         const MockTransaction& trans_info) {
   RunTransactionTestAndGetTiming(cache, trans_info, net::BoundNetLog(), NULL);
 }
 
+void RunTransactionTestWithLog(net::HttpCache* cache,
+                               const MockTransaction& trans_info,
+                               const net::BoundNetLog& log) {
+  RunTransactionTestAndGetTiming(cache, trans_info, log, NULL);
+}
+
 void RunTransactionTestWithResponseInfo(net::HttpCache* cache,
                                         const MockTransaction& trans_info,
                                         net::HttpResponseInfo* response) {
   RunTransactionTestWithRequest(cache, trans_info, MockHttpRequest(trans_info),
                                 response);
 }
 
 void RunTransactionTestWithResponseInfoAndGetTiming(
     net::HttpCache* cache,
     const MockTransaction& trans_info,
@@ skipping 82 matching lines @@
 
   // Returns only 416 or 304 when set.
   void set_not_modified(bool value) { not_modified_ = value; }
 
   // Returns 206 when revalidating a range (instead of 304).
   void set_modified(bool value) { modified_ = value; }
 
   // Returns 200 instead of 206 (a malformed response overall).
   void set_bad_200(bool value) { bad_200_ = value; }
 
+  // Other than regular range related behavior (and the flags mentioned above),
+  // the server reacts to requests headers like so:
+  //   X-Require-Mock-Auth -> return 401.
+  //   X-Return-Default-Range -> assume 40-49 was requested.
   static void RangeHandler(const net::HttpRequestInfo* request,
                            std::string* response_status,
                            std::string* response_headers,
                            std::string* response_data);
 
  private:
   static bool not_modified_;
   static bool modified_;
   static bool bad_200_;
   DISALLOW_COPY_AND_ASSIGN(RangeTransactionServer);
@@ skipping 49 matching lines @@
       ranges.size() != 1) {
     // This is not a byte range request. We return 200.
     response_status->assign("HTTP/1.1 200 OK");
     response_headers->assign("Date: Wed, 28 Nov 2007 09:40:09 GMT");
     response_data->assign("Not a range");
     return;
   }
 
   // We can handle this range request.
   net::HttpByteRange byte_range = ranges[0];
+
+  if (request->extra_headers.HasHeader("X-Return-Default-Range")) {
+    byte_range.set_first_byte_position(40);
+    byte_range.set_last_byte_position(49);
+  }
+
   if (byte_range.first_byte_position() > 79) {
     response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
     response_data->clear();
     return;
   }
 
   EXPECT_TRUE(byte_range.ComputeBounds(80));
   int start = static_cast<int>(byte_range.first_byte_position());
   int end = static_cast<int>(byte_range.last_byte_position());
 
@@ skipping 44 matching lines @@
   "Accept-Ranges: bytes\n"
   "Content-Length: 10\n",
   base::Time(),
   "rg: 40-49 ",
   TEST_MODE_NORMAL,
   &RangeTransactionServer::RangeHandler,
   0,
   net::OK
 };
 
+const char kFullRangeData[] =
+    "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 "
+    "rg: 40-49 rg: 50-59 rg: 60-69 rg: 70-79 ";
+
 // Verifies the response headers (|response|) match a partial content
 // response for the range starting at |start| and ending at |end|.
 void Verify206Response(std::string response, int start, int end) {
   std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
                                                             response.size()));
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(raw_headers));
 
   ASSERT_EQ(206, headers->response_code());
 
@@ skipping 94 matching lines @@
 }
 
 // Modifies |entries| to only include log entries created by the cache layer and
 // asserted on in these tests.
 void FilterLogEntries(net::CapturingNetLog::CapturedEntryList* entries) {
   entries->erase(std::remove_if(entries->begin(), entries->end(),
                                 &ShouldIgnoreLogEntry),
                  entries->end());
 }
 
+bool LogContainsEventType(const net::CapturingBoundNetLog& log,
+                          net::NetLog::EventType expected) {
+  net::CapturingNetLog::CapturedEntryList entries;
+  log.GetEntries(&entries);
+  for (size_t i = 0; i < entries.size(); i++) {
+    if (entries[i].type == expected)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
 // Tests.
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
   scoped_ptr<net::HttpTransaction> trans;
@@ skipping 3073 matching lines @@
   transaction.request_headers = "If-Range: bla\r\n"
                                 EXTRA_HEADER
                                 "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());
 }
 
+TEST(HttpCache, SimpleGET_DoesntLogHeaders) {
+  MockHttpCache cache;
+
+  net::CapturingBoundNetLog log;
+  RunTransactionTestWithLog(cache.http_cache(), kSimpleGET_Transaction,
+                            log.bound());
+
+  EXPECT_FALSE(LogContainsEventType(
+      log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
+}
+
+TEST(HttpCache, RangeGET_LogsHeaders) {
+  MockHttpCache cache;
+
+  net::CapturingBoundNetLog log;
+  RunTransactionTestWithLog(cache.http_cache(), kRangeGET_Transaction,
+                            log.bound());
+
+  EXPECT_TRUE(LogContainsEventType(
+      log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
+}
+
+TEST(HttpCache, ExternalValidation_LogsHeaders) {
+  MockHttpCache cache;
+
+  net::CapturingBoundNetLog log;
+  MockTransaction transaction(kSimpleGET_Transaction);
+  transaction.request_headers = "If-None-Match: foo\r\n" EXTRA_HEADER;
+  RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
+
+  EXPECT_TRUE(LogContainsEventType(
+      log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
+}
+
+TEST(HttpCache, SpecialHeaders_LogsHeaders) {
+  MockHttpCache cache;
+
+  net::CapturingBoundNetLog log;
+  MockTransaction transaction(kSimpleGET_Transaction);
+  transaction.request_headers = "cache-control: no-cache\r\n" EXTRA_HEADER;
+  RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
+
+  EXPECT_TRUE(LogContainsEventType(
+      log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
+}
+
 // Tests that receiving 206 for a regular request is handled correctly.
 TEST(HttpCache, GET_Crazy206) {
   MockHttpCache cache;
 
   // Write to the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
   transaction.request_headers = EXTRA_HEADER;
   transaction.handler = NULL;
   RunTransactionTest(cache.http_cache(), transaction);
@@ skipping 21 matching lines @@
   transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
   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());
 
   RemoveMockTransaction(&transaction);
 }
 
-// Tests that we store partial responses that can't be validated, as they can
-// be used for requests that don't require revalidation.
+// Tests that we don't store partial responses that can't be validated.
 TEST(HttpCache, RangeGET_NoStrongValidators) {
   MockHttpCache cache;
   std::string headers;
 
-  // Write to the cache (40-49).
-  MockTransaction transaction(kRangeGET_TransactionOK);
-  AddMockTransaction(&transaction);
+  // Attempt to write to the cache (40-49).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.response_headers = "Content-Length: 10\n"
                                  "Cache-Control: max-age=3600\n"
                                  "ETag: w/\"foo\"\n";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   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());
 
-  // Now verify that there's cached data.
+  // Now verify that there's no cached data.
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   Verify206Response(headers, 40, 49);
-  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);
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
-// Tests failures to validate cache partial responses that lack strong
-// validators.
-TEST(HttpCache, RangeGET_NoValidation) {
+// Tests failures to conditionalize byte range requests.
+TEST(HttpCache, RangeGET_NoConditionalization) {
   MockHttpCache cache;
+  cache.FailConditionalizations();
   std::string headers;
 
   // Write to the cache (40-49).
-  MockTransaction transaction(kRangeGET_TransactionOK);
-  AddMockTransaction(&transaction);
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.response_headers = "Content-Length: 10\n"
-                                 "ETag: w/\"foo\"\n";
+                                 "ETag: \"foo\"\n";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   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());
+
+  // Now verify that the cached data is not used.
+  RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
+                                 &headers);
+
+  Verify206Response(headers, 40, 49);
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
+// Tests that restarting a partial request when the cached data cannot be
+// revalidated logs an event.
+TEST(HttpCache, RangeGET_NoValidation_LogsRestart) {
+  MockHttpCache cache;
+  cache.FailConditionalizations();
+
+  // Write to the cache (40-49).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.response_headers = "Content-Length: 10\n"
+                                 "ETag: \"foo\"\n";
+  RunTransactionTest(cache.http_cache(), transaction);
+
+  // Now verify that the cached data is not used.
+  net::CapturingBoundNetLog log;
+  RunTransactionTestWithLog(cache.http_cache(), kRangeGET_TransactionOK,
+                            log.bound());
+
+  EXPECT_TRUE(LogContainsEventType(
+      log, net::NetLog::TYPE_HTTP_CACHE_RESTART_PARTIAL_REQUEST));
+}
+
+// Tests that a failure to conditionalize a regular request (no range) with a
+// sparse entry results in a full response.
+TEST(HttpCache, GET_NoConditionalization) {
+  MockHttpCache cache;
+  cache.FailConditionalizations();
+  std::string headers;
+
+  // Write to the cache (40-49).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.response_headers = "Content-Length: 10\n"
+                                 "ETag: \"foo\"\n";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  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());
 
   // Now verify that the cached data is not used.
-  RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
-                                 &headers);
+  // Don't ask for a range. The cache will attempt to use the cached data but
+  // should discard it as it cannot be validated. A regular request should go
+  // to the server and a new entry should be created.
+  transaction.request_headers = EXTRA_HEADER;
+  transaction.data = "Not a range";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
-  Verify206Response(headers, 40, 49);
+  EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
-  RemoveMockTransaction(&transaction);
+  // The last response was saved.
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
+  EXPECT_EQ(2, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
+// Verifies that conditionalization failures when asking for a range that would
+// require the cache to modify the range to ask, result in a network request
+// that matches the user's one.
+TEST(HttpCache, RangeGET_NoConditionalization2) {
+  MockHttpCache cache;
+  cache.FailConditionalizations();
+  std::string headers;
+
+  // Write to the cache (40-49).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.response_headers = "Content-Length: 10\n"
+                                 "ETag: \"foo\"\n";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  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());
+
+  // Now verify that the cached data is not used.
+  // Ask for a range that extends before and after the cached data so that the
+  // cache would normally mix data from three sources. After deleting the entry,
+  // the response will come from a single network request.
+  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 ";
+  transaction.response_headers = kRangeGET_TransactionOK.response_headers;
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  Verify206Response(headers, 20, 59);
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+
+  // The last response was saved.
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(2, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we cache partial responses that lack content-length.
 TEST(HttpCache, RangeGET_NoContentLength) {
   MockHttpCache cache;
   std::string headers;
 
   // Attempt to write to the cache (40-49).
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
@@ skipping 73 matching lines @@
 
   Verify206Response(headers, 20, 59);
   EXPECT_EQ(4, cache.network_layer()->transaction_count());
   EXPECT_EQ(3, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
-// Checks that with a cache backend having Sparse IO unimplementes the cache
-// entry would be doomed after a range request.
-// TODO(pasko): remove when the SimpleBackendImpl implements Sparse IO.
-TEST(HttpCache, RangeGET_SparseNotImplemented) {
-  MockHttpCache cache;
-  cache.disk_cache()->set_fail_sparse_requests();
-
-  // Run a cacheable request to prime the cache.
-  MockTransaction transaction(kTypicalGET_Transaction);
-  transaction.url = kRangeGET_TransactionOK.url;
-  AddMockTransaction(&transaction);
-  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());
-
-  // Verify that we added the entry.
-  disk_cache::Entry* entry;
-  net::TestCompletionCallback cb;
-  int rv = cache.disk_cache()->OpenEntry(transaction.url,
-                                         &entry,
-                                         cb.callback());
-  ASSERT_EQ(net::OK, cb.GetResult(rv));
-  EXPECT_EQ(1, cache.disk_cache()->open_count());
-  entry->Close();
-  RemoveMockTransaction(&transaction);
-
-  // Request the range with the backend that does not support it.
-  MockTransaction transaction2(kRangeGET_TransactionOK);
-  std::string headers;
-  AddMockTransaction(&transaction2);
-  RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
-  EXPECT_EQ(2, cache.disk_cache()->open_count());
-  EXPECT_EQ(2, cache.disk_cache()->create_count());
-
-  // Mock cache would return net::ERR_CACHE_OPEN_FAILURE on a doomed entry, even
-  // if it was re-created later, so this effectively checks that the old data is
-  // gone.
-  disk_cache::Entry* entry2;
-  rv = cache.disk_cache()->OpenEntry(transaction2.url,
-                                     &entry2,
-                                     cb.callback());
-  ASSERT_EQ(net::ERR_CACHE_OPEN_FAILURE, cb.GetResult(rv));
-  RemoveMockTransaction(&transaction2);
-}
-
-TEST(HttpCache, RangeGET_SparseNotImplementedOnEmptyCache) {
-  MockHttpCache cache;
-  cache.disk_cache()->set_fail_sparse_requests();
-
-  // Request the range with the backend that does not support it.
-  MockTransaction transaction(kRangeGET_TransactionOK);
-  std::string headers;
-  AddMockTransaction(&transaction);
-  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-  EXPECT_EQ(1, cache.network_layer()->transaction_count());
-  EXPECT_EQ(0, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
-
-  // Mock cache would return net::ERR_CACHE_OPEN_FAILURE on a doomed entry, even
-  // if it was re-created later, so this effectively checks that the old data is
-  // gone as a result of a failed range write.
-  disk_cache::Entry* entry;
-  net::TestCompletionCallback cb;
-  int rv = cache.disk_cache()->OpenEntry(transaction.url,
-                                         &entry,
-                                         cb.callback());
-  ASSERT_EQ(net::ERR_CACHE_OPEN_FAILURE, cb.GetResult(rv));
-  RemoveMockTransaction(&transaction);
-}
-
 // Tests that we can cache range requests and fetch random blocks from the
 // cache and the network, with synchronous responses.
 TEST(HttpCache, RangeGET_SyncOK) {
   MockHttpCache cache;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.test_mode = TEST_MODE_SYNC_ALL;
   AddMockTransaction(&transaction);
 
   // Write to the cache (40-49).
@@ skipping 187 matching lines @@
 
   // And the entry should be gone.
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
+// Tests that when a server returns 206 with a sub-range of the requested range,
+// and there is nothing stored in the cache, the returned response is passed to
+// the caller as is. In this context, a subrange means a response that starts
+// with the same byte that was requested, but that is not the whole range that
+// was requested.
+TEST(HttpCache, RangeGET_206ReturnsSubrangeRange_NoCachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Request a large range (40-59). The server sends 40-49.
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 40-59\r\n" EXTRA_HEADER;
+  transaction.response_headers =
+      "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+      "ETag: \"foo\"\n"
+      "Accept-Ranges: bytes\n"
+      "Content-Length: 10\n"
+      "Content-Range: bytes 40-49/80\n";
+  transaction.handler = nullptr;
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  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());
+}
+
+// Tests that when a server returns 206 with a sub-range of the requested range,
+// and there was an entry stored in the cache, the cache gets out of the way.
+TEST(HttpCache, RangeGET_206ReturnsSubrangeRange_CachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Write to the cache (70-79).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
+  transaction.data = "rg: 70-79 ";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+  Verify206Response(headers, 70, 79);
+
+  // Request a large range (40-79). The cache will ask the server for 40-59.
+  // The server returns 40-49. The cache should consider the server confused and
+  // abort caching, restarting the request without caching.
+  transaction.request_headers = "Range: bytes = 40-79\r\n" EXTRA_HEADER;
+  transaction.response_headers =
+      "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+      "ETag: \"foo\"\n"
+      "Accept-Ranges: bytes\n"
+      "Content-Length: 10\n"
+      "Content-Range: bytes 40-49/80\n";
+  transaction.handler = nullptr;
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  // Two new network requests were issued, one from the cache and another after
+  // deleting the entry.
+  Verify206Response(headers, 40, 49);
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // The entry was deleted.
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(4, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
+// Tests that when a server returns 206 with a sub-range of the requested range,
+// and there was an entry stored in the cache, the cache gets out of the way,
+// when the caller is not using ranges.
+TEST(HttpCache, GET_206ReturnsSubrangeRange_CachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Write to the cache (70-79).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
+  transaction.data = "rg: 70-79 ";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+  Verify206Response(headers, 70, 79);
+
+  // Don't ask for a range. The cache will ask the server for 0-69.
+  // The server returns 40-49. The cache should consider the server confused and
+  // abort caching, restarting the request.
+  // The second network request should not be a byte range request so the server
+  // should return 200 + "Not a range"
+  transaction.request_headers = "X-Return-Default-Range:\r\n" EXTRA_HEADER;
+  transaction.data = "Not a range";
+  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());
+
+  // The entry was deleted.
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(4, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
+// Tests that when a server returns 206 with a random range and there is
+// nothing stored in the cache, the returned response is passed to the caller
+// as is. In this context, a WrongRange means that the returned range may or may
+// not have any relationship with the requested range (may or may not be
+// contained). The important part is that the first byte doesn't match the first
+// requested byte.
+TEST(HttpCache, RangeGET_206ReturnsWrongRange_NoCachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Request a large range (30-59). The server sends (40-49).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 30-59\r\n" EXTRA_HEADER;
+  transaction.response_headers =
+      "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+      "ETag: \"foo\"\n"
+      "Accept-Ranges: bytes\n"
+      "Content-Length: 10\n"
+      "Content-Range: bytes 40-49/80\n";
+  transaction.handler = nullptr;
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  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());
+
+  // The entry was deleted.
+  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());
+}
+
+// Tests that when a server returns 206 with a random range and there is
+// an entry stored in the cache, the cache gets out of the way.
+TEST(HttpCache, RangeGET_206ReturnsWrongRange_CachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Write to the cache (70-79).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
+  transaction.data = "rg: 70-79 ";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+  Verify206Response(headers, 70, 79);
+
+  // Request a large range (30-79). The cache will ask the server for 30-69.
+  // The server returns 40-49. The cache should consider the server confused and
+  // abort caching, returning the weird range to the caller.
+  transaction.request_headers = "Range: bytes = 30-79\r\n" EXTRA_HEADER;
+  transaction.response_headers =
+      "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+      "ETag: \"foo\"\n"
+      "Accept-Ranges: bytes\n"
+      "Content-Length: 10\n"
+      "Content-Range: bytes 40-49/80\n";
+  transaction.handler = nullptr;
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  Verify206Response(headers, 40, 49);
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // The entry was deleted.
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(4, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
+// Tests that when a caller asks for a range beyond EOF, with an empty cache,
+// the response matches the one provided by the server.
+TEST(HttpCache, RangeGET_206ReturnsSmallerFile_NoCachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Request a large range (70-99). The server sends 70-79.
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 70-99\r\n" EXTRA_HEADER;
+  transaction.data = "rg: 70-79 ";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  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());
+
+  RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+}
+
+// Tests that when a caller asks for a range beyond EOF, with a cached entry,
+// the cache automatically fixes the request.
+TEST(HttpCache, RangeGET_206ReturnsSmallerFile_CachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Write to the cache (40-49).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  // Request a large range (70-99). The server sends 70-79.
+  transaction.request_headers = "Range: bytes = 70-99\r\n" EXTRA_HEADER;
+  transaction.data = "rg: 70-79 ";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  Verify206Response(headers, 70, 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());
+
+  // The entry was not deleted (the range was automatically fixed).
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(2, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+}
+
+// Tests that when a caller asks for a not-satisfiable range, the server's
+// response is forwarded to the caller.
+TEST(HttpCache, RangeGET_416_NoCachedContent) {
+  MockHttpCache cache;
+  std::string headers;
+
+  // Request a range beyond EOF (80-99).
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+  transaction.request_headers = "Range: bytes = 80-99\r\n" EXTRA_HEADER;
+  transaction.data = "";
+  transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
+  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+
+  EXPECT_EQ(0U, headers.find(transaction.status));
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // The entry was deleted.
+  RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
 // Tests that we cache 301s for range requests.
 TEST(HttpCache, RangeGET_301) {
   MockHttpCache cache;
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.status = "HTTP/1.1 301 Moved Permanently";
   transaction.response_headers = "Location: http://www.bar.com/\n";
   transaction.data = "";
   transaction.handler = NULL;
-  AddMockTransaction(&transaction);
 
   // 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());
 
   // Read from the 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 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;
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (70-79).
@@ skipping 106 matching lines @@
 
   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());
   TestLoadTimingNetworkRequest(load_timing_info);
 
   // Write and read from the cache (0-79), when not asked for a range.
   MockTransaction transaction(kRangeGET_TransactionOK);
   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 ";
+  transaction.data = kFullRangeData;
   RunTransactionTestWithResponseAndGetTiming(
       cache.http_cache(), transaction, &headers, log.bound(),
       &load_timing_info);
 
   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());
   TestLoadTimingNetworkRequest(load_timing_info);
 
@@ skipping 29 matching lines @@
   Verify206Response(headers, 70, 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());
   TestLoadTimingNetworkRequest(load_timing_info);
 
   // Read from the cache (0-9), write and read from cache (10 - 79).
   transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
   transaction.request_headers = "Foo: bar\r\n" 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 ";
+  transaction.data = kFullRangeData;
   RunTransactionTestWithResponseAndGetTiming(
       cache.http_cache(), transaction, &headers, log.bound(),
       &load_timing_info);
 
   EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
   EXPECT_EQ(4, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 
@@ skipping 179 matching lines @@
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we can handle range requests with cached 200 responses.
 TEST(HttpCache, RangeGET_Previous200) {
   MockHttpCache cache;
 
   // Store the whole thing with status 200.
   MockTransaction transaction(kTypicalGET_Transaction);
   transaction.url = kRangeGET_TransactionOK.url;
-  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 ";
+  transaction.data = kFullRangeData;
   AddMockTransaction(&transaction);
   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());
 
   RemoveMockTransaction(&transaction);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Now see that we use the stored entry.
@@ skipping 312 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Verify that we don't have a cached entry.
   disk_cache::Entry* entry;
   EXPECT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that if a server tells us conflicting information about a resource we
-// ignore the response.
+// drop the entry.
 TEST(HttpCache, RangeGET_InvalidResponse3) {
   MockHttpCache cache;
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.handler = NULL;
   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();
@@ skipping 11 matching lines @@
   // This transaction will report a resource size of 80 bytes, and we think it's
   // 160 so we should ignore the response.
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   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());
 
-  // Verify that we cached the first response but not the second one.
-  disk_cache::Entry* en;
-  ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &en));
-
-  int64 cached_start = 0;
-  net::TestCompletionCallback cb;
-  int rv = en->GetAvailableRange(40, 20, &cached_start, cb.callback());
-  EXPECT_EQ(10, cb.GetResult(rv));
-  EXPECT_EQ(50, cached_start);
-  en->Close();
-
+  // Verify that the entry is gone.
+  RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we handle large range values properly.
 TEST(HttpCache, RangeGET_LargeValues) {
   // We need a real sparse cache for this test.
   MockHttpCache cache(net::HttpCache::DefaultBackend::InMemory(1024 * 1024));
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
@@ skipping 57 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we don't crash when after reading from the cache we issue a
 // request for the next range and the server gives us a 200 synchronously.
 TEST(HttpCache, RangeGET_FastFlakyServer) {
   MockHttpCache cache;
 
-  MockTransaction transaction(kRangeGET_TransactionOK);
+  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 40-\r\n" EXTRA_HEADER;
   transaction.test_mode = TEST_MODE_SYNC_NET_START;
   transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
-  AddMockTransaction(&transaction);
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
 
   // And now read from the cache and the network.
   RangeTransactionServer handler;
   handler.set_bad_200(true);
   transaction.data = "Not a range";
-  RunTransactionTest(cache.http_cache(), transaction);
+  net::CapturingBoundNetLog log;
+  RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
 
   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);
+  EXPECT_TRUE(LogContainsEventType(
+      log, net::NetLog::TYPE_HTTP_CACHE_RE_SEND_PARTIAL_REQUEST));
 }
 
 // Tests that when the server gives us less data than expected, we don't keep
 // asking for more data.
 TEST(HttpCache, RangeGET_FastFlakyServer2) {
   MockHttpCache cache;
 
   // First, check with an empty cache (WRITE mode).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 40-49\r\n" EXTRA_HEADER;
@@ skipping 340 matching lines @@
                           "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);
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
   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 ";
+  transaction.data = kFullRangeData;
   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 2007 01:10:43 GMT\n"
       "Accept-Ranges: bytes\n"
       "ETag: \"foo\"\n"
       "Content-Length: 80\n");
 
@@ skipping 27 matching lines @@
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 
   // Now make a regular request.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
   std::string response_headers(transaction.response_headers);
   response_headers += ("Cache-Control: no-store\n");
   transaction.response_headers = response_headers.c_str();
-  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 ";
+  transaction.data = kFullRangeData;
   AddMockTransaction(&transaction);
 
   std::string headers;
   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 2007 01:10:43 GMT\n"
       "Accept-Ranges: bytes\n"
@@ skipping 24 matching lines @@
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 
   // Now make a regular request.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
   std::string response_headers(transaction.response_headers);
   response_headers += ("Cache-Control: no-store\n");
   transaction.response_headers = response_headers.c_str();
-  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 ";
+  transaction.data = kFullRangeData;
   AddMockTransaction(&transaction);
 
   MockHttpRequest request(transaction);
   Context* c = new Context();
 
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_EQ(net::OK, rv);
 
   // Queue another request to this transaction. We have to start this request
   // before the first one gets the response from the server and dooms the entry,
@@ skipping 73 matching lines @@
                           "ETag: \"foo\"\n"
                           "Cache-Control: max-age= 36000\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
   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 ";
+  transaction.data = kFullRangeData;
 
   scoped_ptr<Context> c(new Context);
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_EQ(net::OK, rv);
 
   MockHttpRequest request(transaction);
   rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // We should have checked with the server before finishing Start().
@@ skipping 13 matching lines @@
                           "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);
 
   // Now make a regular request.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "X-Require-Mock-Auth: dummy\r\n"
                                 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 ";
+  transaction.data = kFullRangeData;
   RangeTransactionServer handler;
 
   scoped_ptr<Context> c(new Context);
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_EQ(net::OK, rv);
 
   MockHttpRequest request(transaction);
   rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
@@ skipping 1069 matching lines @@
                           "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);
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
   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 ";
+  transaction.data = kFullRangeData;
 
   scoped_ptr<net::HttpTransaction> trans;
   ASSERT_EQ(net::OK,
             cache.http_cache()->CreateTransaction(net::MEDIUM, &trans));
   EXPECT_EQ(net::DEFAULT_PRIORITY,
             cache.network_layer()->last_create_transaction_priority());
 
   MockHttpRequest info(transaction);
   net::TestCompletionCallback callback;
   EXPECT_EQ(net::ERR_IO_PENDING,
@@ skipping 676 matching lines @@
 
   // Here the second transaction proceeds without reading the first body.
   EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(net::LOAD_STATE_IDLE, second->trans->GetLoadState());
   ASSERT_TRUE(second->trans->GetResponseInfo());
   EXPECT_TRUE(second->trans->GetResponseInfo()->headers->HasHeaderValue(
       "Cache-Control", "no-store"));
   ReadAndVerifyTransaction(second->trans.get(), kSimpleGET_Transaction);
 }