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

net/http/http_cache_lookup_manager_unittest.cc

 // Copyright (c) 2016 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 <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 65 matching lines @@
 
   EXPECT_THAT(rv, IsOk());
   std::string expected(mock_trans->data);
   EXPECT_EQ(expected, content);
   RemoveMockTransaction(mock_trans.get());
 }
 
 }  // namespace
 
 TEST(HttpCacheLookupManagerTest, ServerPushMissCache) {
-  MockHttpCache mock_cache;
+  MockHttpCache mock_cache(false);

[Ryan Hamilton, 2017/01/31 01:32:26]

You might also consider keeping the old no-arg constructor to make this CL
smaller. But totally up to you.

[Zhongyi Shi, 2017/02/02 01:05:12]

Done.

   HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
                                        NetLogWithSource());
   GURL request_url("http://www.example.com/pushed.jpg");
 
   std::unique_ptr<MockServerPushHelper> push_helper =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr = push_helper.get();
 
   // Receive a server push and should not cancel the push.
   EXPECT_CALL(*push_helper_ptr, Cancel()).Times(0);
   push_delegate.OnPush(std::move(push_helper));
   base::RunLoop().RunUntilIdle();
 
   // Make sure no network transaction is created.
   EXPECT_EQ(0, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(0, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(0, mock_cache.disk_cache()->create_count());
 }
 
 TEST(HttpCacheLookupManagerTest, ServerPushDoNotCreateCacheEntry) {
-  MockHttpCache mock_cache;
+  MockHttpCache mock_cache(false);
   HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
                                        NetLogWithSource());
   GURL request_url("http://www.example.com/pushed.jpg");
 
   std::unique_ptr<MockServerPushHelper> push_helper =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr = push_helper.get();
 
   // Receive a server push and should not cancel the push.
   EXPECT_CALL(*push_helper_ptr, Cancel()).Times(0);
   push_delegate.OnPush(std::move(push_helper));
   base::RunLoop().RunUntilIdle();
 
   // Receive another server push for the same url.
   std::unique_ptr<MockServerPushHelper> push_helper2 =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr2 = push_helper2.get();
   EXPECT_CALL(*push_helper_ptr2, Cancel()).Times(0);
   push_delegate.OnPush(std::move(push_helper2));
   base::RunLoop().RunUntilIdle();
 
   // Verify no network transaction is created.
   EXPECT_EQ(0, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(0, mock_cache.disk_cache()->open_count());
   // Verify no cache entry is created for server push lookup.
   EXPECT_EQ(0, mock_cache.disk_cache()->create_count());
 }
 
 TEST(HttpCacheLookupManagerTest, ServerPushHitCache) {
-  MockHttpCache mock_cache;
+  MockHttpCache mock_cache(false);
   HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
                                        NetLogWithSource());
   GURL request_url("http://www.example.com/pushed.jpg");
 
   // Populate the cache entry so that the cache lookup for server push hits.
   PopulateCacheEntry(mock_cache.http_cache(), request_url);
   EXPECT_EQ(1, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(0, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->create_count());
 
@@ skipping 17 matching lines @@
   EXPECT_EQ(1, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->create_count());
 
   RemoveMockTransaction(mock_trans.get());
 }
 
 // Test when a server push is received while the HttpCacheLookupManager has a
 // pending lookup transaction for the same URL, the new server push will not
 // send a new lookup transaction and should not be canceled.
 TEST(HttpCacheLookupManagerTest, ServerPushPendingLookup) {
-  MockHttpCache mock_cache;
+  MockHttpCache mock_cache(false);
   HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
                                        NetLogWithSource());
   GURL request_url("http://www.example.com/pushed.jpg");
 
   // Populate the cache entry so that the cache lookup for server push hits.
   PopulateCacheEntry(mock_cache.http_cache(), request_url);
   EXPECT_EQ(1, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(0, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->create_count());
 
@@ skipping 24 matching lines @@
   // Make sure no new net layer transaction is created.
   EXPECT_EQ(1, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->create_count());
 
   RemoveMockTransaction(mock_trans.get());
 }
 
 // Test the server push lookup is based on the full url.
 TEST(HttpCacheLookupManagerTest, ServerPushLookupOnUrl) {
-  MockHttpCache mock_cache;
+  MockHttpCache mock_cache(false);
   HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
                                        NetLogWithSource());
   GURL request_url("http://www.example.com/pushed.jpg?u=0");
   GURL request_url2("http://www.example.com/pushed.jpg?u=1");
 
   // Populate the cache entry so that the cache lookup for server push hits.
   PopulateCacheEntry(mock_cache.http_cache(), request_url);
   EXPECT_EQ(1, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(0, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->create_count());
@@ skipping 48 matching lines @@
 
   base::RunLoop().RunUntilIdle();
   // Make sure no new net layer transaction is created.
   EXPECT_EQ(1, mock_cache.network_layer()->transaction_count());
   EXPECT_EQ(2, mock_cache.disk_cache()->open_count());
   EXPECT_EQ(1, mock_cache.disk_cache()->create_count());
   RemoveMockTransaction(mock_trans3.get());
 }
 
 }  // namespace net