Notify NetworkDelegate when bytes have been sent over the network.

net/base/layered_network_delegate_unittest.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/base/layered_network_delegate.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 80 matching lines @@
 
   void OnResponseStarted(URLRequest* request) override {
     IncrementAndCompareCounter("on_response_started_count");
   }
 
   void OnNetworkBytesReceived(const URLRequest& request,
                               int64_t bytes_received) override {
     IncrementAndCompareCounter("on_network_bytes_received_count");
   }
 
+  void OnNetworkBytesSent(const URLRequest& request,
+                          int64_t bytes_sent) override {
+    IncrementAndCompareCounter("on_network_bytes_sent_count");
+  }
+
   void OnCompleted(URLRequest* request, bool started) override {
     IncrementAndCompareCounter("on_completed_count");
   }
 
   void OnURLRequestDestroyed(URLRequest* request) override {
     IncrementAndCompareCounter("on_url_request_destroyed_count");
   }
 
   void OnPACScriptError(int line_number, const base::string16& error) override {
     IncrementAndCompareCounter("on_pac_script_error_count");
@@ skipping 79 matching lines @@
     scoped_ptr<ProxyInfo> proxy_info(new ProxyInfo());
 
     EXPECT_EQ(OK, OnBeforeURLRequest(request.get(),
                                      completion_callback.callback(), NULL));
     OnResolveProxy(GURL(), 0, *proxy_service, proxy_info.get());
     OnProxyFallback(ProxyServer(), 0);
     EXPECT_EQ(OK, OnBeforeSendHeaders(NULL, completion_callback.callback(),
                                       request_headers.get()));
     OnBeforeSendProxyHeaders(NULL, ProxyInfo(), request_headers.get());
     OnSendHeaders(NULL, *request_headers);
+    OnNetworkBytesSent(*request, 42);
     EXPECT_EQ(OK, OnHeadersReceived(NULL, completion_callback.callback(),
                                     response_headers.get(), NULL, NULL));
     OnResponseStarted(request.get());
     OnNetworkBytesReceived(*request, 42);
     OnCompleted(request.get(), false);
     OnURLRequestDestroyed(request.get());
     OnPACScriptError(0, base::string16());
     EXPECT_EQ(
         NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION,
         OnAuthRequired(request.get(), *auth_challenge, AuthCallback(), NULL));
@@ skipping 67 matching lines @@
     ++(*counters_)["on_response_started_count"];
     EXPECT_EQ(1, (*counters_)["on_response_started_count"]);
   }
 
   void OnNetworkBytesReceivedInternal(const URLRequest& request,
                                       int64_t bytes_received) override {
     ++(*counters_)["on_network_bytes_received_count"];
     EXPECT_EQ(1, (*counters_)["on_network_bytes_received_count"]);
   }
 
+  void OnNetworkBytesSentInternal(const URLRequest& request,
+                                  int64_t bytes_sent) override {
+    ++(*counters_)["on_network_bytes_sent_count"];
+    EXPECT_EQ(1, (*counters_)["on_network_bytes_sent_count"]);
+  }
+
   void OnCompletedInternal(URLRequest* request, bool started) override {
     ++(*counters_)["on_completed_count"];
     EXPECT_EQ(1, (*counters_)["on_completed_count"]);
   }
 
   void OnURLRequestDestroyedInternal(URLRequest* request) override {
     ++(*counters_)["on_url_request_destroyed_count"];
     EXPECT_EQ(1, (*counters_)["on_url_request_destroyed_count"]);
   }
 
@@ skipping 73 matching lines @@
   CountersMap layered_network_delegate_counters;
   TestNetworkDelegateImpl* test_network_delegate_;
   scoped_ptr<TestLayeredNetworkDelegate> layered_network_delegate_;
 };
 
 TEST_F(LayeredNetworkDelegateTest, VerifyLayeredNetworkDelegateInternal) {
   layered_network_delegate_->CallAndVerify();
 }
 
 }  // namespace net