Added and implemented URLRequest::GetTotalSentBytes.

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 <stdint.h>
+
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 112 matching lines @@
   std::string expected(trans_info.data);
   EXPECT_EQ(expected, content);
 }
 
 void RunTransactionTestBase(HttpCache* cache,
                             const MockTransaction& trans_info,
                             const MockHttpRequest& request,
                             HttpResponseInfo* response_info,
                             const BoundNetLog& net_log,
                             LoadTimingInfo* load_timing_info,
-                            int64* received_bytes) {
+                            int64_t* sent_bytes,
+                            int64_t* received_bytes) {
   TestCompletionCallback callback;
 
   // write to the cache
 
   scoped_ptr<HttpTransaction> trans;
   int rv = cache->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_EQ(OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net_log);
@@ skipping 13 matching lines @@
   if (load_timing_info) {
     // If a fake network connection is used, need a NetLog to get a fake socket
     // ID.
     EXPECT_TRUE(net_log.net_log());
     *load_timing_info = LoadTimingInfo();
     trans->GetLoadTimingInfo(load_timing_info);
   }
 
   ReadAndVerifyTransaction(trans.get(), trans_info);
 
+  if (sent_bytes)
+    *sent_bytes = trans->GetTotalSentBytes();
   if (received_bytes)
     *received_bytes = trans->GetTotalReceivedBytes();
 }
 
 void RunTransactionTestWithRequest(HttpCache* cache,
                                    const MockTransaction& trans_info,
                                    const MockHttpRequest& request,
                                    HttpResponseInfo* response_info) {
   RunTransactionTestBase(cache, trans_info, request, response_info,
-                         BoundNetLog(), NULL, NULL);
+                         BoundNetLog(), nullptr, nullptr, nullptr);
 }
 
 void RunTransactionTestAndGetTiming(HttpCache* cache,
                                     const MockTransaction& trans_info,
                                     const BoundNetLog& log,
                                     LoadTimingInfo* load_timing_info) {
   RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
-                         NULL, log, load_timing_info, NULL);
+                         nullptr, log, load_timing_info, nullptr, nullptr);
 }
 
 void RunTransactionTest(HttpCache* cache, const MockTransaction& trans_info) {
-  RunTransactionTestAndGetTiming(cache, trans_info, BoundNetLog(), NULL);
+  RunTransactionTestAndGetTiming(cache, trans_info, BoundNetLog(), nullptr);
 }
 
 void RunTransactionTestWithLog(HttpCache* cache,
                                const MockTransaction& trans_info,
                                const BoundNetLog& log) {
-  RunTransactionTestAndGetTiming(cache, trans_info, log, NULL);
+  RunTransactionTestAndGetTiming(cache, trans_info, log, nullptr);
 }
 
 void RunTransactionTestWithResponseInfo(HttpCache* cache,
                                         const MockTransaction& trans_info,
                                         HttpResponseInfo* response) {
   RunTransactionTestWithRequest(cache, trans_info, MockHttpRequest(trans_info),
                                 response);
 }
 
 void RunTransactionTestWithResponseInfoAndGetTiming(
     HttpCache* cache,
     const MockTransaction& trans_info,
     HttpResponseInfo* response,
     const BoundNetLog& log,
     LoadTimingInfo* load_timing_info) {
   RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
-                         response, log, load_timing_info, NULL);
+                         response, log, load_timing_info, nullptr, nullptr);
 }
 
 void RunTransactionTestWithResponse(HttpCache* cache,
                                     const MockTransaction& trans_info,
                                     std::string* response_headers) {
   HttpResponseInfo response;
   RunTransactionTestWithResponseInfo(cache, trans_info, &response);
   response.headers->GetNormalizedHeaders(response_headers);
 }
 
 void RunTransactionTestWithResponseAndGetTiming(
     HttpCache* cache,
     const MockTransaction& trans_info,
     std::string* response_headers,
     const BoundNetLog& log,
     LoadTimingInfo* load_timing_info) {
   HttpResponseInfo response;
   RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
-                         &response, log, load_timing_info, NULL);
+                         &response, log, load_timing_info, nullptr, nullptr);
   response.headers->GetNormalizedHeaders(response_headers);
 }
 
 // This class provides a handler for kFastNoStoreGET_Transaction so that the
 // no-store header can be included on demand.
 class FastTransactionServer {
  public:
   FastTransactionServer() {
     no_store = false;
   }
@@ skipping 6854 matching lines @@
   trans->SetPriority(HIGHEST);
   // Should trigger a new network transaction and pick up the new
   // priority.
   ReadAndVerifyTransaction(trans.get(), transaction);
 
   EXPECT_EQ(HIGHEST, cache.network_layer()->last_create_transaction_priority());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
-int64 RunTransactionAndGetReceivedBytes(
-    MockHttpCache& cache,
-    const MockTransaction& trans_info) {
-  int64 received_bytes = -1;
+namespace {
+
+void RunTransactionAndGetNetworkBytes(MockHttpCache& cache,
+                                      const MockTransaction& trans_info,
+                                      int64_t* sent_bytes,
+                                      int64_t* received_bytes) {
   RunTransactionTestBase(cache.http_cache(), trans_info,
-                         MockHttpRequest(trans_info), NULL, BoundNetLog(), NULL,
-                         &received_bytes);
-  return received_bytes;
+                         MockHttpRequest(trans_info), nullptr, BoundNetLog(),
+                         nullptr, sent_bytes, received_bytes);
 }
 
-int64 TransactionSize(const MockTransaction& transaction) {
-  return strlen(transaction.status) + strlen(transaction.response_headers) +
-         strlen(transaction.data);
-}
+}  // namespace
 
-TEST(HttpCache, ReceivedBytesCacheMissAndThenHit) {
+TEST(HttpCache, NetworkBytesCacheMissAndThenHit) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimpleGET_Transaction);
-  int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(TransactionSize(transaction), received_bytes);
+  int64_t sent, received;
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
-  received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(0, received_bytes);
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(0, sent);
+  EXPECT_EQ(0, received);
 }
 
-TEST(HttpCache, ReceivedBytesConditionalRequest304) {
+TEST(HttpCache, NetworkBytesConditionalRequest304) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kETagGET_Transaction);
-  int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(TransactionSize(transaction), received_bytes);
+  int64_t sent, received;
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   transaction.load_flags = LOAD_VALIDATE_CACHE;
   transaction.handler = ETagGet_ConditionalRequest_Handler;
-  received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(TransactionSize(transaction), received_bytes);
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 }
 
-TEST(HttpCache, ReceivedBytesConditionalRequest200) {
+TEST(HttpCache, NetworkBytesConditionalRequest200) {
   MockHttpCache cache;
 
   MockTransaction transaction(kTypicalGET_Transaction);
   transaction.request_headers = "Foo: bar\r\n";
   transaction.response_headers =
       "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Etag: \"foopy\"\n"
       "Cache-Control: max-age=0\n"
       "Vary: Foo\n";
   AddMockTransaction(&transaction);
-  int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(TransactionSize(transaction), received_bytes);
+  int64_t sent, received;
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   RevalidationServer server;
   transaction.handler = server.Handler;
   transaction.request_headers = "Foo: none\r\n";
-  received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(TransactionSize(transaction), received_bytes);
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   RemoveMockTransaction(&transaction);
 }
 
-TEST(HttpCache, ReceivedBytesRange) {
+TEST(HttpCache, NetworkBytesRange) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
   MockTransaction transaction(kRangeGET_TransactionOK);
 
   // Read bytes 40-49 from the network.
-  int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  int64 range_response_size = TransactionSize(transaction);
-  EXPECT_EQ(range_response_size, received_bytes);
+  int64_t sent, received;
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
 
   // Read bytes 40-49 from the cache.
-  received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(0, received_bytes);
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(0, sent);
+  EXPECT_EQ(0, received);
   base::MessageLoop::current()->RunUntilIdle();
 
   // Read bytes 30-39 from the network.
   transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
   transaction.data = "rg: 30-39 ";
-  received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(range_response_size, received_bytes);
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
   base::MessageLoop::current()->RunUntilIdle();
 
   // Read bytes 20-29 and 50-59 from the network, bytes 30-49 from the cache.
   transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
   transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
-  received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
-  EXPECT_EQ(range_response_size * 2, received_bytes);
+  RunTransactionAndGetNetworkBytes(cache, transaction, &sent, &received);
+  EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes * 2, sent);
+  EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes * 2, received);
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 class HttpCachePrefetchValidationTest : public ::testing::Test {
  protected:
   static const int kMaxAgeSecs = 100;
   static const int kRequireValidationSecs = kMaxAgeSecs + 1;
 
   HttpCachePrefetchValidationTest() : transaction_(kSimpleGET_Transaction) {
@@ skipping 420 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   EXPECT_TRUE(response_info.was_cached);
 
   // The new SSL state is reported.
   EXPECT_EQ(status2, response_info.ssl_info.connection_status);
   EXPECT_TRUE(cert2->Equals(response_info.ssl_info.cert.get()));
 }
 
 }  // namespace net