Change MockHttpCache constructor to take boolean to set quic server info factory

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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 621 matching lines @@
   return false;
 }
 
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
 // Tests.
 
 TEST(HttpCache, CreateThenDestroy) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   std::unique_ptr<HttpTransaction> trans;
   EXPECT_THAT(cache.CreateTransaction(&trans), IsOk());
   ASSERT_TRUE(trans.get());
 }
 
 TEST(HttpCache, GetBackend) {
-  MockHttpCache cache(HttpCache::DefaultBackend::InMemory(0));
+  MockHttpCache cache(HttpCache::DefaultBackend::InMemory(0), false);
 
   disk_cache::Backend* backend;
   TestCompletionCallback cb;
   // This will lazily initialize the backend.
   int rv = cache.http_cache()->GetBackend(&backend, cb.callback());
   EXPECT_THAT(cb.GetResult(rv), IsOk());
 }
 
 TEST(HttpCache, SimpleGET) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Write to the cache.
   RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
                                  log.bound(), &load_timing_info);
 
   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);
 }
 
 TEST(HttpCache, SimpleGETNoDiskCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   cache.disk_cache()->set_fail_requests();
 
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Read from the network, and don't use the cache.
   RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
                                  log.bound(), &load_timing_info);
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 }
 
 TEST(HttpCache, SimpleGETNoDiskCache2) {
   // This will initialize a cache object with NULL backend.
   std::unique_ptr<MockBlockingBackendFactory> factory(
       new MockBlockingBackendFactory());
   factory->set_fail(true);
   factory->FinishCreation();  // We'll complete synchronously.
-  MockHttpCache cache(std::move(factory));
+  MockHttpCache cache(std::move(factory), false);
 
   // Read from the network, and don't use the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_FALSE(cache.http_cache()->GetCurrentBackend());
 }
 
 // Tests that IOBuffers are not referenced after IO completes.
 TEST(HttpCache, ReleaseBuffer) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
   const int kBufferSize = 10;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
   ReleaseBufferCompletionCallback cb(buffer.get());
 
   int rv = trans->Start(&request, cb.callback(), NetLogWithSource());
   EXPECT_THAT(cb.GetResult(rv), IsOk());
 
   rv = trans->Read(buffer.get(), kBufferSize, cb.callback());
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
 }
 
 TEST(HttpCache, SimpleGETWithDiskFailures) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   cache.disk_cache()->set_soft_failures(true);
 
   // Read from the network, and fail to write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 one should see an empty cache again.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 disk failures after the transaction has started don't cause the
 // request to fail.
 TEST(HttpCache, SimpleGETWithDiskFailures2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::unique_ptr<Context> c(new Context());
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = c->callback.WaitForResult();
@@ skipping 16 matching lines @@
   // This one should see an empty cache again.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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());
 }
 
 // Tests that we handle failures to read from the cache.
 TEST(HttpCache, SimpleGETWithDiskFailures3) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Read from the network, and write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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());
 
   cache.disk_cache()->set_soft_failures(true);
 
@@ skipping 14 matching lines @@
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(3, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Write to the cache.
   RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
                                  log.bound(), &load_timing_info);
 
   // Check that the NetLog was filled as expected.
   TestNetLogEntry::List entries;
@@ skipping 51 matching lines @@
   EXPECT_TRUE(
       LogContainsEndEvent(entries, 7, NetLogEventType::HTTP_CACHE_READ_INFO));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingCachedResponse(load_timing_info);
 }
 
 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Miss) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // force this transaction to read from the cache
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimpleGET_LoadPreferringCache_Hit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // force this transaction to read from the cache if valid
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
 
   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());
 }
 
 TEST(HttpCache, SimpleGET_LoadPreferringCache_Miss) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // force this transaction to read from the cache if valid
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
 
   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());
 }
 
 // Tests LOAD_SKIP_CACHE_VALIDATION in the presence of vary headers.
 TEST(HttpCache, SimpleGET_LoadPreferringCache_VaryMatch) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
   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 |= LOAD_SKIP_CACHE_VALIDATION;
   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_SKIP_CACHE_VALIDATION in the presence of vary headers.
 TEST(HttpCache, SimpleGET_LoadPreferringCache_VaryMismatch) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
   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 |= LOAD_SKIP_CACHE_VALIDATION;
   transaction.request_headers = "Foo: none\r\n";
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
   RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
                                  &load_timing_info);
 
   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);
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that was_cached was set properly on a failure, even if the cached
 // response wasn't returned.
 TEST(HttpCache, SimpleGET_CacheSignal_Failure) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Prime cache.
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "Cache-Control: no-cache\n";
 
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
@@ skipping 14 matching lines @@
   const HttpResponseInfo* response_info = trans->GetResponseInfo();
   ASSERT_TRUE(response_info);
   EXPECT_TRUE(response_info->was_cached);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Confirm if we have an empty cache, a read is marked as network verified.
 TEST(HttpCache, SimpleGET_NetworkAccessed_Network) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // write to the cache
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response_info);
 
   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_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_NOT_IN_CACHE,
             response_info.cache_entry_status);
 }
 
 // Confirm if we have a fresh entry in cache, it isn't marked as
 // network verified.
 TEST(HttpCache, SimpleGET_NetworkAccessed_Cache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Prime cache.
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Re-run transaction; make sure we don't mark the network as accessed.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
                                      &response_info);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_FALSE(response_info.server_data_unavailable);
   EXPECT_FALSE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_USED, response_info.cache_entry_status);
 }
 
 TEST(HttpCache, SimpleGET_LoadBypassCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // Force this transaction to write to the cache again.
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= LOAD_BYPASS_CACHE;
 
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
@@ skipping 25 matching lines @@
   EXPECT_TRUE(LogContainsEndEvent(entries, 7,
                                   NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 }
 
 TEST(HttpCache, SimpleGET_LoadBypassCache_Implicit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // 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\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;
+  MockHttpCache cache(false);
 
   // 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\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;
+  MockHttpCache cache(false);
 
   // 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.load_flags |= LOAD_VALIDATE_CACHE;
 
   HttpResponseInfo response_info;
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
   RunTransactionTestWithResponseInfoAndGetTiming(
       cache.http_cache(), transaction, &response_info, log.bound(),
       &load_timing_info);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   EXPECT_TRUE(response_info.network_accessed);
   TestLoadTimingNetworkRequest(load_timing_info);
 }
 
 TEST(HttpCache, SimpleGET_LoadValidateCache_Implicit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // 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\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());
 }
 
 // Tests that |unused_since_prefetch| is updated accordingly (e.g. it is set to
 // true after a prefetch and set back to false when the prefetch is used).
 TEST(HttpCache, SimpleGET_UnusedSincePrefetch) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   HttpResponseInfo response_info;
 
   // A normal load does not have |unused_since_prefetch| set.
   RunTransactionTestWithResponseInfoAndGetTiming(
       cache.http_cache(), kSimpleGET_Transaction, &response_info,
       BoundTestNetLog().bound(), nullptr);
   EXPECT_FALSE(response_info.unused_since_prefetch);
   EXPECT_FALSE(response_info.was_cached);
 
   // The prefetch itself does not have |unused_since_prefetch| set.
@@ skipping 29 matching lines @@
 
 static void PreserveRequestHeaders_Handler(const HttpRequestInfo* request,
                                            std::string* response_status,
                                            std::string* response_headers,
                                            std::string* response_data) {
   EXPECT_TRUE(request->extra_headers.HasHeader(kExtraHeaderKey));
 }
 
 // Tests that we don't remove extra headers for simple requests.
 TEST(HttpCache, SimpleGET_PreserveRequestHeaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.handler = PreserveRequestHeaders_Handler;
   transaction.request_headers = EXTRA_HEADER;
   transaction.response_headers = "Cache-Control: max-age=0\n";
   AddMockTransaction(&transaction);
 
   // Write, then revalidate the entry.
   RunTransactionTest(cache.http_cache(), transaction);
   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 we don't remove extra headers for conditionalized requests.
 TEST(HttpCache, ConditionalizedGET_PreserveRequestHeaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
 
   MockTransaction transaction(kETagGET_Transaction);
   transaction.handler = PreserveRequestHeaders_Handler;
   transaction.request_headers = "If-None-Match: \"foopy\"\r\n"
                                 EXTRA_HEADER;
   AddMockTransaction(&transaction);
 
   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);
 }
 
 TEST(HttpCache, SimpleGET_ManyReaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
@@ skipping 45 matching lines @@
     Context* c = context_list[i];
     delete c;
   }
 }
 
 // This is a test for http://code.google.com/p/chromium/issues/detail?id=4769.
 // If cancelling a request is racing with another request for the same resource
 // finishing, we have to make sure that we remove both transactions from the
 // entry.
 TEST(HttpCache, SimpleGET_RacingReaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   MockHttpRequest reader_request(kSimpleGET_Transaction);
   reader_request.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(new Context());
@@ skipping 63 matching lines @@
     Context* c = context_list[i];
     delete c;
   }
 }
 
 // Tests that we can doom an entry with pending transactions and delete one of
 // the pending transactions before the first one completes.
 // See http://code.google.com/p/chromium/issues/detail?id=25588
 TEST(HttpCache, SimpleGET_DoomWithPending) {
   // We need simultaneous doomed / not_doomed entries so let's use a real cache.
-  MockHttpCache cache(HttpCache::DefaultBackend::InMemory(1024 * 1024));
+  MockHttpCache cache(HttpCache::DefaultBackend::InMemory(1024 * 1024), false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   MockHttpRequest writer_request(kSimpleGET_Transaction);
   writer_request.load_flags = LOAD_BYPASS_CACHE;
 
   std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 4;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(base::WrapUnique(new Context()));
@@ skipping 25 matching lines @@
     ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
     c->result = c->callback.WaitForResult();
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 }
 
 // This is a test for http://code.google.com/p/chromium/issues/detail?id=4731.
 // We may attempt to delete an entry synchronously with the act of adding a new
 // transaction to said entry.
 TEST(HttpCache, FastNoStoreGET_DoneWithPending) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // The headers will be served right from the call to Start() the request.
   MockHttpRequest request(kFastNoStoreGET_Transaction);
   FastTransactionServer request_handler;
   AddMockTransaction(&kFastNoStoreGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; ++i) {
@@ skipping 29 matching lines @@
   }
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kFastNoStoreGET_Transaction);
 }
 
 TEST(HttpCache, SimpleGET_ManyWriters_CancelFirst) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 2;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
@@ skipping 39 matching lines @@
 
   for (int i = 1; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     delete c;
   }
 }
 
 // Tests that we can cancel requests that are queued waiting to open the disk
 // cache entry.
 TEST(HttpCache, SimpleGET_ManyWriters_CancelCreate) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; i++) {
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
@@ skipping 35 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   for (int i = 1; i < kNumTransactions; ++i) {
     delete context_list[i];
   }
 }
 
 // Tests that we can cancel a single request to open a disk cache entry.
 TEST(HttpCache, SimpleGET_CancelCreate) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
 
   c->result = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(c->result, IsOk());
 
   c->result =
       c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->result, IsError(ERR_IO_PENDING));
 
   // Release the reference that the mock disk cache keeps for this entry, so
   // that we test that the http cache handles the cancellation correctly.
   cache.disk_cache()->ReleaseAll();
   delete c;
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete/create entries even if multiple requests are queued.
 TEST(HttpCache, SimpleGET_ManyWriters_BypassCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   request.load_flags = LOAD_BYPASS_CACHE;
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; i++) {
     context_list.push_back(new Context());
     Context* c = context_list[i];
@@ skipping 26 matching lines @@
   EXPECT_EQ(5, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
     delete context_list[i];
   }
 }
 
 // Tests that a (simulated) timeout allows transactions waiting on the cache
 // lock to continue.
 TEST(HttpCache, SimpleGET_WriterTimeout) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   cache.BypassCacheLock();
 
   MockHttpRequest request(kSimpleGET_Transaction);
   Context c1, c2;
   ASSERT_THAT(cache.CreateTransaction(&c1.trans), IsOk());
   ASSERT_EQ(ERR_IO_PENDING, c1.trans->Start(&request, c1.callback.callback(),
                                             NetLogWithSource()));
   ASSERT_THAT(cache.CreateTransaction(&c2.trans), IsOk());
   ASSERT_EQ(ERR_IO_PENDING, c2.trans->Start(&request, c2.callback.callback(),
                                             NetLogWithSource()));
 
   // The second request is queued after the first one.
 
   c2.callback.WaitForResult();
   ReadAndVerifyTransaction(c2.trans.get(), kSimpleGET_Transaction);
 
   // Complete the first transaction.
   c1.callback.WaitForResult();
   ReadAndVerifyTransaction(c1.trans.get(), kSimpleGET_Transaction);
 }
 
 TEST(HttpCache, SimpleGET_AbandonedCacheRead) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
@@ skipping 11 matching lines @@
 
   // Make sure we pump any pending events, which should include a call to
   // HttpCache::Transaction::OnCacheReadCompleted.
   base::RunLoop().RunUntilIdle();
 }
 
 // Tests that we can delete the HttpCache and deal with queued transactions
 // ("waiting for the backend" as opposed to Active or Doomed entries).
 TEST(HttpCache, SimpleGET_ManyWriters_DeleteCache) {
   std::unique_ptr<MockHttpCache> cache(
-      new MockHttpCache(base::WrapUnique(new MockBackendNoCbFactory())));
+      new MockHttpCache(base::WrapUnique(new MockBackendNoCbFactory()), false));
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; i++) {
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
@@ skipping 16 matching lines @@
   // There is not much to do with the transactions at this point... they are
   // waiting for a callback that will not fire.
   for (int i = 0; i < kNumTransactions; ++i) {
     delete context_list[i];
   }
 }
 
 // Tests that we queue requests when initializing the backend.
 TEST(HttpCache, SimpleGET_WaitForBackend) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(base::WrapUnique(factory));
+  MockHttpCache cache(base::WrapUnique(factory), false);
 
   MockHttpRequest request0(kSimpleGET_Transaction);
   MockHttpRequest request1(kTypicalGET_Transaction);
   MockHttpRequest request2(kETagGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; i++) {
     context_list.push_back(new Context());
@@ skipping 25 matching lines @@
   for (int i = 0; i < kNumTransactions; ++i) {
     EXPECT_TRUE(context_list[i]->callback.have_result());
     delete context_list[i];
   }
 }
 
 // Tests that we can cancel requests that are queued waiting for the backend
 // to be initialized.
 TEST(HttpCache, SimpleGET_WaitForBackend_CancelCreate) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(base::WrapUnique(factory));
+  MockHttpCache cache(base::WrapUnique(factory), false);
 
   MockHttpRequest request0(kSimpleGET_Transaction);
   MockHttpRequest request1(kTypicalGET_Transaction);
   MockHttpRequest request2(kETagGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; i++) {
     context_list.push_back(new Context());
@@ skipping 34 matching lines @@
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   delete context_list[2];
 }
 
 // Tests that we can delete the cache while creating the backend.
 TEST(HttpCache, DeleteCacheWaitingForBackend) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
   std::unique_ptr<MockHttpCache> cache(
-      new MockHttpCache(base::WrapUnique(factory)));
+      new MockHttpCache(base::WrapUnique(factory), false));
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::unique_ptr<Context> c(new Context());
   c->result = cache->CreateTransaction(&c->trans);
   ASSERT_THAT(c->result, IsOk());
 
   c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
 
   // Just to make sure that everything is still pending.
@@ skipping 11 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   backend->reset();
   callback.Run(ERR_ABORTED);
 }
 
 // Tests that we can delete the cache while creating the backend, from within
 // one of the callbacks.
 TEST(HttpCache, DeleteCacheWaitingForBackend2) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache* cache = new MockHttpCache(base::WrapUnique(factory));
+  MockHttpCache* cache = new MockHttpCache(base::WrapUnique(factory), false);
 
   DeleteCacheCompletionCallback cb(cache);
   disk_cache::Backend* backend;
   int rv = cache->http_cache()->GetBackend(&backend, cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Now let's queue a regular transaction
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::unique_ptr<Context> c(new Context());
@@ skipping 24 matching lines @@
 }
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_TypicalGET_ConditionalRequest \
   DISABLED_TypicalGET_ConditionalRequest
 #else
 #define MAYBE_TypicalGET_ConditionalRequest TypicalGET_ConditionalRequest
 #endif
 TEST(HttpCache, MAYBE_TypicalGET_ConditionalRequest) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kTypicalGET_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 this time we expect it to result
   // in a conditional request.
@@ skipping 13 matching lines @@
                                                std::string* response_headers,
                                                std::string* response_data) {
   EXPECT_TRUE(
       request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch));
   response_status->assign("HTTP/1.1 304 Not Modified");
   response_headers->assign(kETagGET_Transaction.response_headers);
   response_data->clear();
 }
 
 TEST(HttpCache, ETagGET_ConditionalRequest_304) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_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());
 
@@ skipping 55 matching lines @@
     response_data->clear();
   } else {
     response_status->assign(kTypicalGET_Transaction.status);
     response_headers->assign(kTypicalGET_Transaction.response_headers);
     response_data->assign(kTypicalGET_Transaction.data);
   }
 }
 
 // Tests revalidation after a vary match.
 TEST(HttpCache, GET_ValidateCache_VaryMatch) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kTypicalGET_Transaction);
   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";
@@ skipping 12 matching lines @@
   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());
   TestLoadTimingNetworkRequest(load_timing_info);
   RemoveMockTransaction(&transaction);
 }
 
 // Tests revalidation after a vary mismatch if etag is present.
 TEST(HttpCache, GET_ValidateCache_VaryMismatch) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kTypicalGET_Transaction);
   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";
@@ skipping 13 matching lines @@
   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());
   TestLoadTimingNetworkRequest(load_timing_info);
   RemoveMockTransaction(&transaction);
 }
 
 // Tests lack of revalidation after a vary mismatch and no etag.
 TEST(HttpCache, GET_DontValidateCache_VaryMismatch) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kTypicalGET_Transaction);
   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);
@@ skipping 12 matching lines @@
   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());
   TestLoadTimingNetworkRequest(load_timing_info);
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a new vary header provided when revalidating an entry is saved.
 TEST(HttpCache, GET_ValidateCache_VaryMatch_UpdateVary) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   ScopedMockTransaction transaction(kTypicalGET_Transaction);
   transaction.request_headers = "Foo: bar\r\n Name: bar\r\n";
   transaction.response_headers =
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=0\n"
       "Vary: Foo\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
@@ skipping 18 matching lines @@
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that new request headers causing a vary mismatch are paired with the
 // new response when the server says the old response can be used.
 TEST(HttpCache, GET_ValidateCache_VaryMismatch_UpdateRequestHeader) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   ScopedMockTransaction transaction(kTypicalGET_Transaction);
   transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=3600\n"
       "Vary: Foo\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
@@ skipping 14 matching lines @@
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that a 304 without vary headers doesn't delete the previously stored
 // vary data after a vary match revalidation.
 TEST(HttpCache, GET_ValidateCache_VaryMatch_DontDeleteVary) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   ScopedMockTransaction transaction(kTypicalGET_Transaction);
   transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=0\n"
       "Vary: Foo\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
@@ skipping 16 matching lines @@
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that a 304 without vary headers doesn't delete the previously stored
 // vary data after a vary mismatch.
 TEST(HttpCache, GET_ValidateCache_VaryMismatch_DontDeleteVary) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   ScopedMockTransaction transaction(kTypicalGET_Transaction);
   transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=3600\n"
       "Vary: Foo\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
@@ skipping 23 matching lines @@
 
 static void ETagGet_UnconditionalRequest_Handler(const HttpRequestInfo* request,
                                                  std::string* response_status,
                                                  std::string* response_headers,
                                                  std::string* response_data) {
   EXPECT_FALSE(
       request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch));
 }
 
 TEST(HttpCache, ETagGET_Http10) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_Transaction);
   transaction.status = "HTTP/1.0 200 OK";
 
   // 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, without generating a conditional request.
   transaction.load_flags = LOAD_VALIDATE_CACHE;
   transaction.handler = ETagGet_UnconditionalRequest_Handler;
   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());
 }
 
 TEST(HttpCache, ETagGET_Http10_Range) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_Transaction);
   transaction.status = "HTTP/1.0 200 OK";
 
   // 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());
@@ skipping 15 matching lines @@
     std::string* response_headers,
     std::string* response_data) {
   EXPECT_TRUE(
       request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch));
   response_status->assign("HTTP/1.1 304 Not Modified");
   response_headers->assign("Cache-Control: no-store\n");
   response_data->clear();
 }
 
 TEST(HttpCache, ETagGET_ConditionalRequest_304_NoStore) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_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());
 
@@ skipping 23 matching lines @@
 // (2) loads |kUrl| from cache only -- expects |net_response_1| to be returned.
 // (3) loads |kUrl| using |extra_request_headers| -- expects |net_response_2| to
 //     be returned.
 // (4) loads |kUrl| from cache only -- expects |cached_response_2| to be
 //     returned.
 static void ConditionalizedRequestUpdatesCacheHelper(
     const Response& net_response_1,
     const Response& net_response_2,
     const Response& cached_response_2,
     const char* extra_request_headers) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // The URL we will be requesting.
   const char kUrl[] = "http://foobar.com/main.css";
 
   // Junk network response.
   static const Response kUnexpectedResponse = {
     "HTTP/1.1 500 Unexpected",
     "Server: unexpected_header",
     "unexpected body"
   };
@@ skipping 168 matching lines @@
       "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;
+  MockHttpCache cache(false);
 
   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",
     ""
   };
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&mock_network_response);
 }
 
 // Test that when doing an externally conditionalized if-modified-since
 // and there is no corresponding cache entry, a new cache entry is NOT
 // created (200 response).
 TEST(HttpCache, ConditionalizedRequestUpdatesCache5) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   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!!!"
   };
 
@@ skipping 165 matching lines @@
   // The modification date doesn't match what we have stored.
   const char kExtraRequestHeaders[] =
       "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(HttpCache, UrlContainingHash) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // 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());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Request the same URL, but this time with a reference section (hash).
   // Since the cache key strips the hash sections, this should be a cache hit.
   std::string url_with_hash = std::string(trans.url) + "#multiple#hashes";
   trans.url = url_with_hash.c_str();
   trans.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   RunTransactionTest(cache.http_cache(), trans);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we skip the cache for POST requests that do not have an upload
 // identifier.
 TEST(HttpCache, SimplePOST_SkipsCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   RunTransactionTest(cache.http_cache(), kSimplePOST_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());
 }
 
 // Tests POST handling with a disabled cache (no DCHECK).
 TEST(HttpCache, SimplePOST_DisabledCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   cache.http_cache()->set_mode(HttpCache::Mode::DISABLE);
 
   RunTransactionTest(cache.http_cache(), kSimplePOST_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());
 }
 
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Miss) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
   ASSERT_TRUE(trans.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CACHE_MISS));
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Hit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Test that we hit the cache for POST requests.
 
   MockTransaction transaction(kSimplePOST_Transaction);
 
   const int64_t kUploadId = 1;  // Just a dummy value.
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::MakeUnique<UploadBytesElementReader>("hello", 5));
@@ skipping 13 matching lines @@
   request.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Test that we don't hit the cache for POST requests if there is a byte range.
 TEST(HttpCache, SimplePOST_WithRanges) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.request_headers = "Range: bytes = 0-4\r\n";
 
   const int64_t kUploadId = 1;  // Just a dummy value.
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::WrapUnique(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers),
                                               kUploadId);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that a POST is cached separately from a GET.
 TEST(HttpCache, SimplePOST_SeparateCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::WrapUnique(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   MockHttpRequest req1(transaction);
   req1.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   transaction.method = "GET";
   MockHttpRequest req2(transaction);
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   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 a successful POST invalidates a previously cached GET.
 TEST(HttpCache, SimplePOST_Invalidate_205) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 19 matching lines @@
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(3, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a successful POST invalidates a previously cached GET, even when
 // there is no upload identifier.
 TEST(HttpCache, SimplePOST_NoUploadId_Invalidate_205) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 23 matching lines @@
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that processing a POST before creating the backend doesn't crash.
 TEST(HttpCache, SimplePOST_NoUploadId_NoBackend) {
   // This will initialize a cache object with NULL backend.
   std::unique_ptr<MockBlockingBackendFactory> factory(
       new MockBlockingBackendFactory());
   factory->set_fail(true);
   factory->FinishCreation();
-  MockHttpCache cache(std::move(factory));
+  MockHttpCache cache(std::move(factory), false);
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::WrapUnique(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req(transaction);
   req.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req, NULL);
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we don't invalidate entries as a result of a failed POST.
 TEST(HttpCache, SimplePOST_DontInvalidate_100) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 18 matching lines @@
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   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);
 }
 
 // Tests that a HEAD request is not cached by itself.
 TEST(HttpCache, SimpleHEAD_LoadOnlyFromCache_Miss) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kSimplePOST_Transaction);
   AddMockTransaction(&transaction);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.method = "HEAD";
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
   ASSERT_TRUE(trans.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CACHE_MISS));
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a HEAD request is served from a cached GET.
 TEST(HttpCache, SimpleHEAD_LoadOnlyFromCache_Hit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Populate 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());
 
   // Load from cache.
   transaction.method = "HEAD";
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.data = "";
   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 a read-only request served from the cache preserves CL.
 TEST(HttpCache, SimpleHEAD_ContentLengthOnHit_Read) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   transaction.response_headers = "Content-Length: 42\n";
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Load from cache.
   transaction.method = "HEAD";
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.data = "";
   std::string headers;
 
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_EQ("HTTP/1.1 200 OK\nContent-Length: 42\n", headers);
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a read-write request served from the cache preserves CL.
 TEST(HttpCache, ETagHEAD_ContentLengthOnHit_ReadWrite) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kETagGET_Transaction);
   AddMockTransaction(&transaction);
   std::string server_headers(kETagGET_Transaction.response_headers);
   server_headers.append("Content-Length: 42\n");
   transaction.response_headers = server_headers.data();
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Load from cache.
   transaction.method = "HEAD";
   transaction.data = "";
   std::string headers;
 
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_NE(std::string::npos, headers.find("Content-Length: 42\n"));
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a HEAD request that includes byte ranges bypasses the cache.
 TEST(HttpCache, SimpleHEAD_WithRanges) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Load from cache.
   transaction.method = "HEAD";
   transaction.request_headers = "Range: bytes = 0-4\r\n";
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a HEAD request can be served from a partialy cached resource.
 TEST(HttpCache, SimpleHEAD_WithCachedRanges) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Write to the cache (40-49).
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 
   MockTransaction transaction(kSimpleGET_Transaction);
 
   transaction.url = kRangeGET_TransactionOK.url;
   transaction.method = "HEAD";
   transaction.data = "";
   AddMockTransaction(&transaction);
   std::string headers;
 
   // Load from cache.
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
   EXPECT_NE(std::string::npos, headers.find("Content-Length: 80\n"));
   EXPECT_EQ(std::string::npos, headers.find("Content-Range"));
   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 a HEAD request can be served from a truncated resource.
 TEST(HttpCache, SimpleHEAD_WithTruncatedEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 
@@ skipping 12 matching lines @@
   EXPECT_NE(std::string::npos, headers.find("Content-Length: 80\n"));
   EXPECT_EQ(std::string::npos, headers.find("Content-Range"));
   EXPECT_EQ(0, 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 a HEAD request updates the cached response.
 TEST(HttpCache, TypicalHEAD_UpdatesResponse) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kTypicalGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Update the cache.
   transaction.method = "HEAD";
   transaction.response_headers = "Foo: bar\n";
   transaction.data = "";
@@ skipping 17 matching lines @@
 
   EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction2);
 }
 
 // Tests that an externally conditionalized HEAD request updates the cache.
 TEST(HttpCache, TypicalHEAD_ConditionalizedRequestUpdatesResponse) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kTypicalGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Update the cache.
   transaction.method = "HEAD";
   transaction.request_headers =
       "If-Modified-Since: Wed, 28 Nov 2007 00:40:09 GMT\r\n";
@@ skipping 19 matching lines @@
 
   EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction2);
 }
 
 // Tests that a HEAD request invalidates an old cached entry.
 TEST(HttpCache, SimpleHEAD_InvalidatesEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   MockTransaction transaction(kTypicalGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Update the cache.
   transaction.method = "HEAD";
   transaction.data = "";
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   // Load from the cache.
   transaction.method = "GET";
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we do not cache the response of a PUT.
 TEST(HttpCache, SimplePUT_Miss) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.method = "PUT";
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::WrapUnique(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that we invalidate entries as a result of a PUT.
 TEST(HttpCache, SimplePUT_Invalidate) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   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 15 matching lines @@
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we invalidate entries as a result of a PUT.
 TEST(HttpCache, SimplePUT_Invalidate_305) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 18 matching lines @@
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   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(&transaction);
 }
 
 // Tests that we don't invalidate entries as a result of a failed PUT.
 TEST(HttpCache, SimplePUT_DontInvalidate_404) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 18 matching lines @@
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we do not cache the response of a DELETE.
 TEST(HttpCache, SimpleDELETE_Miss) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.method = "DELETE";
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       base::WrapUnique(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that we invalidate entries as a result of a DELETE.
 TEST(HttpCache, SimpleDELETE_Invalidate) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   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 15 matching lines @@
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we invalidate entries as a result of a DELETE.
 TEST(HttpCache, SimpleDELETE_Invalidate_301) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Attempt to populate 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());
@@ skipping 11 matching lines @@
   RunTransactionTest(cache.http_cache(), transaction);
 
   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(&transaction);
 }
 
 // Tests that we don't invalidate entries as a result of a failed DELETE.
 TEST(HttpCache, SimpleDELETE_DontInvalidate_416) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Attempt to populate 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());
@@ skipping 12 matching lines @@
   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());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we don't invalidate entries after a failed network transaction.
 TEST(HttpCache, SimpleGET_DontInvalidateOnFailure) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // Fail the network request.
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.return_code = ERR_FAILED;
   transaction.load_flags |= LOAD_VALIDATE_CACHE;
 
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   RemoveMockTransaction(&transaction);
 
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.return_code = OK;
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Make sure the transaction didn't reach the network.
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   RemoveMockTransaction(&transaction);
 }
 
 TEST(HttpCache, RangeGET_SkipsCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Test that we skip the cache for range GET requests.  Eventually, we will
   // 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());
@@ skipping 11 matching lines @@
   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;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kRangeGET_Transaction);
   transaction.request_headers = "If-None-Match: foo\r\n"
                                 EXTRA_HEADER
                                 "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());
@@ skipping 12 matching lines @@
                                 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;
+  MockHttpCache cache(false);
 
   BoundTestNetLog log;
   RunTransactionTestWithLog(cache.http_cache(), kSimpleGET_Transaction,
                             log.bound());
 
   EXPECT_FALSE(LogContainsEventType(
       log, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
 }
 
 TEST(HttpCache, RangeGET_LogsHeaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   BoundTestNetLog log;
   RunTransactionTestWithLog(cache.http_cache(), kRangeGET_Transaction,
                             log.bound());
 
   EXPECT_TRUE(LogContainsEventType(
       log, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
 }
 
 TEST(HttpCache, ExternalValidation_LogsHeaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   BoundTestNetLog 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, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
 }
 
 TEST(HttpCache, SpecialHeaders_LogsHeaders) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   BoundTestNetLog 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, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
 }
 
 // Tests that receiving 206 for a regular request is handled correctly.
 TEST(HttpCache, GET_Crazy206) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
   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);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that receiving 416 for a regular request is handled correctly.
 TEST(HttpCache, GET_Crazy416) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   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 don't store partial responses that can't be validated.
 TEST(HttpCache, RangeGET_NoStrongValidators) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   std::string headers;
 
   // 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 no cached data.
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   Verify206Response(headers, 40, 49);
   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 conditionalize byte range requests.
 TEST(HttpCache, RangeGET_NoConditionalization) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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);
 
   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;
+  MockHttpCache cache(false);
   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.
   BoundTestNetLog log;
   RunTransactionTestWithLog(cache.http_cache(), kRangeGET_TransactionOK,
                             log.bound());
 
   EXPECT_TRUE(LogContainsEventType(
       log, NetLogEventType::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;
+  MockHttpCache cache(false);
   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);
@@ skipping 18 matching lines @@
   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;
+  MockHttpCache cache(false);
   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);
@@ skipping 17 matching lines @@
 
   // 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;
+  MockHttpCache cache(false);
   std::string headers;
 
   // Attempt to write to the cache (40-49).
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
   transaction.response_headers = "ETag: \"foo\"\n"
                                  "Accept-Ranges: bytes\n"
                                  "Content-Range: bytes 40-49/80\n";
   transaction.handler = NULL;
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
@@ skipping 17 matching lines @@
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_OK DISABLED_RangeGET_OK
 #else
 #define MAYBE_RangeGET_OK RangeGET_OK
 #endif
 // Tests that we can cache range requests and fetch random blocks from the
 // cache and the network.
 TEST(HttpCache, MAYBE_RangeGET_OK) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (40-49).
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 45 matching lines @@
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_SyncOK DISABLED_RangeGET_SyncOK
 #else
 #define MAYBE_RangeGET_SyncOK RangeGET_SyncOK
 #endif
 // Tests that we can cache range requests and fetch random blocks from the
 // cache and the network, with synchronous responses.
 TEST(HttpCache, MAYBE_RangeGET_SyncOK) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.test_mode = TEST_MODE_SYNC_ALL;
   AddMockTransaction(&transaction);
 
   // Write to the cache (40-49).
   std::string headers;
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 40, 49);
@@ skipping 40 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that if the previous transaction is cancelled while busy (doing sparse
 // IO), a new transaction (that reuses that same ActiveEntry) waits until the
 // entry is ready again.
 TEST(HttpCache, Sparse_WaitForEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
 
   // Create a sparse entry.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Simulate a previous transaction being cancelled.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
   entry->CancelSparseIO();
 
   // Test with a range request.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Now test with a regular request.
   entry->CancelSparseIO();
   transaction.request_headers = EXTRA_HEADER;
   transaction.data = kFullRangeData;
   RunTransactionTest(cache.http_cache(), transaction);
 
   entry->Close();
 }
 
 // Tests that we don't revalidate an entry unless we are required to do so.
 TEST(HttpCache, RangeGET_Revalidate1) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   std::string headers;
 
   // Write to the cache (40-49).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
       "Expires: Wed, 7 Sep 2033 21:46:42 GMT\n"  // Should never expire.
       "ETag: \"foo\"\n"
       "Accept-Ranges: bytes\n"
       "Content-Length: 10\n";
@@ skipping 34 matching lines @@
 }
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_Revalidate2 DISABLED_RangeGET_Revalidate2
 #else
 #define MAYBE_RangeGET_Revalidate2 RangeGET_Revalidate2
 #endif
 // Checks that we revalidate an entry when the headers say so.
 TEST(HttpCache, MAYBE_RangeGET_Revalidate2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   std::string headers;
 
   // Write to the cache (40-49).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
       "Expires: Sat, 18 Apr 2009 01:10:43 GMT\n"  // Expired.
       "ETag: \"foo\"\n"
       "Accept-Ranges: bytes\n"
       "Content-Length: 10\n";
@@ skipping 11 matching lines @@
 
   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 we deal with 304s for range requests.
 TEST(HttpCache, RangeGET_304) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (40-49).
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &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());
 
   // Read from the cache (40-49).
   RangeTransactionServer handler;
   handler.set_not_modified(true);
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.load_flags |= LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &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());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we deal with 206s when revalidating range requests.
 TEST(HttpCache, RangeGET_ModifiedResult) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (40-49).
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 19 matching lines @@
 
   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;
+  MockHttpCache cache(false);
   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;
+  MockHttpCache cache(false);
   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.
@@ skipping 20 matching lines @@
   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;
+  MockHttpCache cache(false);
   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.
@@ skipping 17 matching lines @@
   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;
+  MockHttpCache cache(false);
   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;
+  MockHttpCache cache(false);
   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.
@@ skipping 17 matching lines @@
   // 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;
+  MockHttpCache cache(false);
   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;
+  MockHttpCache cache(false);
   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;
+  MockHttpCache cache(false);
   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;
+  MockHttpCache cache(false);
   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;
 
   // 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());
 }
 
 // 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;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (70-79).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 70, 79);
@@ skipping 14 matching lines @@
   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;
+  MockHttpCache cache(false);
   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" EXTRA_HEADER;
@@ skipping 17 matching lines @@
   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;
+  MockHttpCache cache(false);
   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" EXTRA_HEADER;
   transaction.data = "";
   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);
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we can handle non-range requests when we have cached a range.
 TEST(HttpCache, GET_Previous206) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Write to the cache (40-49).
   RunTransactionTestWithResponseAndGetTiming(
       cache.http_cache(), kRangeGET_TransactionOK, &headers, log.bound(),
       &load_timing_info);
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we can handle non-range requests when we have cached the first
 // part of the object and the server replies with 304 (Not Modified).
 TEST(HttpCache, GET_Previous206_NotModified) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   AddMockTransaction(&transaction);
   std::string headers;
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Write to the cache (0-9).
   transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
   transaction.data = "rg: 00-09 ";
@@ skipping 29 matching lines @@
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we can handle a regular request to a sparse entry, that results in
 // new content provided by the server (206).
 TEST(HttpCache, GET_Previous206_NewContent) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (0-9).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
   transaction.data = "rg: 00-09 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 0, 9);
@@ skipping 25 matching lines @@
 
   // Verify that the previous request deleted the entry.
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we can handle cached 206 responses that are not sparse.
 TEST(HttpCache, GET_Previous206_NotSparse) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Create a disk cache entry that stores 206 headers while not being sparse.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.CreateBackendEntry(kSimpleGET_Transaction.url, &entry,
                                        NULL));
 
   std::string raw_headers(kRangeGET_TransactionOK.status);
   raw_headers.append("\n");
   raw_headers.append(kRangeGET_TransactionOK.response_headers);
   raw_headers =
@@ skipping 26 matching lines @@
   EXPECT_EQ(expected_headers, headers);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 }
 
 // Tests that we can handle cached 206 responses that are not sparse. This time
 // we issue a range request and expect to receive a range.
 TEST(HttpCache, RangeGET_Previous206_NotSparse_2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Create a disk cache entry that stores 206 headers while not being sparse.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry,
                                        NULL));
 
   std::string raw_headers(kRangeGET_TransactionOK.status);
   raw_headers.append("\n");
   raw_headers.append(kRangeGET_TransactionOK.response_headers);
@@ skipping 21 matching lines @@
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(1, 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 we can handle cached 206 responses that can't be validated.
 TEST(HttpCache, GET_Previous206_NotValidation) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Create a disk cache entry that stores 206 headers.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.CreateBackendEntry(kSimpleGET_Transaction.url, &entry,
                                        NULL));
 
   // Make sure that the headers cannot be validated with the server.
   std::string raw_headers(kRangeGET_TransactionOK.status);
   raw_headers.append("\n");
   raw_headers.append("Content-Length: 80\n");
@@ skipping 28 matching lines @@
 }
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_Previous200 DISABLED_RangeGET_Previous200
 #else
 #define MAYBE_RangeGET_Previous200 RangeGET_Previous200
 #endif
 // Tests that we can handle range requests with cached 200 responses.
 TEST(HttpCache, MAYBE_RangeGET_Previous200) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Store the whole thing with status 200.
   MockTransaction transaction(kTypicalGET_Transaction);
   transaction.url = kRangeGET_TransactionOK.url;
   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());
@@ skipping 48 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RunTransactionTest(cache.http_cache(), transaction2);
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we can handle a 200 response when dealing with sparse entries.
 TEST(HttpCache, RangeRequestResultsIn200) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (70-79).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   Verify206Response(headers, 70, 79);
@@ skipping 19 matching lines @@
   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(&transaction2);
 }
 
 // Tests that a range request that falls outside of the size that we know about
 // only deletes the entry if the resource has indeed changed.
 TEST(HttpCache, RangeGET_MoreThanCurrentSize) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (40-49).
   RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
                                  &headers);
 
   Verify206Response(headers, 40, 49);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 18 matching lines @@
 }
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_Cancel DISABLED_RangeGET_Cancel
 #else
 #define MAYBE_RangeGET_Cancel RangeGET_Cancel
 #endif
 // Tests that we don't delete a sparse entry when we cancel a request.
 TEST(HttpCache, MAYBE_RangeGET_Cancel) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   MockHttpRequest request(kRangeGET_TransactionOK);
 
   Context* c = new Context();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
@@ skipping 22 matching lines @@
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_Cancel2 DISABLED_RangeGET_Cancel2
 #else
 #define MAYBE_RangeGET_Cancel2 RangeGET_Cancel2
 #endif
 // Tests that we don't delete a sparse entry when we start a new request after
 // cancelling the previous one.
 TEST(HttpCache, MAYBE_RangeGET_Cancel2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.load_flags |= LOAD_VALIDATE_CACHE;
 
   Context* c = new Context();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
@@ skipping 24 matching lines @@
 
   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);
 }
 
 // A slight variation of the previous test, this time we cancel two requests in
 // a row, making sure that the second is waiting for the entry to be ready.
 TEST(HttpCache, RangeGET_Cancel3) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.load_flags |= LOAD_VALIDATE_CACHE;
 
   Context* c = new Context();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
@@ skipping 38 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   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 an invalid range response results in no cached entry.
 TEST(HttpCache, RangeGET_InvalidResponse1) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.handler = NULL;
   transaction.response_headers = "Content-Range: bytes 40-49/45\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);
 
   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 don't have a cached entry.
   disk_cache::Entry* entry;
   EXPECT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we reject a range that doesn't match the content-length.
 TEST(HttpCache, RangeGET_InvalidResponse2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.handler = NULL;
   transaction.response_headers = "Content-Range: bytes 40-49/80\n"
                                  "Content-Length: 20\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);
 
   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 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
 // drop the entry.
 TEST(HttpCache, RangeGET_InvalidResponse3) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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();
   AddMockTransaction(&transaction);
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
@@ skipping 19 matching lines @@
   // 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(HttpCache::DefaultBackend::InMemory(1024 * 1024));
+  MockHttpCache cache(HttpCache::DefaultBackend::InMemory(1024 * 1024), false);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.handler = NULL;
   transaction.request_headers = "Range: bytes = 4294967288-4294967297\r\n"
                                 EXTRA_HEADER;
   transaction.response_headers =
       "ETag: \"foo\"\n"
       "Content-Range: bytes 4294967288-4294967297/4294967299\n"
       "Content-Length: 10\n";
@@ skipping 15 matching lines @@
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we don't crash with a range request if the disk cache was not
 // initialized properly.
 TEST(HttpCache, RangeGET_NoDiskCache) {
   std::unique_ptr<MockBlockingBackendFactory> factory(
       new MockBlockingBackendFactory());
   factory->set_fail(true);
   factory->FinishCreation();  // We'll complete synchronously.
-  MockHttpCache cache(std::move(factory));
+  MockHttpCache cache(std::move(factory), false);
 
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we handle byte range requests that skip the cache.
 TEST(HttpCache, RangeHEAD) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
   transaction.method = "HEAD";
   transaction.data = "rg: 70-79 ";
 
   std::string headers;
   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(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;
+  MockHttpCache cache(false);
 
   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 |= LOAD_VALIDATE_CACHE;
 
   // 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";
   BoundTestNetLog 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());
   EXPECT_TRUE(LogContainsEventType(
       log, NetLogEventType::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;
+  MockHttpCache cache(false);
 
   // First, check with an empty cache (WRITE mode).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 40-49\r\n" EXTRA_HEADER;
   transaction.data = "rg: 40-";  // Less than expected.
   transaction.handler = NULL;
   std::string headers(transaction.response_headers);
   headers.append("Content-Range: bytes 40-49/80\n");
   transaction.response_headers = headers.c_str();
 
@@ skipping 19 matching lines @@
   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);
 }
 
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 // This test hits a NOTREACHED so it is a release mode only test.
 TEST(HttpCache, RangeGET_OK_LoadOnlyFromCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Write to the cache (40-49).
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Force this transaction to read from the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
@@ skipping 17 matching lines @@
   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(&kRangeGET_TransactionOK);
 }
 #endif
 
 // Tests the handling of the "truncation" flag.
 TEST(HttpCache, WriteResponseInfo_Truncated) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.CreateBackendEntry("http://www.google.com", &entry,
                                        NULL));
 
   std::string headers("HTTP/1.1 200 OK");
   headers = HttpUtil::AssembleRawHeaders(headers.data(), headers.size());
   HttpResponseInfo response;
   response.headers = new HttpResponseHeaders(headers);
 
   // Set the last argument for this to be an incomplete request.
@@ skipping 31 matching lines @@
   // Verify fields.
   EXPECT_TRUE(response2.was_cached);  // InitFromPickle sets this flag.
   EXPECT_EQ("1.2.3.4", response2.socket_address.host());
   EXPECT_EQ(80, response2.socket_address.port());
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 // Tests that we delete an entry when the request is cancelled before starting
 // to read from the network.
 TEST(HttpCache, DoomOnDestruction) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     c->result = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Destroy the transaction. We only have the headers so we should delete this
   // entry.
   delete c;
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 we delete an entry when the request is cancelled if the response
 // does not have content-length and strong validators.
 TEST(HttpCache, DoomOnDestruction2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
@@ skipping 15 matching lines @@
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 we delete an entry when the request is cancelled if the response
 // has an "Accept-Ranges: none" header.
 TEST(HttpCache, DoomOnDestruction3) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Accept-Ranges: none\n"
       "Etag: \"foopy\"\n";
   AddMockTransaction(&transaction);
   MockHttpRequest request(transaction);
 
@@ skipping 23 matching lines @@
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we mark an entry as incomplete when the request is cancelled.
 TEST(HttpCache, SetTruncatedFlag) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Etag: \"foopy\"\n";
   MockHttpRequest request(transaction);
 
   std::unique_ptr<Context> c(new Context());
 
@@ skipping 32 matching lines @@
   // could end up with the transaction being deleted twice if we send any
   // notification from the transaction destructor (see http://crbug.com/31723).
   EXPECT_FALSE(c->callback.have_result());
 
   // Verify that the entry is marked as incomplete.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
 }
 
 // Tests that we don't mark an entry as truncated when we read everything.
 TEST(HttpCache, DontSetTruncatedFlag) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Etag: \"foopy\"\n";
   MockHttpRequest request(transaction);
 
   std::unique_ptr<Context> c(new Context());
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   // Read everything.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(22));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(buf->size(), c->callback.GetResult(rv));
 
   // Destroy the transaction.
   c->trans.reset();
 
   // Verify that the entry is not marked as truncated.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, false, 0);
 }
 
 // Tests that sparse entries don't set the truncate flag.
 TEST(HttpCache, RangeGET_DontTruncate) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-19\r\n" EXTRA_HEADER;
 
   std::unique_ptr<MockHttpRequest> request(new MockHttpRequest(transaction));
   std::unique_ptr<HttpTransaction> trans;
 
   int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_THAT(rv, IsOk());
 
   TestCompletionCallback cb;
   rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(10));
   rv = trans->Read(buf.get(), 10, cb.callback());
   EXPECT_EQ(10, cb.GetResult(rv));
 
   // Should not trigger any DCHECK.
   trans.reset();
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 0);
 }
 
 // Tests that sparse entries don't set the truncate flag (when the byte range
 //  starts after 0).
 TEST(HttpCache, RangeGET_DontTruncate2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
 
   std::unique_ptr<MockHttpRequest> request(new MockHttpRequest(transaction));
   std::unique_ptr<HttpTransaction> trans;
 
   int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_THAT(rv, IsOk());
 
   TestCompletionCallback cb;
   rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(10));
   rv = trans->Read(buf.get(), 10, cb.callback());
   EXPECT_EQ(10, cb.GetResult(rv));
 
   // Should not trigger any DCHECK.
   trans.reset();
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 0);
 }
 
 // Tests that we can continue with a request that was interrupted.
 TEST(HttpCache, GET_IncompleteResource) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   ScopedMockTransaction transaction(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);
 
   // Now make a regular request.
@@ skipping 14 matching lines @@
   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 the disk entry was updated.
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 80);
 }
 
 // Tests the handling of no-store when revalidating a truncated entry.
 TEST(HttpCache, GET_IncompleteResource_NoStore) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 
@@ skipping 24 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Verify that the disk entry was deleted.
   disk_cache::Entry* entry;
   EXPECT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
   RemoveMockTransaction(&transaction);
 }
 
 // Tests cancelling a request after the server sent no-store.
 TEST(HttpCache, GET_IncompleteResource_Cancel) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 
@@ skipping 37 matching lines @@
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   base::RunLoop().RunUntilIdle();
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we delete truncated entries if the server changes its mind midway.
 TEST(HttpCache, GET_IncompleteResource2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Content-length will be intentionally bad.
   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: 50\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Verify that the disk entry was deleted.
   disk_cache::Entry* entry;
   ASSERT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we always validate a truncated request.
 TEST(HttpCache, GET_IncompleteResource3) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // This should not require validation for 10 hours.
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Cache-Control: max-age= 36000\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
@@ skipping 15 matching lines @@
   // We should have checked with the server before finishing Start().
   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(&kRangeGET_TransactionOK);
 }
 
 // Tests that we handle 401s for truncated resources.
 TEST(HttpCache, GET_IncompleteResourceWithAuth) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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);
 
   // Now make a regular request.
@@ skipping 28 matching lines @@
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
   entry->Close();
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Test that the transaction won't retry failed partial requests
 // after it starts reading data.  http://crbug.com/474835
 TEST(HttpCache, TransactionRetryLimit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Cache 0-9, so that we have data to read before failing.
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
   transaction.data = "rg: 00-09 ";
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
@@ skipping 14 matching lines @@
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   std::string content;
   rv = ReadTransaction(c->trans.get(), &content);
   EXPECT_THAT(rv, IsError(ERR_CACHE_AUTH_FAILURE_AFTER_READ));
 }
 
 // Tests that we cache a 200 response to the validation request.
 TEST(HttpCache, GET_IncompleteResource4) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2009 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;
   transaction.request_headers = EXTRA_HEADER;
   transaction.data = "Not a range";
   RangeTransactionServer handler;
   handler.set_bad_200(true);
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Verify that the disk entry was updated.
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 11);
 }
 
 // Tests that when we cancel a request that was interrupted, we mark it again
 // as truncated.
 TEST(HttpCache, GET_CancelIncompleteResource) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2009 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.
@@ skipping 21 matching lines @@
   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 the disk entry was updated: now we have 30 bytes.
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, true, 30);
 }
 
 // Tests that we can handle range requests when we have a truncated entry.
 TEST(HttpCache, RangeGET_IncompleteResource) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Content-length will be intentionally bogus.
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: something\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 10\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a range request.
   std::string headers;
   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(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 TEST(HttpCache, SyncRead) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // This test ensures that a read that completes synchronously does not cause
   // any problems.
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.test_mode |= (TEST_MODE_SYNC_CACHE_START |
                             TEST_MODE_SYNC_CACHE_READ |
                             TEST_MODE_SYNC_CACHE_WRITE);
 
   MockHttpRequest r1(transaction),
@@ skipping 17 matching lines @@
   EXPECT_TRUE(c1.is_done());
   EXPECT_TRUE(c2.is_done());
   EXPECT_TRUE(c3.is_done());
 
   EXPECT_THAT(c1.error(), IsOk());
   EXPECT_THAT(c2.error(), IsOk());
   EXPECT_THAT(c3.error(), IsOk());
 }
 
 TEST(HttpCache, ValidationResultsIn200) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // This test ensures that a conditional request, which results in a 200
   // instead of a 304, properly truncates the existing response data.
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
 
   // force this transaction to validate the cache
   MockTransaction transaction(kETagGET_Transaction);
   transaction.load_flags |= LOAD_VALIDATE_CACHE;
   RunTransactionTest(cache.http_cache(), transaction);
 
   // read from the cache
   RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
 }
 
 TEST(HttpCache, CachedRedirect) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
   kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
   kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
 
   MockHttpRequest request(kTestTransaction);
   TestCompletionCallback callback;
 
   // Write to the cache.
   {
@@ skipping 55 matching lines @@
     // read the response body -- want to test that it is still getting cached.
   }
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Verify that no-cache resources are stored in cache, but are not fetched from
 // cache during normal loads.
 TEST(HttpCache, CacheControlNoCacheNormalLoad) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "cache-control: no-cache\n";
 
   // Initial load.
   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());
 
   // Try loading again; it should result in a network fetch.
   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());
 
   disk_cache::Entry* entry;
   EXPECT_TRUE(cache.OpenBackendEntry(transaction.url, &entry));
   entry->Close();
 }
 
 // Verify that no-cache resources are stored in cache and fetched from cache
 // when the LOAD_SKIP_CACHE_VALIDATION flag is set.
 TEST(HttpCache, CacheControlNoCacheHistoryLoad) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "cache-control: no-cache\n";
 
   // Initial load.
   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());
 
   // Try loading again with LOAD_SKIP_CACHE_VALIDATION.
   transaction.load_flags = LOAD_SKIP_CACHE_VALIDATION;
   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());
 
   disk_cache::Entry* entry;
   EXPECT_TRUE(cache.OpenBackendEntry(transaction.url, &entry));
   entry->Close();
 }
 
 TEST(HttpCache, CacheControlNoStore) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "cache-control: no-store\n";
 
   // initial load
   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());
 
   // try loading again; it should result in a network fetch
   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());
 
   disk_cache::Entry* entry;
   EXPECT_FALSE(cache.OpenBackendEntry(transaction.url, &entry));
 }
 
 TEST(HttpCache, CacheControlNoStore2) {
   // this test is similar to the above test, except that the initial response
   // is cachable, but when it is validated, no-store is received causing the
   // cached document to be deleted.
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_Transaction);
 
   // initial load
   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());
 
   // try loading again; it should result in a network fetch
   transaction.load_flags = LOAD_VALIDATE_CACHE;
   transaction.response_headers = "cache-control: no-store\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());
 
   disk_cache::Entry* entry;
   EXPECT_FALSE(cache.OpenBackendEntry(transaction.url, &entry));
 }
 
 TEST(HttpCache, CacheControlNoStore3) {
   // this test is similar to the above test, except that the response is a 304
   // instead of a 200.  this should never happen in practice, but it seems like
   // a good thing to verify that we still destroy the cache entry.
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_Transaction);
 
   // initial load
   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());
 
   // try loading again; it should result in a network fetch
   transaction.load_flags = LOAD_VALIDATE_CACHE;
   transaction.response_headers = "cache-control: no-store\n";
   transaction.status = "HTTP/1.1 304 Not Modified";
   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());
 
   disk_cache::Entry* entry;
   EXPECT_FALSE(cache.OpenBackendEntry(transaction.url, &entry));
 }
 
 // Ensure that we don't cache requests served over bad HTTPS.
 TEST(HttpCache, SimpleGET_SSLError) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction = kSimpleGET_Transaction;
   transaction.cert_status = CERT_STATUS_REVOKED;
   ScopedMockTransaction scoped_transaction(transaction);
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Test that it was not cached.
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
-  MockHttpCache* cache = new MockHttpCache;
+  MockHttpCache* cache = new MockHttpCache(false);
 
   std::unique_ptr<HttpTransaction> trans;
   EXPECT_THAT(cache->CreateTransaction(&trans), IsOk());
 
   delete cache;
   trans.reset();
 }
 
 // Test that the disabled mode works.
 TEST(HttpCache, CacheDisabledMode) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // go into disabled mode
   cache.http_cache()->set_mode(HttpCache::DISABLE);
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Other tests check that the response headers of the cached response
 // get updated on 304. Here we specifically check that the
 // HttpResponseHeaders::request_time and HttpResponseHeaders::response_time
 // fields also gets updated.
 // http://crbug.com/20594.
 TEST(HttpCache, UpdatesRequestResponseTimeOn304) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   const char kUrl[] = "http://foobar";
   const char kData[] = "body";
 
   MockTransaction mock_network_response = { 0 };
   mock_network_response.url = kUrl;
 
   AddMockTransaction(&mock_network_response);
 
   // Request |kUrl|, causing |kNetResponse1| to be written to the cache.
@@ skipping 49 matching lines @@
   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);
 }
 
 // Tests that we can write metadata to an entry.
 TEST(HttpCache, WriteMetadata_OK) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache
   HttpResponseInfo response;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   // Trivial call.
   cache.http_cache()->WriteMetadata(GURL("foo"), DEFAULT_PRIORITY, Time::Now(),
                                     NULL, 0);
@@ skipping 18 matching lines @@
   EXPECT_EQ(50, response.metadata->size());
   EXPECT_EQ(0, strcmp(response.metadata->data(), "Hi there"));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we only write metadata to an entry if the time stamp matches.
 TEST(HttpCache, WriteMetadata_Fail) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache
   HttpResponseInfo response;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   // Attempt to write meta data to the same entry.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(50));
   memset(buf->data(), 0, buf->size());
@@ skipping 12 matching lines @@
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we ignore VARY checks when writing metadata since the request
 // headers for the WriteMetadata transaction are made up.
 TEST(HttpCache, WriteMetadata_IgnoreVary) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache
   HttpResponseInfo response;
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.request_headers = "accept-encoding: gzip\r\n";
   transaction.response_headers =
       "Vary: accept-encoding\n"
       "Cache-Control: max-age=10000\n";
 
   RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
@@ skipping 16 matching lines @@
   ASSERT_TRUE(response.metadata);
   EXPECT_EQ(50, response.metadata->size());
   EXPECT_EQ(0, strcmp(response.metadata->data(), "Hi there"));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SkipVaryCheck) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write a simple vary transaction to the cache.
   HttpResponseInfo response;
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.request_headers = "accept-encoding: gzip\r\n";
   transaction.response_headers =
       "Vary: accept-encoding\n"
       "Cache-Control: max-age=10000\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Change the request headers so that the request doesn't match due to vary.
   // The request should fail.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE;
   transaction.request_headers = "accept-encoding: foo\r\n";
   transaction.return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Change the load flags to ignore vary checks, the request should now hit.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_VARY_CHECK;
   transaction.return_code = OK;
   RunTransactionTest(cache.http_cache(), transaction);
 }
 
 // Tests that we only return valid entries with LOAD_ONLY_FROM_CACHE
 // transactions unless LOAD_SKIP_CACHE_VALIDATION is set.
 TEST(HttpCache, ValidLoadOnlyFromCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   cache.http_cache()->SetClockForTesting(base::WrapUnique(clock));
   cache.network_layer()->SetClock(clock);
 
   // Write a resource that will expire in 100 seconds.
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "Cache-Control: max-age=100\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Move forward in time such that the cached response is no longer valid.
   clock->Advance(base::TimeDelta::FromSeconds(101));
 
   // Skipping cache validation should still return a response.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   RunTransactionTest(cache.http_cache(), transaction);
 
   // If the cache entry is checked for validitiy, it should fail.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE;
   transaction.return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 }
 
 TEST(HttpCache, InvalidLoadFlagCombination) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Put the resource in the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // Now try to fetch it again, but with a flag combination disallowing both
   // cache and network access.
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   // DevTools relies on this combination of flags for "disable cache" mode
   // when a resource is only supposed to be loaded from cache.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_BYPASS_CACHE;
   transaction.return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 }
 
 // Tests that we can read metadata after validating the entry and with READ mode
 // transactions.
 TEST(HttpCache, ReadMetadata) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Write to the cache
   HttpResponseInfo response;
   RunTransactionTestWithResponseInfo(cache.http_cache(),
                                      kTypicalGET_Transaction, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   // Write meta data to the same entry.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(50));
   memset(buf->data(), 0, buf->size());
@@ skipping 41 matching lines @@
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we don't mark entries as truncated when a filter detects the end
 // of the stream.
 TEST(HttpCache, FilterCompletion) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
 
   {
     std::unique_ptr<HttpTransaction> trans;
     ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
     MockHttpRequest request(kSimpleGET_Transaction);
     int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
@@ skipping 13 matching lines @@
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we don't mark entries as truncated and release the cache
 // entry when DoneReading() is called before any Read() calls, such as
 // for a redirect.
 TEST(HttpCache, DoneReading) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.data = "";
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
   MockHttpRequest request(transaction);
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   trans->DoneReading();
   // Leave the transaction around.
 
   // Make sure that the ActiveEntry is gone.
   base::RunLoop().RunUntilIdle();
 
   // Read from the cache. This should not deadlock.
   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());
 }
 
 // Tests that we stop caching when told.
 TEST(HttpCache, StopCachingDeletesEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
     std::unique_ptr<HttpTransaction> trans;
     ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
     int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
@@ skipping 17 matching lines @@
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 we stop caching when told, even if DoneReading is called
 // after StopCaching.
 TEST(HttpCache, StopCachingThenDoneReadingDeletesEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
     std::unique_ptr<HttpTransaction> trans;
     ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
     int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
@@ skipping 19 matching lines @@
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 we stop caching when told, when using auth.
 TEST(HttpCache, StopCachingWithAuthDeletesEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
   MockTransaction mock_transaction(kSimpleGET_Transaction);
   mock_transaction.status = "HTTP/1.1 401 Unauthorized";
   AddMockTransaction(&mock_transaction);
   MockHttpRequest request(mock_transaction);
 
   {
     std::unique_ptr<HttpTransaction> trans;
     ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
@@ skipping 14 matching lines @@
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 we are told to stop caching we don't throw away valid data.
 TEST(HttpCache, StopCachingSavesEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
     std::unique_ptr<HttpTransaction> trans;
     ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
     // Force a response that can be resumed.
     ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
     AddMockTransaction(&mock_transaction);
@@ skipping 16 matching lines @@
     rv = trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 0);
   }
 
   // Verify that the entry is marked as incomplete.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
 }
 
 // Tests that we handle truncated enries when StopCaching is called.
 TEST(HttpCache, StopCachingTruncatedEntry) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.extra_headers.Clear();
   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"
@@ skipping 229 matching lines @@
 // fetched via GET. Various combinations of cache state and when StopCaching()
 // is called is controlled by the parameter passed into the test via the
 // INSTANTIATE_TEST_CASE_P invocation above.
 TEST_P(HttpCacheHugeResourceTest,
        StopCachingFollowedByReadForHugeTruncatedResource) {
   // This test is going to be repeated for all combinations of TransactionPhase
   // and CacheInitializers returned by GetTestModes().
   const TransactionPhase stop_caching_phase = GetParam().first;
   const CacheInitializer cache_initializer = GetParam().second;
 
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   (*cache_initializer)(&cache);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.url = kRangeGET_TransactionOK.url;
   transaction.handler = &LargeResourceTransactionHandler;
   transaction.read_handler = &LargeBufferReader;
   ScopedMockTransaction scoped_transaction(transaction);
 
   MockHttpRequest request(transaction);
   net::TestCompletionCallback callback;
@@ skipping 46 matching lines @@
 
   // The only verification we are going to do is that the received resource has
   // the correct size. This is sufficient to verify that the state machine
   // didn't terminate abruptly due to the StopCaching() call.
   EXPECT_EQ(kTotalSize, total_bytes_received);
 }
 
 // Tests that we detect truncated resources from the net when there is
 // a Content-Length header.
 TEST(HttpCache, TruncatedByContentLength) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   transaction.response_headers = "Cache-Control: max-age=10000\n"
                                  "Content-Length: 100\n";
   RunTransactionTest(cache.http_cache(), transaction);
   RemoveMockTransaction(&transaction);
 
   // Read from the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_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 we actually flag entries as truncated when we detect an error
 // from the net.
 TEST(HttpCache, TruncatedByContentLength2) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   TestCompletionCallback callback;
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   transaction.response_headers = "Cache-Control: max-age=10000\n"
                                  "Content-Length: 100\n"
                                  "Etag: \"foo\"\n";
   RunTransactionTest(cache.http_cache(), transaction);
   RemoveMockTransaction(&transaction);
 
   // Verify that the entry is marked as incomplete.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
 }
 
 // Make sure that calling SetPriority on a cache transaction passes on
 // its priority updates to its underlying network transaction.
 TEST(HttpCache, SetPriority) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &trans), IsOk());
 
   // Shouldn't crash, but doesn't do anything either.
   trans->SetPriority(LOW);
 
   EXPECT_FALSE(cache.network_layer()->last_transaction());
   EXPECT_EQ(DEFAULT_PRIORITY,
             cache.network_layer()->last_create_transaction_priority());
@@ skipping 16 matching lines @@
     EXPECT_EQ(LOW, cache.network_layer()->last_create_transaction_priority());
     EXPECT_EQ(HIGHEST, cache.network_layer()->last_transaction()->priority());
   }
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Make sure that calling SetWebSocketHandshakeStreamCreateHelper on a cache
 // transaction passes on its argument to the underlying network transaction.
 TEST(HttpCache, SetWebSocketHandshakeStreamCreateHelper) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   FakeWebSocketHandshakeStreamCreateHelper create_helper;
   std::unique_ptr<HttpTransaction> trans;
   ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &trans), IsOk());
 
   EXPECT_FALSE(cache.network_layer()->last_transaction());
 
   HttpRequestInfo info;
   info.url = GURL(kSimpleGET_Transaction.url);
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans->Start(&info, callback.callback(), NetLogWithSource()));
 
   ASSERT_TRUE(cache.network_layer()->last_transaction());
   EXPECT_FALSE(cache.network_layer()->last_transaction()->
                websocket_handshake_stream_create_helper());
   trans->SetWebSocketHandshakeStreamCreateHelper(&create_helper);
   EXPECT_EQ(&create_helper,
             cache.network_layer()->last_transaction()->
             websocket_handshake_stream_create_helper());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Make sure that a cache transaction passes on its priority to
 // newly-created network transactions.
 TEST(HttpCache, SetPriorityNewTransaction) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   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);
 
   // Now make a regular request.
@@ skipping 32 matching lines @@
                                       int64_t* sent_bytes,
                                       int64_t* received_bytes) {
   RunTransactionTestBase(
       cache.http_cache(), trans_info, MockHttpRequest(trans_info), nullptr,
       NetLogWithSource(), nullptr, sent_bytes, received_bytes, nullptr);
 }
 
 }  // namespace
 
 TEST(HttpCache, NetworkBytesCacheMissAndThenHit) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   int64_t sent, received;
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(0, sent);
   EXPECT_EQ(0, received);
 }
 
 TEST(HttpCache, NetworkBytesConditionalRequest304) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kETagGET_Transaction);
   int64_t sent, received;
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   transaction.load_flags = LOAD_VALIDATE_CACHE;
   transaction.handler = ETagGet_ConditionalRequest_Handler;
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 }
 
 TEST(HttpCache, NetworkBytesConditionalRequest200) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   MockTransaction transaction(kTypicalGET_Transaction);
   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);
   int64_t sent, received;
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   RevalidationServer server;
   transaction.handler = server.Handler;
   transaction.request_headers = "Foo: none\r\n";
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   RemoveMockTransaction(&transaction);
 }
 
 TEST(HttpCache, NetworkBytesRange) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   AddMockTransaction(&kRangeGET_TransactionOK);
   MockTransaction transaction(kRangeGET_TransactionOK);
 
   // Read bytes 40-49 from the network.
   int64_t sent, received;
   RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
   EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
   EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   // Read bytes 40-49 from the cache.
@@ skipping 19 matching lines @@
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 class HttpCachePrefetchValidationTest : public ::testing::Test {
  protected:
   static const int kNumSecondsPerMinute = 60;
   static const int kMaxAgeSecs = 100;
   static const int kRequireValidationSecs = kMaxAgeSecs + 1;
 
-  HttpCachePrefetchValidationTest() : transaction_(kSimpleGET_Transaction) {
+  HttpCachePrefetchValidationTest()
+      : cache_(false), transaction_(kSimpleGET_Transaction) {
     DCHECK_LT(kMaxAgeSecs, prefetch_reuse_mins() * kNumSecondsPerMinute);
 
     clock_ = new base::SimpleTestClock();
     cache_.http_cache()->SetClockForTesting(base::WrapUnique(clock_));
     cache_.network_layer()->SetClock(clock_);
 
     transaction_.response_headers = "Cache-Control: max-age=100\n";
   }
 
   bool TransactionRequiredNetwork(int load_flags) {
@@ skipping 96 matching lines @@
                                          std::string* response_headers,
                                          std::string* response_data) {
   std::string value;
   EXPECT_TRUE(request->extra_headers.GetHeader("Resource-Freshness", &value));
   EXPECT_EQ("max-age=3600,stale-while-revalidate=7200,age=10801", value);
 }
 
 // Verify that the Resource-Freshness header is sent on a revalidation if the
 // stale-while-revalidate directive was on the response.
 TEST(HttpCache, ResourceFreshnessHeaderSent) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction stale_while_revalidate_transaction(
       kSimpleGET_Transaction);
   stale_while_revalidate_transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
       "Age: 10801\n"
       "Cache-Control: max-age=3600,stale-while-revalidate=7200\n";
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
@@ skipping 11 matching lines @@
 static void CheckResourceFreshnessAbsent(const HttpRequestInfo* request,
                                          std::string* response_status,
                                          std::string* response_headers,
                                          std::string* response_data) {
   EXPECT_FALSE(request->extra_headers.HasHeader("Resource-Freshness"));
 }
 
 // Verify that the Resource-Freshness header is not sent when
 // stale-while-revalidate is 0.
 TEST(HttpCache, ResourceFreshnessHeaderNotSent) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction stale_while_revalidate_transaction(
       kSimpleGET_Transaction);
   stale_while_revalidate_transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
       "Age: 10801\n"
       "Cache-Control: max-age=3600,stale-while-revalidate=0\n";
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // Send the request again and check that Resource-Freshness header is absent.
   stale_while_revalidate_transaction.handler = CheckResourceFreshnessAbsent;
 
   RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 }
 
 TEST(HttpCache, StaleContentNotUsedWhenLoadFlagNotSet) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction stale_while_revalidate_transaction(
       kSimpleGET_Transaction);
 
   stale_while_revalidate_transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
       "Age: 10801\n"
       "Cache-Control: max-age=0,stale-while-revalidate=86400\n";
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // Send the request again and check that it is sent to the network again.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(
       cache.http_cache(), stale_while_revalidate_transaction, &response_info);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_FALSE(response_info.async_revalidation_required);
 }
 
 TEST(HttpCache, StaleContentUsedWhenLoadFlagSetAndUsable) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction stale_while_revalidate_transaction(
       kSimpleGET_Transaction);
   stale_while_revalidate_transaction.load_flags |=
       LOAD_SUPPORT_ASYNC_REVALIDATION;
   stale_while_revalidate_transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
       "Age: 10801\n"
       "Cache-Control: max-age=0,stale-while-revalidate=86400\n";
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // Send the request again and check that it is not sent to the network again.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(
       cache.http_cache(), stale_while_revalidate_transaction, &response_info);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_TRUE(response_info.async_revalidation_required);
 }
 
 TEST(HttpCache, StaleContentNotUsedWhenUnusable) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction stale_while_revalidate_transaction(
       kSimpleGET_Transaction);
   stale_while_revalidate_transaction.load_flags |=
       LOAD_SUPPORT_ASYNC_REVALIDATION;
   stale_while_revalidate_transaction.response_headers =
       "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
       "Age: 10801\n"
       "Cache-Control: max-age=0,stale-while-revalidate=1800\n";
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // Send the request again and check that it is sent to the network again.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(
       cache.http_cache(), stale_while_revalidate_transaction, &response_info);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_FALSE(response_info.async_revalidation_required);
 }
 
 // Tests that we allow multiple simultaneous, non-overlapping transactions to
 // take place on a sparse entry.
 TEST(HttpCache, RangeGET_MultipleRequests) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   // Create a transaction for bytes 0-9.
   MockHttpRequest request(kRangeGET_TransactionOK);
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
   transaction.data = "rg: 00-09 ";
   AddMockTransaction(&transaction);
 
   TestCompletionCallback callback;
   std::unique_ptr<HttpTransaction> trans;
@@ skipping 13 matching lines @@
   callback.WaitForResult();
 
   RemoveMockTransaction(&transaction);
 }
 
 // Makes sure that a request stops using the cache when the response headers
 // with "Cache-Control: no-store" arrives. That means that another request for
 // the same URL can be processed before the response body of the original
 // request arrives.
 TEST(HttpCache, NoStoreResponseShouldNotBlockFollowingRequests) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
   mock_transaction.response_headers = "Cache-Control: no-store\n";
   MockHttpRequest request(mock_transaction);
 
   std::unique_ptr<Context> first(new Context);
   first->result = cache.CreateTransaction(&first->trans);
   ASSERT_THAT(first->result, IsOk());
   EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
   first->result = first->trans->Start(&request, first->callback.callback(),
                                       NetLogWithSource());
@@ skipping 29 matching lines @@
 TEST(HttpCache, CachePreservesSSLInfo) {
   static const uint16_t kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xc02f;
   int status = 0;
   SSLConnectionStatusSetCipherSuite(kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
                                     &status);
   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2, &status);
 
   scoped_refptr<X509Certificate> cert =
       ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
 
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.cert = cert;
   transaction.ssl_connection_status = status;
 
   // Fetch the resource.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
                                      &response_info);
 
@@ skipping 32 matching lines @@
   int status2 = 0;
   SSLConnectionStatusSetCipherSuite(kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
                                     &status2);
   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2, &status2);
 
   scoped_refptr<X509Certificate> cert1 =
       ImportCertFromFile(GetTestCertsDirectory(), "expired_cert.pem");
   scoped_refptr<X509Certificate> cert2 =
       ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
 
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   ScopedMockTransaction transaction(kTypicalGET_Transaction);
   transaction.cert = cert1;
   transaction.ssl_connection_status = status1;
 
   // Fetch the resource.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
                                      &response_info);
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   EXPECT_TRUE(response_info.was_cached);
 
   // The new SSL state is reported.
   EXPECT_EQ(status2, response_info.ssl_info.connection_status);
   EXPECT_TRUE(cert2->Equals(response_info.ssl_info.cert.get()));
 }
 
 TEST(HttpCache, CacheEntryStatusOther) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kRangeGET_Transaction,
                                      &response_info);
 
   EXPECT_FALSE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_OTHER, response_info.cache_entry_status);
 }
 
 TEST(HttpCache, CacheEntryStatusNotInCache) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
 
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response_info);
 
   EXPECT_FALSE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_NOT_IN_CACHE,
             response_info.cache_entry_status);
 }
 
 TEST(HttpCache, CacheEntryStatusUsed) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response_info);
 
   EXPECT_TRUE(response_info.was_cached);
   EXPECT_FALSE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_USED, response_info.cache_entry_status);
 }
 
 TEST(HttpCache, CacheEntryStatusValidated) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
 
   ScopedMockTransaction still_valid(kETagGET_Transaction);
   still_valid.load_flags = LOAD_VALIDATE_CACHE;  // Force a validation.
   still_valid.handler = ETagGet_ConditionalRequest_Handler;
 
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), still_valid,
                                      &response_info);
 
   EXPECT_TRUE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_VALIDATED,
             response_info.cache_entry_status);
 }
 
 TEST(HttpCache, CacheEntryStatusUpdated) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
 
   ScopedMockTransaction update(kETagGET_Transaction);
   update.load_flags = LOAD_VALIDATE_CACHE;  // Force a validation.
 
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), update,
                                      &response_info);
 
   EXPECT_FALSE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_UPDATED, response_info.cache_entry_status);
 }
 
 TEST(HttpCache, CacheEntryStatusCantConditionalize) {
-  MockHttpCache cache;
+  MockHttpCache cache(false);
   cache.FailConditionalizations();
   RunTransactionTest(cache.http_cache(), kTypicalGET_Transaction);
 
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(),
                                      kTypicalGET_Transaction, &response_info);
 
   EXPECT_FALSE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE,
             response_info.cache_entry_status);
 }
 
 }  // namespace net