Adding histograms showing fraction of page load times

net/http/http_cache_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/cache_type.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
+#include "net/http/http_transaction_delegate.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/http/http_util.h"
 #include "net/http/mock_http_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
 class DeleteCacheCompletionCallback : public net::TestCompletionCallbackBase {
@@ skipping 15 matching lines @@
 
   MockHttpCache* cache_;
   net::CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCacheCompletionCallback);
 };
 
 //-----------------------------------------------------------------------------
 // helpers
 
+class TestHttpTransactionDelegate : public net::HttpTransactionDelegate {
+ public:
+  TestHttpTransactionDelegate(int num_actions_to_observe)
+      : num_remaining_actions_to_observe_(num_actions_to_observe),
+        action_in_progress_(false){

[rvargas (doing something else), 2012/07/26 02:13:43]

nit: missing space before {

[tburkard, 2012/07/26 02:50:54]

Done.

+  }
+  virtual ~TestHttpTransactionDelegate() {
+    EXPECT_EQ(num_remaining_actions_to_observe_, 0);
+    EXPECT_EQ(action_in_progress_, false);
+  }
+  virtual void OnCacheActionStart() {
+    EXPECT_EQ(action_in_progress_, false);
+    EXPECT_GT(num_remaining_actions_to_observe_, 0);
+    num_remaining_actions_to_observe_--;
+    action_in_progress_ = true;
+  }
+  virtual void OnCacheActionFinish() {
+    EXPECT_EQ(action_in_progress_, true);
+    action_in_progress_ = false;
+  }
+
+ private:
+  int num_remaining_actions_to_observe_;
+  bool action_in_progress_;
+};
+
 void ReadAndVerifyTransaction(net::HttpTransaction* trans,
                               const MockTransaction& trans_info) {
   std::string content;
   int rv = ReadTransaction(trans, &content);
 
   EXPECT_EQ(net::OK, rv);
   std::string expected(trans_info.data);
   EXPECT_EQ(expected, content);
 }
 
-void RunTransactionTestWithRequestAndLog(net::HttpCache* cache,
-                                         const MockTransaction& trans_info,
-                                         const MockHttpRequest& request,
-                                         net::HttpResponseInfo* response_info,
-                                         const net::BoundNetLog& net_log) {
+static const int kNoDelegateTransactionCheck = -1;
+
+void RunTransactionTestWithRequestAndLogAndNumDelegateTransactions(

[rvargas (doing something else), 2012/07/26 02:13:43]

nit: ...LogAndDelegate(

[tburkard, 2012/07/26 02:50:54]

I'd rather keep it so to disambiguate "RequestLog" from "Request, Log"

On 2012/07/26 02:13:43, rvargas wrote:

[rvargas (doing something else), 2012/07/26 18:47:33]

I don't understand what you mean.

RunTransactionTestWithRequestAndLogAndDelegate
RunTransactionTestWithDelegate

I don't like AndNumDelegateTransactions because there is no such thing as
"number of delegate transactions"... the test adds a delegate... saying just
"Delegate" is specific enough.

[tburkard, 2012/07/26 19:12:49]

Done.

+    net::HttpCache* cache,
+    const MockTransaction& trans_info,
+    const MockHttpRequest& request,
+    net::HttpResponseInfo* response_info,
+    const net::BoundNetLog& net_log,
+    int num_delegate_transactions) {

[rvargas (doing something else), 2012/07/26 02:13:43]

num_actions ? if anything, they are not transactions.

[tburkard, 2012/07/26 02:50:54]

Done.

   net::TestCompletionCallback callback;
 
   // write to the cache
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache->CreateTransaction(&trans);
+  scoped_ptr<TestHttpTransactionDelegate> delegate;
+  if (num_delegate_transactions != kNoDelegateTransactionCheck) {
+    delegate.reset(new TestHttpTransactionDelegate(num_delegate_transactions));
+  }
+  int rv = cache->CreateTransaction(&trans, delegate.get());
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net_log);
   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_info)
     *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, net::BoundNetLog());
+  RunTransactionTestWithRequestAndLogAndNumDelegateTransactions(
+      cache, trans_info, request, response_info, net::BoundNetLog(),
+      kNoDelegateTransactionCheck);
 }
 
 void RunTransactionTestWithLog(net::HttpCache* cache,
                                const MockTransaction& trans_info,
                                const net::BoundNetLog& log) {
-  RunTransactionTestWithRequestAndLog(
-      cache, trans_info, MockHttpRequest(trans_info), NULL, log);
+  RunTransactionTestWithRequestAndLogAndNumDelegateTransactions(
+      cache, trans_info, MockHttpRequest(trans_info), NULL, log,
+      kNoDelegateTransactionCheck);
+}
+
+void RunTransactionTestWithNumDelegateTransactions(
+    net::HttpCache* cache,
+    const MockTransaction& trans_info,
+    int num_delegate_transactions) {
+  RunTransactionTestWithRequestAndLogAndNumDelegateTransactions(
+      cache, trans_info, MockHttpRequest(trans_info), NULL, net::BoundNetLog(),
+      num_delegate_transactions);
 }
 
 void RunTransactionTest(net::HttpCache* cache,
                         const MockTransaction& trans_info) {
   RunTransactionTestWithLog(cache, trans_info, net::BoundNetLog());
 }
 
 void RunTransactionTestWithResponseInfo(net::HttpCache* cache,
                                         const MockTransaction& trans_info,
                                         net::HttpResponseInfo* response) {
@@ skipping 266 matching lines @@
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
 // Tests.
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(&trans);
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 }
 
 TEST(HttpCache, GetBackend) {
   MockHttpCache cache(net::HttpCache::DefaultBackend::InMemory(0));
 
   disk_cache::Backend* backend;
   net::TestCompletionCallback cb;
   // This will lazily initialize the backend.
@@ skipping 83 matching lines @@
 }
 
 // Tests that disk failures after the transaction has started don't cause the
 // 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);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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.
@@ skipping 24 matching lines @@
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   cache.disk_cache()->set_soft_failures(true);
 
   // Now fail to read from the cache.
   scoped_ptr<Context> c(new Context());
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // Now verify that the entry was removed from the cache.
   cache.disk_cache()->set_soft_failures(false);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
@@ skipping 79 matching lines @@
   MockHttpCache cache;
 
   // force this transaction to read from the cache
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   net::TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(&trans);
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans.reset();
 
@@ skipping 205 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());
     Context* c = context_list[i];
 
-    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
     EXPECT_EQ(net::LOAD_STATE_IDLE, c->trans->GetLoadState());
 
     c->result = c->trans->Start(
         &request, c->callback.callback(), net::BoundNetLog());
   }
 
   // All requests are waiting for the active entry.
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
@@ skipping 47 matching lines @@
   MockHttpRequest reader_request(kSimpleGET_Transaction);
   reader_request.load_flags = net::LOAD_ONLY_FROM_CACHE;
 
   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);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     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.callback(), net::BoundNetLog());
   }
 
@@ skipping 64 matching lines @@
   MockHttpRequest writer_request(kSimpleGET_Transaction);
   writer_request.load_flags = net::LOAD_BYPASS_CACHE;
 
   ScopedVector<Context> context_list;
   const int kNumTransactions = 4;
 
   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);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     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.callback(), net::BoundNetLog());
   }
 
@@ skipping 27 matching lines @@
   FastTransactionServer request_handler;
   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());
     Context* c = context_list[i];
 
-    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
 
     c->result = c->trans->Start(
         &request, c->callback.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
@@ skipping 26 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());
     Context* c = context_list[i];
 
-    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
 
     c->result = c->trans->Start(
         &request, c->callback.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
@@ skipping 39 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());
     Context* c = context_list[i];
 
-    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
 
     c->result = c->trans->Start(
         &request, c->callback.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());
@@ skipping 30 matching lines @@
 }
 
 // Tests that we can cancel a single request to open a disk cache entry.
 TEST(HttpCache, SimpleGET_CancelCreate) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
 
-  c->result = cache.http_cache()->CreateTransaction(&c->trans);
+  c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, c->result);
 
   c->result = c->trans->Start(
       &request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::ERR_IO_PENDING, c->result);
 
   // Release the reference that the mock disk cache keeps for this entry, so
   // that we test that the http cache handles the cancellation correctly.
   cache.disk_cache()->ReleaseAll();
   delete c;
 
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete/create entries even if multiple requests are queued.
 TEST(HttpCache, SimpleGET_ManyWriters_BypassCache) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
   request.load_flags = net::LOAD_BYPASS_CACHE;
 
   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);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
 
     c->result = c->trans->Start(
         &request, c->callback.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());
@@ skipping 21 matching lines @@
 TEST(HttpCache, SimpleGET_AbandonedCacheRead) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   net::TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(&trans);
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
   rv = trans->Start(&request, callback.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.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
@@ skipping 14 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());
     Context* c = context_list[i];
 
-    c->result = cache->http_cache()->CreateTransaction(&c->trans);
+    c->result = cache->http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
 
     c->result = c->trans->Start(
         &request, c->callback.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());
@@ skipping 18 matching lines @@
   MockHttpRequest request1(kTypicalGET_Transaction);
   MockHttpRequest request2(kETagGET_Transaction);
 
   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);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
   }
 
   context_list[0]->result = context_list[0]->trans->Start(
       &request0, context_list[0]->callback.callback(), net::BoundNetLog());
   context_list[1]->result = context_list[1]->trans->Start(
       &request1, context_list[1]->callback.callback(), net::BoundNetLog());
   context_list[2]->result = context_list[2]->trans->Start(
       &request2, context_list[2]->callback.callback(), net::BoundNetLog());
 
@@ skipping 25 matching lines @@
   MockHttpRequest request1(kTypicalGET_Transaction);
   MockHttpRequest request2(kETagGET_Transaction);
 
   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);
+    c->result = cache.http_cache()->CreateTransaction(&c->trans, NULL);
     EXPECT_EQ(net::OK, c->result);
   }
 
   context_list[0]->result = context_list[0]->trans->Start(
       &request0, context_list[0]->callback.callback(), net::BoundNetLog());
   context_list[1]->result = context_list[1]->trans->Start(
       &request1, context_list[1]->callback.callback(), net::BoundNetLog());
   context_list[2]->result = context_list[2]->trans->Start(
       &request2, context_list[2]->callback.callback(), net::BoundNetLog());
 
@@ skipping 25 matching lines @@
 }
 
 // Tests that we can delete the cache while creating the backend.
 TEST(HttpCache, DeleteCacheWaitingForBackend) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
   scoped_ptr<MockHttpCache> cache(new MockHttpCache(factory));
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   scoped_ptr<Context> c(new Context());
-  c->result = cache->http_cache()->CreateTransaction(&c->trans);
+  c->result = cache->http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, c->result);
 
   c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
 
   // Just to make sure that everything is still pending.
   MessageLoop::current()->RunAllPending();
 
   // The request should be creating the disk cache.
   EXPECT_FALSE(c->callback.have_result());
 
@@ skipping 17 matching lines @@
 
   DeleteCacheCompletionCallback cb(cache);
   disk_cache::Backend* backend;
   int rv = cache->http_cache()->GetBackend(&backend, cb.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Now let's queue a regular transaction
   MockHttpRequest request(kSimpleGET_Transaction);
 
   scoped_ptr<Context> c(new Context());
-  c->result = cache->http_cache()->CreateTransaction(&c->trans);
+  c->result = cache->http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, c->result);
 
   c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
 
   // And another direct backend request.
   net::TestCompletionCallback cb2;
   rv = cache->http_cache()->GetBackend(&backend, cb2.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Just to make sure that everything is still pending.
@@ skipping 665 matching lines @@
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   net::TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(&trans);
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
   ASSERT_EQ(net::ERR_CACHE_MISS, callback.GetResult(rv));
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 1040 matching lines @@
 }
 
 // Tests that we don't delete a sparse entry when we cancel a request.
 TEST(HttpCache, RangeGET_Cancel) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   MockHttpRequest request(kRangeGET_TransactionOK);
 
   Context* c = new Context();
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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());
 
@@ skipping 18 matching lines @@
 // cancelling the previous one.
 TEST(HttpCache, RangeGET_Cancel2) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.load_flags |= net::LOAD_VALIDATE_CACHE;
 
   Context* c = new Context();
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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());
 
@@ skipping 24 matching lines @@
 // a row, making sure that the second is waiting for the entry to be ready.
 TEST(HttpCache, RangeGET_Cancel3) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.load_flags |= net::LOAD_VALIDATE_CACHE;
 
   Context* c = new Context();
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
   rv = c->trans->Read(buf, buf->size(), c->callback.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);
+  rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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.
@@ skipping 260 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Force this transaction to read from the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   net::TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(&trans);
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans.reset();
 
@@ skipping 57 matching lines @@
 }
 
 // Tests that we delete an entry when the request is cancelled before starting
 // to read from the network.
 TEST(HttpCache, DoomOnDestruction) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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;
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete an entry when the request is cancelled if the response
 // does not have content-length and strong validators.
 TEST(HttpCache, DoomOnDestruction2) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   Context* c = new Context();
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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());
 
@@ skipping 22 matching lines @@
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "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);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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());
 
@@ skipping 22 matching lines @@
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "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);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.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());
 
@@ skipping 39 matching lines @@
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "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);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // Read everything.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(22));
   rv = c->trans->Read(buf, buf->size(), c->callback.callback());
   EXPECT_EQ(buf->size(), c->callback.GetResult(rv));
 
@@ skipping 123 matching lines @@
   std::string response_headers(transaction.response_headers);
   response_headers += ("Cache-Control: no-store\n");
   transaction.response_headers = response_headers.c_str();
   transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49 "
                      "rg: 50-59 rg: 60-69 rg: 70-79 ";
   AddMockTransaction(&transaction);
 
   MockHttpRequest request(transaction);
   Context* c = new Context();
 
-  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   // Queue another request to this transaction. We have to start this request
   // before the first one gets the response from the server and dooms the entry,
   // otherwise it will just create a new entry without being queued to the first
   // request.
   Context* pending = new Context();
-  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(&pending->trans));
+  EXPECT_EQ(net::OK,
+            cache.http_cache()->CreateTransaction(&pending->trans, NULL));
 
   rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::ERR_IO_PENDING,
             pending->trans->Start(&request, pending->callback.callback(),
                                   net::BoundNetLog()));
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
   rv = c->trans->Read(buf, buf->size(), c->callback.callback());
@@ skipping 63 matching lines @@
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
   transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49 "
                      "rg: 50-59 rg: 60-69 rg: 70-79 ";
 
   scoped_ptr<Context> c(new Context);
-  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(&c->trans));
+  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(&c->trans, NULL));
 
   MockHttpRequest request(transaction);
   int rv = c->trans->Start(
       &request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // We should have checked with the server before finishing Start().
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
@@ skipping 51 matching lines @@
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // 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));
+  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(&c->trans, NULL));
 
   int rv = c->trans->Start(
       &request, c->callback.callback(), net::BoundNetLog());
   EXPECT_EQ(net::OK, c->callback.GetResult(rv));
 
   // Read 20 bytes from the cache, and 10 from the net.
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(100));
   rv = c->trans->Read(buf, 20, c->callback.callback());
   EXPECT_EQ(20, c->callback.GetResult(rv));
   rv = c->trans->Read(buf, 10, c->callback.callback());
@@ skipping 107 matching lines @@
   ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
   kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
   kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
 
   MockHttpRequest request(kTestTransaction);
   net::TestCompletionCallback callback;
 
   // write to the cache
   {
     scoped_ptr<net::HttpTransaction> trans;
-    int rv = cache.http_cache()->CreateTransaction(&trans);
+    int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
     EXPECT_EQ(net::OK, rv);
     ASSERT_TRUE(trans.get());
 
     rv = trans->Start(&request, callback.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);
+    int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
     EXPECT_EQ(net::OK, rv);
     ASSERT_TRUE(trans.get());
 
     rv = trans->Start(&request, callback.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);
@@ skipping 104 matching lines @@
   // write to the cache
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Test that it was not cached.
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   net::TestCompletionCallback callback;
 
   scoped_ptr<net::HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(&trans);
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.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;
-  int rv = cache->http_cache()->CreateTransaction(&trans);
+  int rv = cache->http_cache()->CreateTransaction(&trans, NULL);
   EXPECT_EQ(net::OK, rv);
 
   delete cache;
   trans.reset();
 }
 
 // Test that the disabled mode works.
 TEST(HttpCache, CacheDisabledMode) {
   MockHttpCache cache;
 
@@ skipping 217 matching lines @@
 }
 
 // Tests that we don't mark entries as truncated when a filter detects the end
 // of the stream.
 TEST(HttpCache, FilterCompletion) {
   MockHttpCache cache;
   net::TestCompletionCallback callback;
 
   {
     scoped_ptr<net::HttpTransaction> trans;
-    int rv = cache.http_cache()->CreateTransaction(&trans);
+    int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
     EXPECT_EQ(net::OK, rv);
 
     MockHttpRequest request(kSimpleGET_Transaction);
     rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
     rv = trans->Read(buf, 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
 
@@ skipping 13 matching lines @@
 }
 
 // Tests that we stop cachining when told.
 TEST(HttpCache, StopCachingDeletesEntry) {
   MockHttpCache cache;
   net::TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
     scoped_ptr<net::HttpTransaction> trans;
-    int rv = cache.http_cache()->CreateTransaction(&trans);
+    int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
     EXPECT_EQ(net::OK, rv);
 
     rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
     rv = trans->Read(buf, 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
     trans->StopCaching();
@@ skipping 17 matching lines @@
 }
 
 // Tests that when we are told to stop caching we don't throw away valid data.
 TEST(HttpCache, StopCachingSavesEntry) {
   MockHttpCache cache;
   net::TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
     scoped_ptr<net::HttpTransaction> trans;
-    int rv = cache.http_cache()->CreateTransaction(&trans);
+    int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
     EXPECT_EQ(net::OK, rv);
 
     // Force a response that can be resumed.
     MockTransaction mock_transaction(kSimpleGET_Transaction);
     AddMockTransaction(&mock_transaction);
     mock_transaction.response_headers = "Cache-Control: max-age=10000\n"
                                         "Content-Length: 42\n"
                                         "Etag: \"foo\"\n";
 
     rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
@@ skipping 36 matching lines @@
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   {
     // Now make a regular request.
     scoped_ptr<net::HttpTransaction> trans;
-    int rv = cache.http_cache()->CreateTransaction(&trans);
+    int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
     EXPECT_EQ(net::OK, rv);
 
     rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
     EXPECT_EQ(net::OK, callback.GetResult(rv));
 
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
     rv = trans->Read(buf, 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
     // This is actually going to do nothing.
@@ skipping 58 matching lines @@
 
   // Verify that the entry is marked as incomplete.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
   net::HttpResponseInfo response;
   bool truncated = false;
   EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
   EXPECT_TRUE(truncated);
   entry->Close();
 }
+
+TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit_TransactionDelegate) {
+  MockHttpCache cache;
+
+  // write to the cache

[rvargas (doing something else), 2012/07/26 02:13:43]

nit: Starts with uppercase and ends with period. Same below.

[tburkard, 2012/07/26 02:50:54]

Done.

+  RunTransactionTestWithNumDelegateTransactions(cache.http_cache(),
+                                                kSimpleGET_Transaction,
+                                                8);
+
+  // force this transaction to read from the cache
+  MockTransaction transaction(kSimpleGET_Transaction);
+  transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
+
+  RunTransactionTestWithNumDelegateTransactions(cache.http_cache(),
+                                                kSimpleGET_Transaction,
+                                                5);
+}