Sparse IO: Allow failover to network in debug builds

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/message_loop.h"
@@ skipping 483 matching lines @@
   "Accept-Ranges: bytes\n"
   "Content-Length: 10\n",
   base::Time(),
   "rg: 40-49 ",
   TEST_MODE_NORMAL,
   &RangeTransactionServer::RangeHandler,
   0,
   net::OK
 };
 
+const MockTransaction kRangeGET_NotReallyARange = {
+  "http://www.google.com/range",
+  "GET",
+  base::Time(),
+  EXTRA_HEADER,
+  net::LOAD_NORMAL,
+  "HTTP/1.1 200 OK",
+  "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
+  "ETag: \"foo\"\n"
+  "Accept-Ranges: bytes\n"
+  "Content-Length: 10\n"
+  "Cache-Control: max-age=10000\n",
+  base::Time(),
+  "Not a range",
+  TEST_MODE_NORMAL,
+  &FastTransactionServer::FastNoStoreHandler,
+  0,
+  net::OK
+};
+
 // 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 2873 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);
 }
 
+#if defined(OS_ANDROID)
+
+// Tests that with a cache backend that does not implement Sparse IO the cache
+// entry would be re-created on each transaction.
+// TODO(pasko): remove when the SimpleBackendImpl implements Sparse IO.
+TEST(HttpCache, RangeGET_SparseNotImplemented) {
+  MockHttpCache cache;
+  cache.disk_cache()->set_fail_sparse_requests();
+  AddMockTransaction(&kRangeGET_TransactionOK);
+  std::string headers;
+
+  // Run a cacheable request to prime the cache.
+  RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_NotReallyARange,

[rvargas (doing something else), 2013/08/28 21:35:47]

I would actually prefer following HttpCache.RangeGET_Previous200

[pasko, 2013/08/28 21:56:28]

Done.

[pasko, 2013/08/28 22:01:43]

huh, misunderstood you here. I thought you suggested renaming, but you probably
suggested following the pattern of the HttpCache.RangeGET_Previous200 test.

This test is a bit longer though :/ What is the benefit?

[rvargas (doing something else), 2013/08/28 22:33:40]

Not really following the whole pattern of that test, just the few lines that
prime the cache.

It has two advantages:
- By reading the test it is pretty clear how the two requests differ. I don't
have to go somewhere else to see if the URL is the same, or any other field of
the structure.

- It makes sure that the cached data is usable to complete the
byte-range-request as is. Using this specific mock transaction may actually fail
by itself because it cannot be used to fulfill a request for bytes 40-49. Sure,
the test actually works because we detect the error code before looking at the
cached data, but that is not clear from the point of view of the test.

Just so that there's no confusion, what I was proposing was one test that:
-primes the cache
-issues the test tx
-verifies the entry is gone (another tx?)

and another that skips the first step.

+                                 &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());
+  EXPECT_EQ(0, cache.disk_cache()->sparse_count());
+
+  // Write to the cache (40-49).
+  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());
+
+  // Two sparse operations are expected: ReadyForSparseIO() and
+  // WriteSparseData().
+  EXPECT_EQ(2, cache.disk_cache()->sparse_count());
+
+  // Run the transaction again.
+  RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
+                                 &headers);
+
+  Verify206Response(headers, 40, 49);
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(3, cache.disk_cache()->create_count());
+
+  // WriteSparseData() must be invoked.
+  EXPECT_EQ(3, cache.disk_cache()->sparse_count());
+
+  RemoveMockTransaction(&kRangeGET_TransactionOK);
+}
+
+#endif  // OS_ANDROID
+
 // 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 2642 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);
 }