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

net/http/disk_cache_based_quic_server_info_unittest.cc

 // Copyright 2014 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/disk_cache_based_quic_server_info.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 76 matching lines @@
 };
 
 }  // namespace
 
 // Tests that we can delete a DiskCacheBasedQuicServerInfo object in a
 // completion callback for DiskCacheBasedQuicServerInfo::WaitForDataReady.
 TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
   // Use the blocking mock backend factory to force asynchronous completion
   // of quic_server_info->WaitForDataReady(), so that the callback will run.
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(base::WrapUnique(factory));
+  MockHttpCache cache(base::WrapUnique(factory), true);
   QuicServerId server_id("www.verisign.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   quic_server_info->Start();
   TestCompletionCallback callback;
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Now complete the backend creation and let the callback run.
   factory->FinishCreation();
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 }
 
 // Tests the basic logic of storing, retrieving and updating data.
 TEST(DiskCacheBasedQuicServerInfo, Update) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
@@ skipping 50 matching lines @@
   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
   EXPECT_EQ(2U, state1.certs.size());
   EXPECT_EQ(cert_a, state1.certs[0]);
   EXPECT_EQ(cert_b, state1.certs[1]);
 
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 // Test that demonstrates different info is returned when the ports differ.
 TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
   AddMockTransaction(&kHostInfoTransaction2);
   TestCompletionCallback callback;
 
   // Persist data for port 443.
   QuicServerId server_id1("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info1(
       new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache()));
   quic_server_info1->Start();
   int rv = quic_server_info1->WaitForDataReady(callback.callback());
@@ skipping 80 matching lines @@
   EXPECT_EQ(server_config_sig_b, state_b.server_config_sig);
   EXPECT_EQ(1U, state_b.certs.size());
   EXPECT_EQ(cert_b, state_b.certs[0]);
 
   RemoveMockTransaction(&kHostInfoTransaction2);
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 // Test IsReadyToPersist when there is a pending write.
 TEST(DiskCacheBasedQuicServerInfo, IsReadyToPersist) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
@@ skipping 41 matching lines @@
   EXPECT_EQ(chlo_hash_a, state1.chlo_hash);
   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
   EXPECT_EQ(1U, state1.certs.size());
   EXPECT_EQ(cert_a, state1.certs[0]);
 
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 // Test multiple calls to Persist.
 TEST(DiskCacheBasedQuicServerInfo, MultiplePersist) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
@@ skipping 69 matching lines @@
   EXPECT_EQ(chlo_hash_a, state1.chlo_hash);
   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
   EXPECT_EQ(1U, state1.certs.size());
   EXPECT_EQ(cert_a, state1.certs[0]);
 
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 TEST(DiskCacheBasedQuicServerInfo, CancelWaitForDataReady) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(base::WrapUnique(factory));
+  MockHttpCache cache(base::WrapUnique(factory), true);
   TestCompletionCallback callback;
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Now cancel the callback.
   quic_server_info->CancelWaitForDataReadyCallback();
   EXPECT_FALSE(quic_server_info->IsDataReady());
   // Now complete the backend creation and let the callback run.
   factory->FinishCreation();
   EXPECT_TRUE(quic_server_info->IsDataReady());
 }
 
 TEST(DiskCacheBasedQuicServerInfo, CancelWaitForDataReadyButDataIsReady) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   quic_server_info->CancelWaitForDataReadyCallback();
   EXPECT_THAT(callback.GetResult(rv), IsOk());
   EXPECT_TRUE(quic_server_info->IsDataReady());
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 TEST(DiskCacheBasedQuicServerInfo, CancelWaitForDataReadyAfterDeleteCache) {
   std::unique_ptr<QuicServerInfo> quic_server_info;
   {
-    MockHttpCache cache;
+    MockHttpCache cache(true);
     AddMockTransaction(&kHostInfoTransaction1);
     TestCompletionCallback callback;
 
     QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
     quic_server_info.reset(
         new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
     EXPECT_FALSE(quic_server_info->IsDataReady());
     quic_server_info->Start();
     int rv = quic_server_info->WaitForDataReady(callback.callback());
     quic_server_info->CancelWaitForDataReadyCallback();
     EXPECT_THAT(callback.GetResult(rv), IsOk());
     EXPECT_TRUE(quic_server_info->IsDataReady());
     RemoveMockTransaction(&kHostInfoTransaction1);
   }
   // Cancel the callback after Cache is deleted.
   quic_server_info->ResetWaitForDataReadyCallback();
 }
 
 // Test Start() followed by Persist() without calling WaitForDataReady.
 TEST(DiskCacheBasedQuicServerInfo, StartAndPersist) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   // Wait until Start() does the work.
   base::RunLoop().RunUntilIdle();
 
@@ skipping 45 matching lines @@
   EXPECT_EQ(1U, state1.certs.size());
   EXPECT_EQ(cert_a, state1.certs[0]);
 
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 // Test Persisting data when we are not ready to persist and then verify it
 // persists the data when Start() finishes.
 TEST(DiskCacheBasedQuicServerInfo, PersistWhenNotReadyToPersist) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(base::WrapUnique(factory));
+  MockHttpCache cache(base::WrapUnique(factory), true);
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   // We do a Start(), but don't call WaitForDataReady(). Because we haven't
   // created the backend, we will wait and data wouldn't be ready.
   quic_server_info->Start();
@@ skipping 40 matching lines @@
   EXPECT_EQ(cert_sct_init, state1.cert_sct);
   EXPECT_EQ(chlo_hash_init, state1.chlo_hash);
   EXPECT_EQ(server_config_sig_init, state1.server_config_sig);
   EXPECT_EQ(1U, state1.certs.size());
   EXPECT_EQ(cert_init, state1.certs[0]);
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 // Test multiple calls to Persist without waiting for the data to be written.
 TEST(DiskCacheBasedQuicServerInfo, MultiplePersistsWithoutWaiting) {
-  MockHttpCache cache;
+  MockHttpCache cache(true);
   AddMockTransaction(&kHostInfoTransaction1);
   TestCompletionCallback callback;
 
   QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
   std::unique_ptr<QuicServerInfo> quic_server_info(
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
   EXPECT_FALSE(quic_server_info->IsDataReady());
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(callback.callback());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
@@ skipping 65 matching lines @@
 
   RemoveMockTransaction(&kHostInfoTransaction1);
 }
 
 // crbug.com/439209: test deletion of QuicServerInfo object in the callback
 // doesn't crash.
 TEST(DiskCacheBasedQuicServerInfo, DeleteServerInfoInCallback) {
   // Use the blocking mock backend factory to force asynchronous completion
   // of quic_server_info->WaitForDataReady(), so that the callback will run.
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(base::WrapUnique(factory));
+  MockHttpCache cache(base::WrapUnique(factory), true);
   QuicServerId server_id("www.verisign.com", 443, PRIVACY_MODE_DISABLED);
   QuicServerInfo* quic_server_info =
       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache());
   // |cb| takes owndership and deletes |quic_server_info| when it is called.
   DeleteCacheCompletionCallback cb(quic_server_info);
   quic_server_info->Start();
   int rv = quic_server_info->WaitForDataReady(cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   // Now complete the backend creation and let the callback run.
   factory->FinishCreation();
   EXPECT_THAT(cb.GetResult(rv), IsOk());
 }
 
 }  // namespace net