Added and implemented URLRequest::GetTotalSentBytes.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 247 matching lines @@
         old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group(
             HttpNetworkSession::NORMAL_SOCKET_POOL)),
         old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool(
             HttpNetworkSession::NORMAL_SOCKET_POOL)) {
   }
 
   struct SimpleGetHelperResult {
     int rv;
     std::string status_line;
     std::string response_data;
-    int64 totalReceivedBytes;
+    int64_t total_received_bytes;
+    int64_t total_sent_bytes;
     LoadTimingInfo load_timing_info;
     ConnectionAttempts connection_attempts;
   };
 
   void SetUp() override {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void TearDown() override {
@@ skipping 55 matching lines @@
       session_deps_.socket_factory->AddSocketDataProvider(data[i]);
     }
 
     TestCompletionCallback callback;
 
     EXPECT_TRUE(log.bound().IsCapturing());
     int rv = trans->Start(&request, callback.callback(), log.bound());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     out.rv = callback.WaitForResult();
+    out.total_sent_bytes = trans->GetTotalSentBytes();
+    out.total_received_bytes = trans->GetTotalReceivedBytes();

[mmenke, 2015/09/04 15:21:49]

Nit:  Received is before sent everywhere else (In retrospect, we probably should
have put sent first everywhere, but not really worth going back and changing
everywhere.

[sclittle, 2015/09/04 22:03:10]

Done.

 
     // Even in the failure cases that use this function, connections are always
     // successfully established before the error.
     EXPECT_TRUE(trans->GetLoadTimingInfo(&out.load_timing_info));
     TestLoadTimingNotReused(out.load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
 
     if (out.rv != OK)
       return out;
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 31 matching lines @@
     EXPECT_TRUE(request_headers.GetHeader("Host", &value));
     EXPECT_EQ("www.example.org", value);
     EXPECT_TRUE(request_headers.GetHeader("Connection", &value));
     EXPECT_EQ("keep-alive", value);
 
     std::string response_headers;
     EXPECT_TRUE(GetHeaders(entries[pos].params.get(), &response_headers));
     EXPECT_EQ("['Host: www.example.org','Connection: keep-alive']",
               response_headers);
 
-    out.totalReceivedBytes = trans->GetTotalReceivedBytes();
+    EXPECT_EQ(
+        static_cast<int64_t>(line.size() + request_headers.ToString().size()),

[mmenke, 2015/09/04 15:21:49]

We really should not be depending on GetFullRequestHeaders, or
headers.ToString().  The former isn't fully implemented, and the latter isn't
correct for SPDY or QUIC.

[sclittle, 2015/09/04 22:03:10]

You're right, removed this. I forgot to remove this check here; it was replaced
with the check in SimpleGetHelper(MockRead, size_t) below.

+        trans->GetTotalSentBytes());
+
+    // The total number of sent bytes should not have changed.
+    EXPECT_EQ(out.total_sent_bytes, trans->GetTotalSentBytes());
+
+    out.total_received_bytes = trans->GetTotalReceivedBytes();
     trans->GetConnectionAttempts(&out.connection_attempts);
     return out;
   }
 
   SimpleGetHelperResult SimpleGetHelper(MockRead data_reads[],
                                         size_t reads_count) {
-    StaticSocketDataProvider reads(data_reads, reads_count, NULL, 0);
-    StaticSocketDataProvider* data[] = { &reads };
-    return SimpleGetHelperForData(data, 1);
-  }
+    MockWrite data_writes[] = {
+        MockWrite("GET / HTTP/1.1\r\n"
+                  "Host: www.example.org\r\n"
+                  "Connection: keep-alive\r\n\r\n"),
+    };

[mmenke, 2015/09/04 15:21:49]

So I guess no tests that use this method use SPDY or QUIC?

[sclittle, 2015/09/04 22:03:10]

That's correct.

 
-  int64 ReadsSize(MockRead data_reads[], size_t reads_count) {
-    int64 size = 0;
-    for (size_t i = 0; i < reads_count; ++i)
-      size += data_reads[i].data_len;
-    return size;
+    StaticSocketDataProvider reads(data_reads, reads_count, data_writes,
+                                   arraysize(data_writes));
+    StaticSocketDataProvider* data[] = {&reads};
+    SimpleGetHelperResult out = SimpleGetHelperForData(data, 1);
+
+    EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
+              out.total_sent_bytes);
+    return out;
   }
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
                                              int expected_status);
 
   void ConnectStatusHelper(const MockRead& status);
 
   void BypassHostCacheOnRefreshHelper(int load_flags);
 
   void CheckErrorIsPassedBack(int error, IoMode mode);
@@ skipping 250 matching lines @@
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
   EXPECT_EQ(0u, out.connection_attempts.size());
 }
 
 // Response with no status line.
 TEST_P(HttpNetworkTransactionTest, SimpleGETNoHeaders) {
   MockRead data_reads[] = {
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
 TEST_P(HttpNetworkTransactionTest, StatusLineJunk3Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
 TEST_P(HttpNetworkTransactionTest, StatusLineJunk4Bytes) {
   MockRead data_reads[] = {
     MockRead("\n\nQJHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
 }
 
 // Beyond 4 bytes of slop and it should fail to find a status line.
 TEST_P(HttpNetworkTransactionTest, StatusLineJunk5Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxxxHTTP/1.1 404 Not Found\nServer: blah"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("xxxxxHTTP/1.1 404 Not Found\nServer: blah", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
 }
 
 // Same as StatusLineJunk4Bytes, except the read chunks are smaller.
 TEST_P(HttpNetworkTransactionTest, StatusLineJunk4Bytes_Slow) {
   MockRead data_reads[] = {
     MockRead("\n"),
     MockRead("\n"),
     MockRead("Q"),
     MockRead("J"),
     MockRead("HTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
 }
 
 // Close the connection before enough bytes to have a status line.
 TEST_P(HttpNetworkTransactionTest, StatusLinePartial) {
   MockRead data_reads[] = {
     MockRead("HTT"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("HTT", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  EXPECT_EQ(reads_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  EXPECT_EQ(reads_size, out.total_received_bytes);
 }
 
 // Simulate a 204 response, lacking a Content-Length header, sent over a
 // persistent connection.  The response should still terminate since a 204
 // cannot have a response body.
 TEST_P(HttpNetworkTransactionTest, StopsReading204) {
   char junk[] = "junk";
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n\r\n"),
     MockRead(junk),  // Should not be read!!
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 204 No Content", out.status_line);
   EXPECT_EQ("", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  int64 response_size = reads_size - strlen(junk);
-  EXPECT_EQ(response_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  int64_t response_size = reads_size - strlen(junk);
+  EXPECT_EQ(response_size, out.total_received_bytes);
 }
 
 // A simple request using chunked encoding with some extra data after.
 TEST_P(HttpNetworkTransactionTest, ChunkedEncoding) {
   std::string final_chunk = "0\r\n\r\n";
   std::string extra_data = "HTTP/1.1 200 OK\r\n";
   std::string last_read = final_chunk + extra_data;
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"),
     MockRead("5\r\nHello\r\n"),
     MockRead("1\r\n"),
     MockRead(" \r\n"),
     MockRead("5\r\nworld\r\n"),
     MockRead(last_read.data()),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello world", out.response_data);
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
-  int64 response_size = reads_size - extra_data.size();
-  EXPECT_EQ(response_size, out.totalReceivedBytes);
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
+  int64_t response_size = reads_size - extra_data.size();
+  EXPECT_EQ(response_size, out.total_received_bytes);
 }
 
 // Next tests deal with http://crbug.com/56344.
 
 TEST_P(HttpNetworkTransactionTest,
        MultipleContentLengthHeadersNoTransferEncoding) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 10\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
@@ skipping 1115 matching lines @@
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   LoadTimingInfo load_timing_info1;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info1));
   TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES);
 
-  int64 reads_size1 = ReadsSize(data_reads1, arraysize(data_reads1));
+  int64_t writes_size1 = CountWriteBytes(data_writes1, arraysize(data_writes1));
+  EXPECT_EQ(writes_size1, trans->GetTotalSentBytes());
+  int64_t reads_size1 = CountReadBytes(data_reads1, arraysize(data_reads1));
   EXPECT_EQ(reads_size1, trans->GetTotalReceivedBytes());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(
       AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   LoadTimingInfo load_timing_info2;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info2));
   TestLoadTimingNotReused(load_timing_info2, CONNECT_TIMING_HAS_DNS_TIMES);
   // The load timing after restart should have a new socket ID, and times after
   // those of the first load timing.
   EXPECT_LE(load_timing_info1.receive_headers_end,
             load_timing_info2.connect_timing.connect_start);
   EXPECT_NE(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
-  int64 reads_size2 = ReadsSize(data_reads2, arraysize(data_reads2));
+  int64_t writes_size2 = CountWriteBytes(data_writes2, arraysize(data_writes2));
+  EXPECT_EQ(writes_size1 + writes_size2, trans->GetTotalSentBytes());
+  int64_t reads_size2 = CountReadBytes(data_reads2, arraysize(data_reads2));
   EXPECT_EQ(reads_size1 + reads_size2, trans->GetTotalReceivedBytes());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 TEST_P(HttpNetworkTransactionTest, DoNotSendAuth) {
   HttpRequestInfo request;
@@ skipping 25 matching lines @@
                                 data_writes, arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
-  int64 reads_size = ReadsSize(data_reads, arraysize(data_reads));
+  int64_t writes_size = CountWriteBytes(data_writes, arraysize(data_writes));
+  EXPECT_EQ(writes_size, trans->GetTotalSentBytes());
+  int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
   EXPECT_EQ(reads_size, trans->GetTotalReceivedBytes());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection.
 TEST_P(HttpNetworkTransactionTest, BasicAuthKeepAlive) {
@@ skipping 85 matching lines @@
   EXPECT_EQ(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
-  int64 reads_size1 = ReadsSize(data_reads1, arraysize(data_reads1));
+
+  int64_t writes_size1 = CountWriteBytes(data_writes1, arraysize(data_writes1));
+  EXPECT_EQ(writes_size1, trans->GetTotalSentBytes());
+  int64_t reads_size1 = CountReadBytes(data_reads1, arraysize(data_reads1));
   EXPECT_EQ(reads_size1, trans->GetTotalReceivedBytes());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection and with no response body to drain.
 TEST_P(HttpNetworkTransactionTest, BasicAuthKeepAliveNoBody) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
@@ skipping 12431 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers.get());
 
   EXPECT_EQ(101, response->headers->response_code());
 
   trans.reset();
   session->CloseAllConnections();
 }
 
+TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesPost) {
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://www.foo.com/");
+  request.upload_data_stream = &upload_data_stream;
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  MockWrite data_writes[] = {
+      MockWrite("POST / HTTP/1.1\r\n"
+                "Host: www.foo.com\r\n"
+                "Connection: keep-alive\r\n"
+                "Content-Length: 3\r\n\r\n"),
+      MockWrite("foo"),
+  };
+
+  MockRead data_reads[] = {
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
+      MockRead(SYNCHRONOUS, OK),
+  };
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
+                                arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  EXPECT_EQ(ERR_IO_PENDING,
+            trans->Start(&request, callback.callback(), BoundNetLog()));
+  EXPECT_EQ(OK, callback.WaitForResult());
+
+  std::string response_data;
+  EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+
+  EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
+            trans->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
+            trans->GetTotalReceivedBytes());
+}
+
+TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesPost100Continue) {
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://www.foo.com/");
+  request.upload_data_stream = &upload_data_stream;
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  MockWrite data_writes[] = {
+      MockWrite("POST / HTTP/1.1\r\n"
+                "Host: www.foo.com\r\n"
+                "Connection: keep-alive\r\n"
+                "Content-Length: 3\r\n\r\n"),
+      MockWrite("foo"),
+  };
+
+  MockRead data_reads[] = {
+      MockRead("HTTP/1.1 100 Continue\r\n\r\n"),
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),

[mmenke, 2015/09/04 15:21:49]

Second mock read should be on next line...Or does git cl format insist it be
there?

[sclittle, 2015/09/04 22:03:10]

git cl format did this.

+      MockRead(SYNCHRONOUS, OK),
+  };
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
+                                arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  EXPECT_EQ(ERR_IO_PENDING,
+            trans->Start(&request, callback.callback(), BoundNetLog()));
+  EXPECT_EQ(OK, callback.WaitForResult());
+
+  std::string response_data;
+  EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+
+  EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
+            trans->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
+            trans->GetTotalReceivedBytes());
+}
+
+TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesChunkedPost) {
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  ChunkedUploadDataStream upload_data_stream(0);
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://www.foo.com/");
+  request.upload_data_stream = &upload_data_stream;
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  // Send headers successfully, but get an error while sending the body.
+  MockWrite data_writes[] = {
+      MockWrite("POST / HTTP/1.1\r\n"
+                "Host: www.foo.com\r\n"
+                "Connection: keep-alive\r\n"
+                "Transfer-Encoding: chunked\r\n\r\n"),
+      MockWrite("1\r\nf\r\n"), MockWrite("2\r\noo\r\n"), MockWrite("0\r\n\r\n"),
+  };
+
+  MockRead data_reads[] = {
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
+      MockRead(SYNCHRONOUS, OK),
+  };
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
+                                arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  EXPECT_EQ(ERR_IO_PENDING,
+            trans->Start(&request, callback.callback(), BoundNetLog()));
+
+  base::RunLoop().RunUntilIdle();
+  upload_data_stream.AppendData("f", 1, false);
+
+  base::RunLoop().RunUntilIdle();
+  upload_data_stream.AppendData("oo", 2, true);
+
+  EXPECT_EQ(OK, callback.WaitForResult());
+
+  std::string response_data;
+  EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+
+  EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
+            trans->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
+            trans->GetTotalReceivedBytes());
+}
+
 }  // namespace net