Add histograms for network activity, and total/cumulative

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"
@@ skipping 44 matching lines @@
   net::CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCacheCompletionCallback);
 };
 
 //-----------------------------------------------------------------------------
 // helpers
 
 class TestHttpTransactionDelegate : public net::HttpTransactionDelegate {
  public:
-  explicit TestHttpTransactionDelegate(int num_actions_to_observe)
-      : num_remaining_actions_to_observe_(num_actions_to_observe),
-        action_in_progress_(false) {
+  TestHttpTransactionDelegate(int num_cache_actions_to_observe,
+                              int num_network_actions_to_observe)
+      : num_callbacks_observed_(0),
+        num_remaining_cache_actions_to_observe_(num_cache_actions_to_observe),
+        num_remaining_network_actions_to_observe_(
+            num_network_actions_to_observe),
+        cache_action_in_progress_(false),
+        network_action_in_progress_(false) {
   }
   virtual ~TestHttpTransactionDelegate() {
-    EXPECT_EQ(0, num_remaining_actions_to_observe_);
-    EXPECT_FALSE(action_in_progress_);
+    EXPECT_EQ(0, num_remaining_cache_actions_to_observe_);
+    EXPECT_EQ(0, num_remaining_network_actions_to_observe_);
+    EXPECT_FALSE(cache_action_in_progress_);
+    EXPECT_FALSE(network_action_in_progress_);
   }
-  virtual void OnCacheActionStart() {
-    EXPECT_FALSE(action_in_progress_);
-    EXPECT_GT(num_remaining_actions_to_observe_, 0);
-    num_remaining_actions_to_observe_--;
-    action_in_progress_ = true;
+  virtual void OnCacheActionStart() OVERRIDE {
+    num_callbacks_observed_++;
+    EXPECT_FALSE(cache_action_in_progress_);
+    EXPECT_FALSE(network_action_in_progress_);
+    EXPECT_GT(num_remaining_cache_actions_to_observe_, 0);
+    num_remaining_cache_actions_to_observe_--;
+    cache_action_in_progress_ = true;
   }
-  virtual void OnCacheActionFinish() {
-    EXPECT_TRUE(action_in_progress_);
-    action_in_progress_ = false;
+  virtual void OnCacheActionFinish() OVERRIDE {
+    num_callbacks_observed_++;
+    EXPECT_TRUE(cache_action_in_progress_);
+    cache_action_in_progress_ = false;
+  }
+  virtual void OnNetworkActionStart() OVERRIDE {
+    num_callbacks_observed_++;
+    EXPECT_FALSE(cache_action_in_progress_);
+    EXPECT_FALSE(network_action_in_progress_);
+    EXPECT_GT(num_remaining_network_actions_to_observe_, 0);
+    num_remaining_network_actions_to_observe_--;
+    network_action_in_progress_ = true;
+  }
+  virtual void OnNetworkActionFinish() OVERRIDE {
+    num_callbacks_observed_++;
+    EXPECT_TRUE(network_action_in_progress_);
+    network_action_in_progress_ = false;
   }
 
+  int num_callbacks_observed() { return num_callbacks_observed_; }
+
  private:
-  int num_remaining_actions_to_observe_;
-  bool action_in_progress_;
+  int num_callbacks_observed_;
+  int num_remaining_cache_actions_to_observe_;
+  int num_remaining_network_actions_to_observe_;
+  bool cache_action_in_progress_;
+  bool network_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);
 }
 
 const int kNoDelegateTransactionCheck = -1;
 
 void RunTransactionTestWithRequestAndLogAndDelegate(
     net::HttpCache* cache,
     const MockTransaction& trans_info,
     const MockHttpRequest& request,
     net::HttpResponseInfo* response_info,
     const net::BoundNetLog& net_log,
-    int num_delegate_actions) {
+    int num_cache_delegate_actions,
+    int num_network_delegate_actions) {
   net::TestCompletionCallback callback;
 
   // write to the cache
 
   scoped_ptr<TestHttpTransactionDelegate> delegate;
-  if (num_delegate_actions != kNoDelegateTransactionCheck) {
-    delegate.reset(new TestHttpTransactionDelegate(num_delegate_actions));
+  if (num_cache_delegate_actions != kNoDelegateTransactionCheck &&
+      num_network_delegate_actions != kNoDelegateTransactionCheck) {
+    delegate.reset(
+        new TestHttpTransactionDelegate(num_cache_delegate_actions,
+                                        num_network_delegate_actions));
   }
   scoped_ptr<net::HttpTransaction> trans;
   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) {
   RunTransactionTestWithRequestAndLogAndDelegate(
       cache, trans_info, request, response_info, net::BoundNetLog(),
-      kNoDelegateTransactionCheck);
+      kNoDelegateTransactionCheck, kNoDelegateTransactionCheck);
 }
 
 void RunTransactionTestWithLog(net::HttpCache* cache,
                                const MockTransaction& trans_info,
                                const net::BoundNetLog& log) {
   RunTransactionTestWithRequestAndLogAndDelegate(
       cache, trans_info, MockHttpRequest(trans_info), NULL, log,
-      kNoDelegateTransactionCheck);
+      kNoDelegateTransactionCheck, kNoDelegateTransactionCheck);
 }
 
 void RunTransactionTestWithDelegate(net::HttpCache* cache,
                                     const MockTransaction& trans_info,
-                                    int num_delegate_actions) {
+                                    int num_cache_delegate_actions,
+                                    int num_network_delegate_actions) {
   RunTransactionTestWithRequestAndLogAndDelegate(
       cache, trans_info, MockHttpRequest(trans_info), NULL, net::BoundNetLog(),
-      num_delegate_actions);
+      num_cache_delegate_actions, num_network_delegate_actions);
 }
 
 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 3730 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, NULL);
+  // We use a test delegate to ensure that after initiating destruction
+  // of the transaction, no further delegate callbacks happen.
+  // We initialize the TestHttpTransactionDelegate with the correct number of
+  // cache actions and network actions to be reported.
+  scoped_ptr<TestHttpTransactionDelegate> delegate(
+      new TestHttpTransactionDelegate(7, 3));
+  int rv = cache.http_cache()->CreateTransaction(&c->trans, delegate.get());
   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());
 
   // 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.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // We want to cancel the request when the transaction is busy.
   rv = c->trans->Read(buf, buf->size(), c->callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   EXPECT_FALSE(c->callback.have_result());
 
   MockHttpCache::SetTestMode(TEST_MODE_SYNC_ALL);
+  int num_delegate_callbacks_before_destruction =
+      delegate->num_callbacks_observed();
 
   // Destroy the transaction.
   c->trans.reset();
   MockHttpCache::SetTestMode(0);
 
+  // Ensure the delegate received no callbacks during destruction.
+  EXPECT_EQ(num_delegate_callbacks_before_destruction,
+            delegate->num_callbacks_observed());
+
+  // Since the transaction was aborted in the middle of network I/O, we will
+  // manually call the delegate so that its pending I/O operation will be
+  // closed (which is what the test delegate is expecting).
+  delegate->OnNetworkActionFinish();
+
   // Make sure that we don't invoke the callback. We may have an issue if the
   // UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
   // could end up with the transaction being deleted twice if we send any
   // notification from the transaction destructor (see http://crbug.com/31723).
   EXPECT_FALSE(c->callback.have_result());
 
   // Verify that the entry is marked as incomplete.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
   net::HttpResponseInfo response;
@@ skipping 1069 matching lines @@
   EXPECT_TRUE(truncated);
   entry->Close();
 }
 
 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit_TransactionDelegate) {
   MockHttpCache cache;
 
   // Write to the cache.
   RunTransactionTestWithDelegate(cache.http_cache(),
                                  kSimpleGET_Transaction,
-                                 8);
+                                 8,
+                                 3);
 
   // Force this transaction to read from the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   RunTransactionTestWithDelegate(cache.http_cache(),
                                  kSimpleGET_Transaction,
-                                 5);
+                                 5,
+                                 0);
 }