Server push cancellation: add NetLogs to track cache lookup transaction

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 66 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;
-  HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
-                                       NetLogWithSource());
+  NetLog net_log;
+  HttpCacheLookupManager push_delegate(mock_cache.http_cache(), &net_log);
   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));
+  push_delegate.OnPush(std::move(push_helper), NetLogWithSource());
   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;
-  HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
-                                       NetLogWithSource());
+  NetLog net_log;
+  HttpCacheLookupManager push_delegate(mock_cache.http_cache(), &net_log);
   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));
+  push_delegate.OnPush(std::move(push_helper), NetLogWithSource());
   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));
+  push_delegate.OnPush(std::move(push_helper2), NetLogWithSource());
   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;
-  HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
-                                       NetLogWithSource());
+  NetLog net_log;
+  HttpCacheLookupManager push_delegate(mock_cache.http_cache(), &net_log);
   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());
 
   // Add another mock transaction since the OnPush will create a new cache
   // transaction.
   std::unique_ptr<MockTransaction> mock_trans =
       CreateMockTransaction(request_url);
   AddMockTransaction(mock_trans.get());
 
   std::unique_ptr<MockServerPushHelper> push_helper =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr = push_helper.get();
 
   // Receive a server push and should cancel the push.
   EXPECT_CALL(*push_helper_ptr, Cancel()).Times(1);
-  push_delegate.OnPush(std::move(push_helper));
+  push_delegate.OnPush(std::move(push_helper), NetLogWithSource());
   base::RunLoop().RunUntilIdle();
 
   // 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 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;
-  HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
-                                       NetLogWithSource());
+  NetLog net_log;
+  HttpCacheLookupManager push_delegate(mock_cache.http_cache(), &net_log);
   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());
 
   // Add another mock transaction since the OnPush will create a new cache
   // transaction.
   std::unique_ptr<MockTransaction> mock_trans =
       CreateMockTransaction(request_url);
   AddMockTransaction(mock_trans.get());
 
   std::unique_ptr<MockServerPushHelper> push_helper =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr = push_helper.get();
 
   // Receive a server push and should cancel the push eventually.
   EXPECT_CALL(*push_helper_ptr, Cancel()).Times(1);
-  push_delegate.OnPush(std::move(push_helper));
+  push_delegate.OnPush(std::move(push_helper), NetLogWithSource());
 
   std::unique_ptr<MockServerPushHelper> push_helper2 =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr2 = push_helper2.get();
 
   // Receive another server push and should not cancel the push.
   EXPECT_CALL(*push_helper_ptr2, Cancel()).Times(0);
-  push_delegate.OnPush(std::move(push_helper2));
+  push_delegate.OnPush(std::move(push_helper2), NetLogWithSource());
 
   base::RunLoop().RunUntilIdle();
 
   // 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;
-  HttpCacheLookupManager push_delegate(mock_cache.http_cache(),
-                                       NetLogWithSource());
+  NetLog net_log;

[eroman, 2017/02/07 22:33:42]

If you change some of these to use TestNetLog, the tests can be updated to
verify that the NetLog was written to.

For the rest where no validation is done, the parameter passed to
HttpCacheLookupManager can be |nullptr|.

[Zhongyi Shi, 2017/02/08 00:40:53]

Will do in a follow-up CL since I realized that the net log which will be
written to id down in the HttpCacheLookupManager::LookupTransactions.

+  HttpCacheLookupManager push_delegate(mock_cache.http_cache(), &net_log);
   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());
 
   // Add another mock transaction since the OnPush will create a new cache
   // transaction.
   std::unique_ptr<MockTransaction> mock_trans =
       CreateMockTransaction(request_url);
   AddMockTransaction(mock_trans.get());
 
   std::unique_ptr<MockServerPushHelper> push_helper =
       base::MakeUnique<MockServerPushHelper>(request_url);
   MockServerPushHelper* push_helper_ptr = push_helper.get();
 
   // Receive a server push and should cancel the push eventually.
   EXPECT_CALL(*push_helper_ptr, Cancel()).Times(1);
-  push_delegate.OnPush(std::move(push_helper));
+  push_delegate.OnPush(std::move(push_helper), NetLogWithSource());
   // Run until the lookup transaction finishes for the first server push.
   base::RunLoop().RunUntilIdle();
   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());
 
   AddMockTransaction(mock_trans.get());
   // Receive the second server push with same url after the first lookup
   // finishes, and should cancel the push.
   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(1);
-  push_delegate.OnPush(std::move(push_helper2));
+  push_delegate.OnPush(std::move(push_helper2), NetLogWithSource());
   // Run until the lookup transaction finishes for the second server push.
   base::RunLoop().RunUntilIdle();
   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_trans.get());
 
   std::unique_ptr<MockTransaction> mock_trans3 =
       CreateMockTransaction(request_url2);
   AddMockTransaction(mock_trans3.get());
   // Receive the third server push with a different url after lookup for a
   // similar server push has been completed, should not cancel the push.
   std::unique_ptr<MockServerPushHelper> push_helper3 =
       base::MakeUnique<MockServerPushHelper>(request_url2);
   MockServerPushHelper* push_helper_ptr3 = push_helper3.get();
 
   EXPECT_CALL(*push_helper_ptr3, Cancel()).Times(0);
-  push_delegate.OnPush(std::move(push_helper3));
+  push_delegate.OnPush(std::move(push_helper3), NetLogWithSource());
 
   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