Notify NetworkDelegate when bytes have been received over the network.

net/base/network_delegate.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/base/network_delegate.h"
 
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ skipping 77 matching lines @@
   DCHECK(request);
   OnResponseStarted(request);
 }
 
 void NetworkDelegate::NotifyRawBytesRead(const URLRequest& request,
                                          int bytes_read) {
   DCHECK(CalledOnValidThread());
   OnRawBytesRead(request, bytes_read);
 }
 
+void NetworkDelegate::NotifyNetworkBytesReceived(const URLRequest& request,
+                                                 int64_t bytes_received) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_GT(bytes_received, 0);
+  OnNetworkBytesReceived(request, bytes_received);

[mmenke, 2015/08/18 18:33:12]

What's the difference between a raw byte read and a network byte received?  Do
we really need both methods?

[sclittle, 2015/08/18 18:49:41]

The main difficulty would be getting the delta |bytes_received| over the
network. |bytes_read| in NotifyRawBytesRead is the delta raw response bytes
read, which isn't necessarily from over the network, and IIUC doesn't include
headers or other overhead, and raw response reads and network reads aren't 1:1.

Calling URLRequest::GetTotalReceivedBytes() on every raw byte read would require
the network delegate to keep track of that value for each request and compute
the delta network bytes_received itself.

[mmenke, 2015/08/18 18:56:07]

I'm strongly opposed to having two methods for this.  Can we modify
NotifyRawBytesRead to get what we want, without modifying consumers?  I'd be
fine with adding a bool indicating if the bytes came over the network or not,
but I don't think anything cares about non-network bytes, anyways.

[sclittle, 2015/08/18 20:13:42]

From a quick code search it looks like you're right, no network delegate seems
to care about non-network bytes read in OnRawBytesRead. We could modify
NotifyRawBytesRead to notify about only network bytes, or even replace
RawBytesRead with NetworkBytesReceived.

I think adding the bool would be weird though. AIUI, RawBytesRead and
NetworkBytesReceived are different conceptually - NetworkBytesReceived counts
bytes that were received over the network, and RawBytesRead counts response body
bytes that were read from these bytes received over the network. Chrome often
receives all the bytes from the network for a request, then reads the raw bytes
from those bit by bit, so there might be 1 chunk of 9KB NetworkBytesReceived
then 3 chunks of 3KB RawBytesRead.

WDYT?

[sclittle, 2015/08/18 20:20:26]

Another alternative might just be to add an int64 |network_bytes_received|
parameter to NotifyRawBytesRead, and accept the fact that sometimes either of
|response_bytes_read| or |network_bytes_received| could be 0.

+}
+
 void NetworkDelegate::NotifyBeforeRedirect(URLRequest* request,
                                            const GURL& new_location) {
   DCHECK(CalledOnValidThread());
   DCHECK(request);
   OnBeforeRedirect(request, new_location);
 }
 
 void NetworkDelegate::NotifyCompleted(URLRequest* request, bool started) {
   DCHECK(CalledOnValidThread());
   DCHECK(request);
@@ skipping 59 matching lines @@
 bool NetworkDelegate::CancelURLRequestWithPolicyViolatingReferrerHeader(
     const URLRequest& request,
     const GURL& target_url,
     const GURL& referrer_url) const {
   DCHECK(CalledOnValidThread());
   return OnCancelURLRequestWithPolicyViolatingReferrerHeader(
       request, target_url, referrer_url);
 }
 
 }  // namespace net