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) {
+  explicit TestHttpTransactionDelegate(int num_cache_actions_to_observe,

[rvargas (doing something else), 2012/08/16 01:18:40]

not explicit

[tburkard, 2012/08/16 22:37:43]

Done.

+                                       int num_network_actions_to_observe)
+      : 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;
+    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;
+    EXPECT_TRUE(cache_action_in_progress_);
+    cache_action_in_progress_ = false;
+  }
+  virtual void OnNetworkActionStart() {
+    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() {
+    EXPECT_TRUE(network_action_in_progress_);
+    network_action_in_progress_ = false;
   }
 
  private:
-  int num_remaining_actions_to_observe_;
-  bool action_in_progress_;
+  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 4848 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);
 }

[rvargas (doing something else), 2012/08/16 01:18:40]

There is no test for request cancellation. That was a bug released to the field
so it deserves a regression test.

[tburkard, 2012/08/16 22:37:43]

Done.