Cleanup: Remove the implicit constructor for BoundNetLog that allowed passing...

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2010 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 "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 599 matching lines @@
     *response_info = *response;
 
   ReadAndVerifyTransaction(trans.get(), trans_info);
 }
 
 void RunTransactionTestWithRequest(net::HttpCache* cache,
                                    const MockTransaction& trans_info,
                                    const MockHttpRequest& request,
                                    net::HttpResponseInfo* response_info) {
   RunTransactionTestWithRequestAndLog(cache, trans_info, request,
-                                      response_info, NULL);
+                                      response_info, net::BoundNetLog());
 }
 
 void RunTransactionTestWithLog(net::HttpCache* cache,
                                const MockTransaction& trans_info,
                                const net::BoundNetLog& log) {
   RunTransactionTestWithRequestAndLog(
       cache, trans_info, MockHttpRequest(trans_info), NULL, log);
 }
 
 void RunTransactionTest(net::HttpCache* cache,
                         const MockTransaction& trans_info) {
-  RunTransactionTestWithLog(cache, trans_info, NULL);
+  RunTransactionTestWithLog(cache, trans_info, net::BoundNetLog());
 }
 
 void RunTransactionTestWithResponseInfo(net::HttpCache* cache,
                                         const MockTransaction& trans_info,
                                         net::HttpResponseInfo* response) {
   RunTransactionTestWithRequest(
       cache, trans_info, MockHttpRequest(trans_info), response);
 }
 
 void RunTransactionTestWithResponse(net::HttpCache* cache,
@@ skipping 308 matching lines @@
 // request to fail.
 TEST(HttpCache, SimpleGETWithDiskFailures2) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   scoped_ptr<Context> c(new Context());
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   rv = c->callback.WaitForResult();
 
   // Start failing request now.
   cache.disk_cache()->set_soft_failures(true);
 
   // We have to open the entry again to propagate the failure flag.
   disk_cache::Entry* en;
   ASSERT_EQ(net::OK, cache.disk_cache()->OpenEntry(kSimpleGET_Transaction.url,
                                                    &en, NULL));
@@ skipping 74 matching lines @@
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   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());
 }
@@ skipping 194 matching lines @@
   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];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
-    c->result = c->trans->Start(&request, &c->callback, NULL);
+    c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   MessageLoop::current()->RunAllPending();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 36 matching lines @@
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
     MockHttpRequest* this_request = &request;
     if (i == 1 || i == 2)
       this_request = &reader_request;
 
-    c->result = c->trans->Start(this_request, &c->callback, NULL);
+    c->result = c->trans->Start(this_request, &c->callback, net::BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   MessageLoop::current()->RunAllPending();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 60 matching lines @@
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
     MockHttpRequest* this_request = &request;
     if (i == 3)
       this_request = &writer_request;
 
-    c->result = c->trans->Start(this_request, &c->callback, NULL);
+    c->result = c->trans->Start(this_request, &c->callback, net::BoundNetLog());
   }
 
   // The first request should be a writer at this point, and the two subsequent
   // requests should be pending. The last request doomed the first entry.
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   // Cancel the first queued transaction.
   delete context_list[1];
   context_list.get()[1] = NULL;
@@ skipping 22 matching lines @@
   std::vector<Context*> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(new Context());
     Context* c = context_list[i];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
-    c->result = c->trans->Start(&request, &c->callback, NULL);
+    c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   MessageLoop::current()->RunAllPending();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 25 matching lines @@
   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];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
-    c->result = c->trans->Start(&request, &c->callback, NULL);
+    c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   MessageLoop::current()->RunAllPending();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 38 matching lines @@
   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];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
-    c->result = c->trans->Start(&request, &c->callback, NULL);
+    c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   }
 
   // The first request should be creating the disk cache entry and the others
   // should be pending.
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Cancel a request from the pending queue.
@@ skipping 35 matching lines @@
   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];
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
 
-    c->result = c->trans->Start(&request, &c->callback, NULL);
+    c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   }
 
   // The first request should be deleting the disk cache entry and the others
   // should be pending.
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 
   // Complete the transactions.
@@ skipping 19 matching lines @@
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
-  rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
   scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(256);
   rv = trans->Read(buf, 256, &callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Test that destroying the transaction while it is reading from the cache
   // works properly.
@@ skipping 610 matching lines @@
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   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());
 }
@@ skipping 723 matching lines @@
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   MockHttpRequest request(kRangeGET_TransactionOK);
 
   Context* c = new Context();
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = 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());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
@@ skipping 19 matching lines @@
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
 
   Context* c = new Context();
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(5);
@@ skipping 24 matching lines @@
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
 
   Context* c = new Context();
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   rv = c->callback.WaitForResult();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(5);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(5, c->callback.GetResult(rv));
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Destroy the transaction before completing the read.
   delete c;
 
   // We have the read and the delete (OnProcessPendingQueue) waiting on the
   // message loop. This means that a new transaction will just reuse the same
   // active entry (no open or create).
 
   c = new Context();
   rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   MockDiskEntry::IgnoreCallbacks(true);
   MessageLoop::current()->RunAllPending();
   MockDiskEntry::IgnoreCallbacks(false);
 
   // The new transaction is waiting for the query range callback.
   delete c;
 
   // And we should not crash when the callback is delivered.
@@ skipping 318 matching lines @@
 TEST(HttpCache, DoomOnDestruction) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::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;
@@ skipping 10 matching lines @@
 TEST(HttpCache, DoomOnDestruction2) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = 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());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
@@ skipping 23 matching lines @@
       "Content-Length: 22\n"
       "Accept-Ranges: none\n"
       "Etag: foopy\n";
   AddMockTransaction(&transaction);
   MockHttpRequest request(transaction);
 
   Context* c = new Context();
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = 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());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
@@ skipping 23 matching lines @@
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Etag: foopy\n";
   AddMockTransaction(&transaction);
   MockHttpRequest request(transaction);
 
   scoped_ptr<Context> c(new Context());
   int rv = cache.http_cache()->CreateTransaction(&c->trans);
   EXPECT_EQ(net::OK, rv);
 
-  rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = 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());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
@@ skipping 185 matching lines @@
   EXPECT_EQ(len, entry->WriteData(1, 0, buf, len, NULL, true));
 
   // Now make a regular request.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
 
   MockHttpRequest request(transaction);
   Context* c = new Context();
   EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(&c->trans));
 
-  int rv = c->trans->Start(&request, &c->callback, NULL);
+  int rv = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // Read 20 bytes from the cache, and 10 from the net.
   rv = c->trans->Read(buf, len, &c->callback);
   EXPECT_EQ(len, c->callback.GetResult(rv));
   rv = c->trans->Read(buf, 10, &c->callback);
   EXPECT_EQ(10, c->callback.GetResult(rv));
 
   // At this point, we are already reading so canceling the request should leave
   // a truncated one.
@@ skipping 70 matching lines @@
                             TEST_MODE_SYNC_CACHE_WRITE);
 
   MockHttpRequest r1(transaction),
                   r2(transaction),
                   r3(transaction);
 
   TestTransactionConsumer c1(cache.http_cache()),
                           c2(cache.http_cache()),
                           c3(cache.http_cache());
 
-  c1.Start(&r1, NULL);
+  c1.Start(&r1, net::BoundNetLog());
 
   r2.load_flags |= net::LOAD_ONLY_FROM_CACHE;
-  c2.Start(&r2, NULL);
+  c2.Start(&r2, net::BoundNetLog());
 
   r3.load_flags |= net::LOAD_ONLY_FROM_CACHE;
-  c3.Start(&r3, NULL);
+  c3.Start(&r3, net::BoundNetLog());
 
   MessageLoop::current()->Run();
 
   EXPECT_TRUE(c1.is_done());
   EXPECT_TRUE(c2.is_done());
   EXPECT_TRUE(c3.is_done());
 
   EXPECT_EQ(net::OK, c1.error());
   EXPECT_EQ(net::OK, c2.error());
   EXPECT_EQ(net::OK, c3.error());
@@ skipping 27 matching lines @@
   MockHttpRequest request(kTestTransaction);
   TestCompletionCallback callback;
 
   // write to the cache
   {
     scoped_ptr<net::HttpTransaction> trans;
     int rv = cache.http_cache()->CreateTransaction(&trans);
     EXPECT_EQ(net::OK, rv);
     ASSERT_TRUE(trans.get());
 
-    rv = trans->Start(&request, &callback, NULL);
+    rv = trans->Start(&request, &callback, net::BoundNetLog());
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_EQ(net::OK, rv);
 
     const net::HttpResponseInfo* info = trans->GetResponseInfo();
     ASSERT_TRUE(info);
 
     EXPECT_EQ(info->headers->response_code(), 301);
 
     std::string location;
     info->headers->EnumerateHeader(NULL, "Location", &location);
     EXPECT_EQ(location, "http://www.bar.com/");
 
     // Destroy transaction when going out of scope. We have not actually
     // read the response body -- want to test that it is still getting cached.
   }
   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
   {
     scoped_ptr<net::HttpTransaction> trans;
     int rv = cache.http_cache()->CreateTransaction(&trans);
     EXPECT_EQ(net::OK, rv);
     ASSERT_TRUE(trans.get());
 
-    rv = trans->Start(&request, &callback, NULL);
+    rv = trans->Start(&request, &callback, net::BoundNetLog());
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_EQ(net::OK, rv);
 
     const net::HttpResponseInfo* info = trans->GetResponseInfo();
     ASSERT_TRUE(info);
 
     EXPECT_EQ(info->headers->response_code(), 301);
 
     std::string location;
@@ skipping 107 matching lines @@
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
   MockHttpCache* cache = new MockHttpCache;
 
   scoped_ptr<net::HttpTransaction> trans;
@@ skipping 219 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   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());
 }