Call MaybeNotifyNetworkBytes() in NotifyStartError().

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 539 matching lines @@
 
 void URLRequestJob::NotifyStartError(const URLRequestStatus &status) {
   DCHECK(!has_handled_response_);
   DCHECK(request_->status().is_io_pending());
 
   has_handled_response_ = true;
   // There may be relevant information in the response info even in the
   // error case.
   GetResponseInfo(&request_->response_info_);
 
+  MaybeNotifyNetworkBytes();
+
   request_->NotifyResponseStarted(status);
   // |this| may have been deleted here.
 }
 
 void URLRequestJob::NotifyDone(const URLRequestStatus &status) {
   DCHECK(!done_) << "Job sending done notification twice";
   if (done_)
     return;
   done_ = true;
 
   // Unless there was an error, we should have at least tried to handle
   // the response before getting here.
   DCHECK(has_handled_response_ || !status.is_success());
 
   request_->set_is_pending(false);
   // With async IO, it's quite possible to have a few outstanding
   // requests.  We could receive a request to Cancel, followed shortly
   // by a successful IO.  For tracking the status(), once there is
   // an error, we do not change the status back to success.  To
   // enforce this, only set the status if the job is so far
   // successful.
   if (request_->status().is_success()) {
     if (status.status() == URLRequestStatus::FAILED)
       request_->net_log().AddEventWithNetErrorCode(NetLogEventType::FAILED,
                                                    status.error());
     request_->set_status(status);
   }
 
-  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_->status().is_success()) {
@@ skipping 59 matching lines @@
 void URLRequestJob::SourceStreamReadComplete(bool synchronous, int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
 
   if (result > 0 && request()->net_log().IsCapturing()) {
     request()->net_log().AddByteTransferEvent(
         NetLogEventType::URL_REQUEST_JOB_FILTERED_BYTES_READ, result,
         pending_read_buffer_->data());
   }
   pending_read_buffer_ = nullptr;
 
+  MaybeNotifyNetworkBytes();

[mmenke, 2016/11/03 19:07:01]

Not needed, we already call this in ReadRawDataComplete.

[Not at Google. Contact bengr, 2016/11/04 00:08:12]

Done.

+
   if (result < 0) {
     NotifyDone(URLRequestStatus::FromError(result));
     return;
   }
 
   if (result > 0) {
     postfilter_bytes_read_ += result;
     if (!synchronous)
       request_->NotifyReadCompleted(result);
     return;
@@ skipping 23 matching lines @@
     // If the read completes synchronously, either success or failure, invoke
     // GatherRawReadStats so we can account for the completed read.
     GatherRawReadStats(result);
   } else {
     read_raw_callback_ = callback;
   }
   return result;
 }
 
 void URLRequestJob::FollowRedirect(const RedirectInfo& redirect_info) {
+  MaybeNotifyNetworkBytes();

[mmenke, 2016/11/03 19:07:01]

This is a weird place to call this - presumably we called this when we parsed
the redirect header.

[Not at Google. Contact bengr, 2016/11/04 00:08:12]

Done.

+
   int rv = request_->Redirect(redirect_info);
   if (rv != OK)
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 void URLRequestJob::GatherRawReadStats(int bytes_read) {
   DCHECK(raw_read_buffer_ || bytes_read == 0);
   DCHECK_NE(ERR_IO_PENDING, bytes_read);
 
   if (bytes_read > 0) {
@@ skipping 94 matching lines @@
   include_referer = base::ToLowerASCII(include_referer);
   if (include_referer == "true" &&
       request_->ssl_info().token_binding_negotiated) {
     redirect_info.referred_token_binding_host = url.host();
   }
 
   return redirect_info;
 }
 
 void URLRequestJob::MaybeNotifyNetworkBytes() {
+  DCHECK(request_->is_pending());
+
   if (!network_delegate_)
     return;
 
   // Report any new received bytes.
   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;
 
   // Report any new sent bytes.
   int64_t total_sent_bytes = GetTotalSentBytes();
   DCHECK_GE(total_sent_bytes, last_notified_total_sent_bytes_);
   if (total_sent_bytes > last_notified_total_sent_bytes_) {
     network_delegate_->NotifyNetworkBytesSent(
         request_, total_sent_bytes - last_notified_total_sent_bytes_);
   }
   last_notified_total_sent_bytes_ = total_sent_bytes;
 }
 
 }  // namespace net