Notify NetworkDelegate when bytes have been received over the network.

net/url_request/url_request_job.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/url_request/url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 54 matching lines @@
                              NetworkDelegate* network_delegate)
     : request_(request),
       done_(false),
       prefilter_bytes_read_(0),
       postfilter_bytes_read_(0),
       filter_needs_more_output_space_(false),
       filtered_read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1),
       network_delegate_(network_delegate),
+      last_notified_total_received_bytes_(0),
       weak_factory_(this) {
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   if (power_monitor)
     power_monitor->AddObserver(this);
 }
 
 void URLRequestJob::SetUpload(UploadDataStream* upload) {
 }
 
 void URLRequestJob::SetExtraRequestHeaders(const HttpRequestHeaders& headers) {
@@ skipping 303 matching lines @@
   request_->response_info_.response_time = base::Time::Now();
   GetResponseInfo(&request_->response_info_);
 
   // When notifying the delegate, the delegate can release the request
   // (and thus release 'this').  After calling to the delgate, we must
   // check the request pointer to see if it still exists, and return
   // immediately if it has been destroyed.  self_preservation ensures our
   // survival until we can get out of this method.
   scoped_refptr<URLRequestJob> self_preservation(this);
 
+  MaybeNotifyNetworkBytes();
+
   if (request_)
     request_->OnHeadersComplete();
 
   GURL new_location;
   int http_status_code;
   if (IsRedirectResponse(&new_location, &http_status_code)) {
     // Redirect response bodies are not read. Notify the transaction
     // so it does not treat being stopped as an error.
     DoneReadingRedirectResponse();
 
@@ skipping 152 matching lines @@
           UMA_HISTOGRAM_BOOLEAN("Net.ErrorResponseHasContentMainFrame",
                                 page_has_content);
         } else {
           UMA_HISTOGRAM_BOOLEAN("Net.ErrorResponseHasContentNonMainFrame",
                                 page_has_content);
         }
       }
     }
   }
 
+  MaybeNotifyNetworkBytes();
+
   // Complete this notification later.  This prevents us from re-entering the
   // delegate if we're done because of a synchronous call.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&URLRequestJob::CompleteNotifyDone,
                             weak_factory_.GetWeakPtr()));
 }
 
 void URLRequestJob::CompleteNotifyDone() {
   // Check if we should notify the delegate that we're done because of an error.
   if (request_ &&
@@ skipping 277 matching lines @@
   }
 
   if (!filter_.get())
     postfilter_bytes_read_ += bytes_read;
   DVLOG(2) << __FUNCTION__ << "() "
            << "\"" << (request_ ? request_->url().spec() : "???") << "\""
            << " pre bytes read = " << bytes_read
            << " pre total = " << prefilter_bytes_read_
            << " post total = " << postfilter_bytes_read_;
   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
-  if (network_delegate_)
-    network_delegate_->NotifyRawBytesRead(*request_, bytes_read);
+
+  // Notify observers if any additional network usage has occurred. Note that
+  // the number of received bytes over the network sent by this notification
+  // could be vastly different from |bytes_read|, such as when a large chunk of
+  // network bytes is received before multiple smaller raw reads are performed
+  // on it.
+  MaybeNotifyNetworkBytes();
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 RedirectInfo URLRequestJob::ComputeRedirectInfo(const GURL& location,
@@ skipping 33 matching lines @@
 
   // Alter the referrer if redirecting cross-origin (especially HTTP->HTTPS).
   redirect_info.new_referrer =
       ComputeReferrerForRedirect(request_->referrer_policy(),
                                  request_->referrer(),
                                  redirect_info.new_url).spec();
 
   return redirect_info;
 }
 
+void URLRequestJob::MaybeNotifyNetworkBytes() {
+  if (!request_ || !network_delegate_)
+    return;
+
+  int64_t total_received_bytes = GetTotalReceivedBytes();
+  DCHECK_GE(total_received_bytes, last_notified_total_received_bytes_);
+  if (total_received_bytes > last_notified_total_received_bytes_) {
+    network_delegate_->NotifyNetworkBytesReceived(
+        *request_, total_received_bytes - last_notified_total_received_bytes_);
+  }
+  last_notified_total_received_bytes_ = total_received_bytes;
+}
+
 }  // namespace net