Added and implemented URLRequest::GetTotalSentBytes.

net/http/http_network_transaction.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_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 131 matching lines @@
       session_(session),
       request_(NULL),
       priority_(priority),
       headers_valid_(false),
       server_ssl_failure_state_(SSL_FAILURE_NONE),
       fallback_error_code_(ERR_SSL_INAPPROPRIATE_FALLBACK),
       fallback_failure_state_(SSL_FAILURE_NONE),
       request_headers_(),
       read_buf_len_(0),
       total_received_bytes_(0),
+      total_sent_bytes_(0),
       next_state_(STATE_NONE),
       establishing_tunnel_(false),
       websocket_handshake_stream_base_create_helper_(NULL) {
   session->ssl_config_service()->GetSSLConfig(&server_ssl_config_);
   session->GetNextProtos(&server_ssl_config_.next_protos);
   proxy_ssl_config_ = server_ssl_config_;
 }
 
 HttpNetworkTransaction::~HttpNetworkTransaction() {
   if (stream_.get()) {
@@ skipping 136 matching lines @@
   // We don't need to drain the response body, so we act as if we had drained
   // the response body.
   DidDrainBodyForAuthRestart(keep_alive);
 }
 
 void HttpNetworkTransaction::DidDrainBodyForAuthRestart(bool keep_alive) {
   DCHECK(!stream_request_.get());
 
   if (stream_.get()) {
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
+    total_sent_bytes_ += stream_->GetTotalSentBytes();
     HttpStream* new_stream = NULL;
     if (keep_alive && stream_->CanReuseConnection()) {
       // We should call connection_->set_idle_time(), but this doesn't occur
       // often enough to be worth the trouble.
       stream_->SetConnectionReused();
       new_stream = stream_->RenewStreamForAuth();
     }
 
     if (!new_stream) {
       // Close the stream and mark it as not_reusable.  Even in the
       // keep_alive case, we've determined that the stream_ is not
       // reusable if new_stream is NULL.
       stream_->Close(true);
       next_state_ = STATE_CREATE_STREAM;
     } else {
-      // Renewed streams shouldn't carry over received bytes.
+      // Renewed streams shouldn't carry over sent or received bytes.
       DCHECK_EQ(0, new_stream->GetTotalReceivedBytes());
+      DCHECK_EQ(0, new_stream->GetTotalSentBytes());
       next_state_ = STATE_INIT_STREAM;
     }
     stream_.reset(new_stream);
   }
 
   // Reset the other member variables.
   ResetStateForAuthRestart();
 }
 
 bool HttpNetworkTransaction::IsReadyToRestartForAuth() {
@@ skipping 49 matching lines @@
   return true;
 }
 
 int64 HttpNetworkTransaction::GetTotalReceivedBytes() const {
   int64 total_received_bytes = total_received_bytes_;
   if (stream_)
     total_received_bytes += stream_->GetTotalReceivedBytes();
   return total_received_bytes;
 }
 
+int64_t HttpNetworkTransaction::GetTotalSentBytes() const {
+  int64_t total_sent_bytes = total_sent_bytes_;
+  if (stream_)
+    total_sent_bytes += stream_->GetTotalSentBytes();
+  return total_sent_bytes;
+}
+
 void HttpNetworkTransaction::DoneReading() {}
 
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
   return &response_;
 }
 
 LoadState HttpNetworkTransaction::GetLoadState() const {
   // TODO(wtc): Define a new LoadState value for the
   // STATE_INIT_CONNECTION_COMPLETE state, which delays the HTTP request.
   switch (next_state_) {
@@ skipping 64 matching lines @@
   DCHECK_EQ(next_state_, STATE_CREATE_STREAM);
   return DoLoop(OK);
 }
 
 void HttpNetworkTransaction::OnStreamReady(const SSLConfig& used_ssl_config,
                                            const ProxyInfo& used_proxy_info,
                                            HttpStream* stream) {
   DCHECK_EQ(STATE_CREATE_STREAM_COMPLETE, next_state_);
   DCHECK(stream_request_.get());
 
-  if (stream_)
+  if (stream_) {
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
+    total_sent_bytes_ += stream_->GetTotalSentBytes();
+  }
   stream_.reset(stream);
   server_ssl_config_ = used_ssl_config;
   proxy_info_ = used_proxy_info;
   response_.was_npn_negotiated = stream_request_->was_npn_negotiated();
   response_.npn_negotiated_protocol = SSLClientSocket::NextProtoToString(
       stream_request_->protocol_negotiated());
   response_.was_fetched_via_spdy = stream_request_->using_spdy();
   response_.was_fetched_via_proxy = !proxy_info_.is_direct();
   if (response_.was_fetched_via_proxy && !proxy_info_.is_empty())
     response_.proxy_server = proxy_info_.proxy_server().host_port_pair();
@@ skipping 78 matching lines @@
     const ProxyInfo& used_proxy_info,
     HttpStream* stream) {
   DCHECK_EQ(STATE_CREATE_STREAM_COMPLETE, next_state_);
 
   CopyConnectionAttemptsFromStreamRequest();
 
   headers_valid_ = true;
   response_ = response_info;
   server_ssl_config_ = used_ssl_config;
   proxy_info_ = used_proxy_info;
-  if (stream_)
+  if (stream_) {
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
+    total_sent_bytes_ += stream_->GetTotalSentBytes();
+  }
   stream_.reset(stream);
   stream_request_.reset();  // we're done with the stream request
   OnIOComplete(ERR_HTTPS_PROXY_TUNNEL_RESPONSE);
 }
 
 void HttpNetworkTransaction::GetConnectionAttempts(
     ConnectionAttempts* out) const {
   *out = connection_attempts_;
 }
 
@@ skipping 213 matching lines @@
 }
 
 int HttpNetworkTransaction::DoInitStreamComplete(int result) {
   if (result == OK) {
     next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
   } else {
     if (result < 0)
       result = HandleIOError(result);
 
     // The stream initialization failed, so this stream will never be useful.
-    if (stream_)
-        total_received_bytes_ += stream_->GetTotalReceivedBytes();
+    if (stream_) {
+      total_received_bytes_ += stream_->GetTotalReceivedBytes();
+      total_sent_bytes_ += stream_->GetTotalSentBytes();
+    }
     stream_.reset();
   }
 
   return result;
 }
 
 int HttpNetworkTransaction::DoGenerateProxyAuthToken() {
   next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE;
   if (!ShouldApplyProxyAuth())
     return OK;
@@ skipping 353 matching lines @@
   //   long time while the user selects a certificate.
   //   Second, even if we did keep the connection open, NSS has a bug where
   //   restarting the handshake for ClientAuth is currently broken.
   DCHECK_EQ(error, ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
 
   if (stream_.get()) {
     // Since we already have a stream, we're being called as part of SSL
     // renegotiation.
     DCHECK(!stream_request_.get());
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
+    total_sent_bytes_ += stream_->GetTotalSentBytes();
     stream_->Close(true);
     stream_.reset();
   }
 
   // The server is asking for a client certificate during the initial
   // handshake.
   stream_request_.reset();
 
   // If the user selected one of the certificates in client_certs or declined
   // to provide one for this server before, use the past decision
@@ skipping 203 matching lines @@
           NetLog::TYPE_HTTP_TRANSACTION_RESTART_AFTER_ERROR, error);
       ResetConnectionAndRequestForResend();
       error = OK;
       break;
   }
   return error;
 }
 
 void HttpNetworkTransaction::ResetStateForRestart() {
   ResetStateForAuthRestart();
-  if (stream_)
+  if (stream_) {
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
+    total_sent_bytes_ += stream_->GetTotalSentBytes();
+  }
   stream_.reset();
 }
 
 void HttpNetworkTransaction::ResetStateForAuthRestart() {
   send_start_time_ = base::TimeTicks();
   send_end_time_ = base::TimeTicks();
 
   pending_auth_target_ = HttpAuth::AUTH_NONE;
   read_buf_ = NULL;
   read_buf_len_ = 0;
@@ skipping 218 matching lines @@
   DCHECK(stream_request_);
 
   // Since the transaction can restart with auth credentials, it may create a
   // stream more than once. Accumulate all of the connection attempts across
   // those streams by appending them to the vector:
   for (const auto& attempt : stream_request_->connection_attempts())
     connection_attempts_.push_back(attempt);
 }
 
 }  // namespace net