Added and implemented URLRequest::GetTotalSentBytes.

net/http/http_transaction_test_util.cc

 // Copyright 2014 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_transaction_test_util.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 224 matching lines @@
 }
 
 MockNetworkTransaction::MockNetworkTransaction(RequestPriority priority,
                                                MockNetworkLayer* factory)
     : request_(NULL),
       data_cursor_(0),
       priority_(priority),
       websocket_handshake_stream_create_helper_(NULL),
       transaction_factory_(factory->AsWeakPtr()),
       received_bytes_(0),
+      sent_bytes_(0),
       socket_log_id_(NetLog::Source::kInvalidId),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const HttpRequestInfo* request,
                                   const CompletionCallback& callback,
                                   const BoundNetLog& net_log) {
   if (request_)
     return ERR_FAILED;
 
   request_ = request;
@@ skipping 64 matching lines @@
 
 bool MockNetworkTransaction::GetFullRequestHeaders(
     HttpRequestHeaders* headers) const {
   return false;
 }
 
 int64 MockNetworkTransaction::GetTotalReceivedBytes() const {
   return received_bytes_;
 }
 
+int64_t MockNetworkTransaction::GetTotalSentBytes() const {
+  return sent_bytes_;
+}
+
 void MockNetworkTransaction::DoneReading() {
   if (transaction_factory_.get())
     transaction_factory_->TransactionDoneReading();
 }
 
 const HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const {
   return &response_;
 }
 
 LoadState MockNetworkTransaction::GetLoadState() const {
@@ skipping 34 matching lines @@
 
 void MockNetworkTransaction::SetPriority(RequestPriority priority) {
   priority_ = priority;
 }
 
 void MockNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
     WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
   websocket_handshake_stream_create_helper_ = create_helper;
 }
 
+// static
+const int64_t MockNetworkTransaction::kTotalReceivedBytes = 1000;
+
+// static
+const int64_t MockNetworkTransaction::kTotalSentBytes = 100;
+
 int MockNetworkTransaction::StartInternal(const HttpRequestInfo* request,
                                           const CompletionCallback& callback,
                                           const BoundNetLog& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return ERR_FAILED;
 
   test_mode_ = t->test_mode;
 
   // Return immediately if we're returning an error.
   if (OK != t->return_code) {
     if (test_mode_ & TEST_MODE_SYNC_NET_START)
       return t->return_code;
     CallbackLater(callback, t->return_code);
     return ERR_IO_PENDING;
   }
 
+  sent_bytes_ = kTotalSentBytes;
+  received_bytes_ = kTotalReceivedBytes;
+
   std::string resp_status = t->status;
   std::string resp_headers = t->response_headers;
   std::string resp_data = t->data;
-  received_bytes_ = resp_status.size() + resp_headers.size() + resp_data.size();
   if (t->handler)
     (t->handler)(request, &resp_status, &resp_headers, &resp_data);
 
   std::string header_data = base::StringPrintf(
       "%s\n%s\n", resp_status.c_str(), resp_headers.c_str());
   std::replace(header_data.begin(), header_data.end(), '\n', '\0');
 
   response_.request_time = transaction_factory_->Now();
   if (!t->request_time.is_null())
     response_.request_time = t->request_time;
@@ skipping 122 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net