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 51 matching lines @@
   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;
   }
 
+  std::string request_line =
+      base::StringPrintf("%s %s HTTP/1.1\r\n", request->method.c_str(),
+                         request->url.PathForRequest().c_str());
+  sent_bytes_ = request_line.size();
+  if (t->request_headers)
+    sent_bytes_ += strlen(t->request_headers);

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

This logic seems ugly and pointless, given that we have to duplicate the exact
same logic in the cache unit tests.  Since these aren't real transactions, can
we just use some sort of bogus value, and expose it in the header, and then use
that for the cache tests?

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

Done.

+
   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');
@@ skipping 126 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net