Dispatch transfer size update notification on mojo-loading

content/browser/loader/mojo_async_resource_handler.cc

 // Copyright 2016 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 "content/browser/loader/mojo_async_resource_handler.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
@@ skipping 126 matching lines @@
   // Unlike OnResponseStarted, OnRequestRedirected will NOT be preceded by
   // OnWillRead.
   DCHECK(!shared_writer_);
 
   *defer = true;
   request()->LogBlockedBy("MojoAsyncResourceHandler");
   did_defer_on_redirect_ = true;
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->GetTotalReceivedBytes();
+  reported_total_received_bytes_ = 0;

[mmenke, 2016/12/13 20:01:25]

This isn't doing anything - we don't call OnResponseStarted until after all
redirects.

[yhirano, 2016/12/14 16:47:27]

Done.

   response->head.request_start = request()->creation_time();
   response->head.response_start = base::TimeTicks::Now();
   // TODO(davidben): Is it necessary to pass the new first party URL for
   // cookies? The only case where it can change is top-level navigation requests
   // and hopefully those will eventually all be owned by the browser. It's
   // possible this is still needed while renderer-owned ones exist.
   url_loader_client_->OnReceiveRedirect(redirect_info, response->head);
   return true;
 }
 
 bool MojoAsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
                                                  bool* defer) {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(request(), info->GetContext(),
                                         response);
   }
 
   NetLogObserver::PopulateResponseInfo(request(), response);
+  response->head.encoded_data_length = request()->raw_header_size();
+  reported_total_received_bytes_ = response->head.encoded_data_length;

[mmenke, 2016/12/13 20:01:25]

Looks like the old API didn't filter these out.  Is this a bug fix, or just a
modified API?

[yhirano, 2016/12/14 16:47:27]

AsyncResourceHandler has a special handling in OnReadCompleted:

if (!first_chunk_read_)
  encoded_data_length -= request()->raw_header_size();

But OnDataDownloaded doesn't have it and notifies a wrong value. Yes, I think
it's a bug and this is a bug-fix.

 
   response->head.request_start = request()->creation_time();
   response->head.response_start = base::TimeTicks::Now();
   sent_received_response_message_ = true;
 
   mojom::DownloadedTempFilePtr downloaded_file_ptr;
   if (!response->head.download_file_path.empty()) {
     downloaded_file_ptr = DownloadedTempFileImpl::Create(info->GetChildID(),
                                                          info->GetRequestID());
     rdh_->RegisterDownloadedTempFile(info->GetChildID(), info->GetRequestID(),
@@ skipping 61 matching lines @@
   return true;
 }
 
 bool MojoAsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
   DCHECK_GE(bytes_read, 0);
   DCHECK(buffer_);
 
   if (!bytes_read)
     return true;
 
+  const ResourceRequestInfoImpl* info = GetRequestInfo();
+  if (info->ShouldReportRawHeaders()) {
+    auto transfer_size_diff = CalculateTransferSizeDiff();
+    if (transfer_size_diff > 0)
+      url_loader_client_->OnTransferSizeUpdated(transfer_size_diff);
+  }
+
   if (is_using_io_buffer_not_from_writer_) {
     // Couldn't allocate a buffer on the data pipe in OnWillRead.
     DCHECK_EQ(0u, buffer_bytes_read_);
     buffer_bytes_read_ = bytes_read;
     if (!CopyReadDataToDataPipe(defer))
       return false;
     if (*defer) {
       request()->LogBlockedBy("MojoAsyncResourceHandler");
       did_defer_on_writing_ = true;
     }
     return true;
   }
 
   if (EndWrite(bytes_read) != MOJO_RESULT_OK)
     return false;
   // Allocate a buffer for the next OnWillRead call here, because OnWillRead
   // doesn't have |defer| parameter.
   if (!AllocateWriterIOBuffer(&buffer_, defer))
     return false;
   if (*defer) {
     request()->LogBlockedBy("MojoAsyncResourceHandler");
     did_defer_on_writing_ = true;
   }
   return true;
 }
 
 void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
-  int64_t total_received_bytes = request()->GetTotalReceivedBytes();
-  int64_t bytes_to_report =
-      total_received_bytes - reported_total_received_bytes_;
-  reported_total_received_bytes_ = total_received_bytes;
-  DCHECK_LE(0, bytes_to_report);
-
-  url_loader_client_->OnDataDownloaded(bytes_downloaded, bytes_to_report);
+  url_loader_client_->OnDataDownloaded(bytes_downloaded,
+                                       CalculateTransferSizeDiff());
 }
 
 void MojoAsyncResourceHandler::FollowRedirect() {
   if (!request()->status().is_success()) {
     DVLOG(1) << "FollowRedirect for invalid request";
     return;
   }
   if (!did_defer_on_redirect_) {
     DVLOG(1) << "Malformed FollowRedirect request";
     ReportBadMessage("Malformed FollowRedirect request");
@@ skipping 151 matching lines @@
   request()->LogUnblocked();
   controller()->Resume();
 }
 
 void MojoAsyncResourceHandler::Cancel() {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   ResourceDispatcherHostImpl::Get()->CancelRequestFromRenderer(
       GlobalRequestID(info->GetChildID(), info->GetRequestID()));
 }
 
+int64_t MojoAsyncResourceHandler::CalculateTransferSizeDiff() {
+  int64_t total_received_bytes = request()->GetTotalReceivedBytes();
+  int64_t bytes_to_report =
+      total_received_bytes - reported_total_received_bytes_;
+  reported_total_received_bytes_ = total_received_bytes;
+  DCHECK_LE(0, bytes_to_report);
+  return bytes_to_report;
+}
+
 void MojoAsyncResourceHandler::ReportBadMessage(const std::string& error) {
   mojo::ReportBadMessage(error);
 }
 
 void MojoAsyncResourceHandler::OnTransfer(
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   binding_.Unbind();
   binding_.Bind(std::move(mojo_request));
   binding_.set_connection_error_handler(
       base::Bind(&MojoAsyncResourceHandler::Cancel, base::Unretained(this)));
   url_loader_client_ = std::move(url_loader_client);
 }
 
 }  // namespace content