Notify NetworkDelegate when bytes have been received 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 75 matching lines @@
 
   void OnBeforeRedirect(URLRequest* request,
                         const GURL& new_location) override {
     IncrementAndCompareCounter("on_before_redirect_count");
   }
 
   void OnResponseStarted(URLRequest* request) override {
     IncrementAndCompareCounter("on_response_started_count");
   }
 
-  void OnRawBytesRead(const URLRequest& request, int bytes_read) override {
-    IncrementAndCompareCounter("on_raw_bytes_read_count");
+  void OnNetworkBytesReceived(const URLRequest& request,
+                              int64_t bytes_received) override {
+    IncrementAndCompareCounter("on_network_bytes_received_count");
   }
 
   void OnCompleted(URLRequest* request, bool started) override {
     IncrementAndCompareCounter("on_completed_count");
   }
 
   void OnURLRequestDestroyed(URLRequest* request) override {
     IncrementAndCompareCounter("on_url_request_destroyed_count");
   }
 
@@ skipping 84 matching lines @@
                                      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);
     EXPECT_EQ(OK, OnHeadersReceived(NULL, completion_callback.callback(),
                                     response_headers.get(), NULL, NULL));
     OnResponseStarted(request.get());
-    OnRawBytesRead(*request, 0);
+    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));
     EXPECT_FALSE(OnCanGetCookies(*request, CookieList()));
     EXPECT_FALSE(OnCanSetCookie(*request, std::string(), NULL));
     EXPECT_FALSE(OnCanAccessFile(*request, base::FilePath()));
     EXPECT_FALSE(OnCanEnablePrivacyMode(GURL(), GURL()));
@@ skipping 57 matching lines @@
                                 const GURL& new_location) override {
     ++(*counters_)["on_before_redirect_count"];
     EXPECT_EQ(1, (*counters_)["on_before_redirect_count"]);
   }
 
   void OnResponseStartedInternal(URLRequest* request) override {
     ++(*counters_)["on_response_started_count"];
     EXPECT_EQ(1, (*counters_)["on_response_started_count"]);
   }
 
-  void OnRawBytesReadInternal(const URLRequest& request,
-                              int bytes_read) override {
-    ++(*counters_)["on_raw_bytes_read_count"];
-    EXPECT_EQ(1, (*counters_)["on_raw_bytes_read_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 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 75 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