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 629 matching lines @@
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
   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);

[Ryan Hamilton, 2017/02/02 01:07:09]

I think you can revert these changes now, right?

[Zhongyi Shi, 2017/02/02 01:32:13]

Added one more constructor in the MockHttpCache so that we could get rid of this
change. 

 
   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;
@@ skipping 47 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) {
@@ skipping 728 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 317 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 1155 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;
@@ skipping 2288 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.
@@ skipping 1100 matching lines @@
   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) {
@@ skipping 1107 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 498 matching lines @@
   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