Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 376 matching lines @@
                                    const MockTransaction& trans_info,
                                    const MockHttpRequest& request,
                                    std::string* response_headers) {
   TestCompletionCallback callback;
 
   // write to the cache
 
   scoped_ptr<net::HttpTransaction> trans(cache->CreateTransaction());
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
 
   if (response_headers)
     response->headers->GetNormalizedHeaders(response_headers);
 
@@ skipping 265 matching lines @@
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans(
       cache.http_cache()->CreateTransaction());
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   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 136 matching lines @@
   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(cache.http_cache()->CreateTransaction()));
 
     Context* c = context_list[i];
-    int rv = c->trans->Start(&request, &c->callback);
+    int rv = c->trans->Start(NULL, &request, &c->callback);
     if (rv != net::ERR_IO_PENDING)
       c->result = rv;
   }
 
   // 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());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 33 matching lines @@
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(
         new Context(cache.http_cache()->CreateTransaction()));
 
     Context* c = context_list[i];
     MockHttpRequest* this_request = &request;
     if (i == 1 || i == 2)
       this_request = &reader_request;
 
-    int rv = c->trans->Start(this_request, &c->callback);
+    int rv = c->trans->Start(NULL, this_request, &c->callback);
     if (rv != net::ERR_IO_PENDING)
       c->result = rv;
   }
 
   // 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());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 51 matching lines @@
   AddMockTransaction(&kFastNoStoreGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(
         new Context(cache.http_cache()->CreateTransaction()));
 
     Context* c = context_list[i];
-    int rv = c->trans->Start(&request, &c->callback);
+    int rv = c->trans->Start(NULL, &request, &c->callback);
     if (rv != net::ERR_IO_PENDING)
       c->result = rv;
   }
 
   // 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());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 22 matching lines @@
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 2;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(
         new Context(cache.http_cache()->CreateTransaction()));
 
     Context* c = context_list[i];
-    int rv = c->trans->Start(&request, &c->callback);
+    int rv = c->trans->Start(NULL, &request, &c->callback);
     if (rv != net::ERR_IO_PENDING)
       c->result = rv;
   }
 
   // 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());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 31 matching lines @@
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans(
       cache.http_cache()->CreateTransaction());
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   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 494 matching lines @@
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans(
       cache.http_cache()->CreateTransaction());
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   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 383 matching lines @@
                             TEST_MODE_SYNC_CACHE_READ);
 
   MockHttpRequest r1(transaction),
                   r2(transaction),
                   r3(transaction);
 
   TestTransactionConsumer c1(cache.http_cache()),
                           c2(cache.http_cache()),
                           c3(cache.http_cache());
 
-  c1.Start(&r1);
+  c1.Start(NULL, &r1);
 
   r2.load_flags |= net::LOAD_ONLY_FROM_CACHE;
-  c2.Start(&r2);
+  c2.Start(NULL, &r2);
 
   r3.load_flags |= net::LOAD_ONLY_FROM_CACHE;
-  c3.Start(&r3);
+  c3.Start(NULL, &r3);
 
   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 26 matching lines @@
 
   MockHttpRequest request(kTestTransaction);
   TestCompletionCallback callback;
 
   // write to the cache
   {
     scoped_ptr<net::HttpTransaction> trans(
         cache.http_cache()->CreateTransaction());
     ASSERT_TRUE(trans.get());
 
-    int rv = trans->Start(&request, &callback);
+    int rv = trans->Start(NULL, &request, &callback);
     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(
         cache.http_cache()->CreateTransaction());
     ASSERT_TRUE(trans.get());
 
-    int rv = trans->Start(&request, &callback);
+    int rv = trans->Start(NULL, &request, &callback);
     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 106 matching lines @@
   // Test that it was not cached.
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans(
       cache.http_cache()->CreateTransaction());
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   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;
 
   net::HttpTransaction* trans = cache->http_cache()->CreateTransaction();
@@ skipping 13 matching lines @@
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }