Added and implemented HttpStream::GetTotalSentBytes for basic streams.

net/http/http_stream_parser.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_stream_parser.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 190 matching lines @@
                                    GrowableIOBuffer* read_buffer,
                                    const BoundNetLog& net_log)
     : io_state_(STATE_NONE),
       request_(request),
       request_headers_(NULL),
       request_headers_length_(0),
       read_buf_(read_buffer),
       read_buf_unused_offset_(0),
       response_header_start_offset_(-1),
       received_bytes_(0),
+      sent_bytes_(0),
       response_body_length_(-1),
       response_body_read_(0),
       user_read_buf_(NULL),
       user_read_buf_len_(0),
       connection_(connection),
       net_log_(net_log),
       sent_last_chunk_(false),
       upload_error_(OK),
       weak_ptr_factory_(this) {
   io_callback_ = base::Bind(&HttpStreamParser::OnIOComplete,
@@ skipping 246 matching lines @@
     // an error that this should try reading after, stash the error for now and
     // act like the request was successfully sent.
     if (request_headers_->BytesConsumed() >= request_headers_length_ &&
         ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
     return result;
   }
 
+  sent_bytes_ += result;
   request_headers_->DidConsume(result);
   if (request_headers_->BytesRemaining() > 0) {
     io_state_ = STATE_SEND_HEADERS;
     return OK;
   }
 
   if (request_->upload_data_stream != NULL &&
       (request_->upload_data_stream->is_chunked() ||
       // !IsEOF() indicates that the body wasn't merged.
       (request_->upload_data_stream->size() > 0 &&
@@ skipping 37 matching lines @@
   if (result < 0) {
     // If |result| is an error that this should try reading after, stash the
     // error for now and act like the request was successfully sent.
     if (ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
     return result;
   }
 
+  sent_bytes_ += result;
   request_body_send_buf_->DidConsume(result);
 
   io_state_ = STATE_SEND_BODY;
   return OK;
 }
 
 int HttpStreamParser::DoSendRequestReadBodyComplete(int result) {
   // |result| is the result of read from the request body from the last call to
   // DoSendBody().
   DCHECK_GE(result, 0);  // There won't be errors.
@@ skipping 586 matching lines @@
 }
 
 void HttpStreamParser::ValidateStatusLine(const std::string& status_line) {
   HttpStatusLineValidator::StatusLineStatus status =
       HttpStatusLineValidator::ValidateStatusLine(status_line);
   UMA_HISTOGRAM_ENUMERATION("Net.HttpStatusLineStatus", status,
                             HttpStatusLineValidator::STATUS_LINE_MAX);
 }
 
 }  // namespace net