Send encoded_body_length to renderer when response completed (2/3)

content/child/resource_dispatcher.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include <utility>
 
@@ skipping 309 matching lines @@
   // Check whether this response data is compliant with our cross-site
   // document blocking policy. We only do this for the first chunk of data.
   if (request_info->site_isolation_metadata.get()) {
     SiteIsolationStatsGatherer::OnReceivedFirstChunk(
         request_info->site_isolation_metadata, data.data(), data.size());
     request_info->site_isolation_metadata.reset();
   }
 
   DCHECK(!request_info->buffer.get());
 
-  std::unique_ptr<RequestPeer::ReceivedData> received_data(
-      new content::FixedReceivedData(data, encoded_data_length,
-                                     encoded_body_length));
-  request_info->peer->OnReceivedData(std::move(received_data));
+  request_info->peer->OnReceivedData(
+      base::MakeUnique<content::FixedReceivedData>(data, encoded_data_length));
 }
 
 void ResourceDispatcher::OnReceivedData(int request_id,
                                         int data_offset,
                                         int data_length,
                                         int encoded_data_length,
                                         int encoded_body_length) {
   TRACE_EVENT0("loader", "ResourceDispatcher::OnReceivedData");
   DCHECK_GT(data_length, 0);
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   bool send_ack = true;
   if (request_info && data_length > 0) {
     CHECK(base::SharedMemory::IsHandleValid(request_info->buffer->handle()));
     CHECK_GE(request_info->buffer_size, data_offset + data_length);
 
     const char* data_start = static_cast<char*>(request_info->buffer->memory());
     CHECK(data_start);
     CHECK(data_start + data_offset);
     const char* data_ptr = data_start + data_offset;
 
     // Check whether this response data is compliant with our cross-site
     // document blocking policy. We only do this for the first chunk of data.
     if (request_info->site_isolation_metadata.get()) {
       SiteIsolationStatsGatherer::OnReceivedFirstChunk(
           request_info->site_isolation_metadata, data_ptr, data_length);
       request_info->site_isolation_metadata.reset();
     }
 
     std::unique_ptr<RequestPeer::ReceivedData> data =
-        request_info->received_data_factory->Create(
-            data_offset, data_length, encoded_data_length, encoded_body_length);
+        request_info->received_data_factory->Create(data_offset, data_length,
+                                                    encoded_data_length);
     // |data| takes care of ACKing.
     send_ack = false;
     request_info->peer->OnReceivedData(std::move(data));
   }
 
   // Acknowledge the reception of this data.
   if (send_ack)
     message_sender_->Send(new ResourceHostMsg_DataReceived_ACK(request_id));
 }
 
@@ skipping 84 matching lines @@
   // The request ID will be removed from our pending list in the destructor.
   // Normally, dispatching this message causes the reference-counted request to
   // die immediately.
   // TODO(kinuko): Revisit here. This probably needs to call request_info->peer
   // but the past attempt to change it seems to have caused crashes.
   // (crbug.com/547047)
   peer->OnCompletedRequest(request_complete_data.error_code,
                            request_complete_data.was_ignored_by_handler,
                            request_complete_data.exists_in_cache,
                            renderer_completion_time,
-                           request_complete_data.encoded_data_length);
+                           request_complete_data.encoded_data_length,
+                           request_complete_data.encoded_body_length);
 }
 
 bool ResourceDispatcher::RemovePendingRequest(int request_id) {
   PendingRequestMap::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())
     return false;
 
   PendingRequestInfo* request_info = it->second.get();
 
   bool release_downloaded_file = request_info->download_to_file;
@@ skipping 371 matching lines @@
     delete message;
   }
 }
 
 void ResourceDispatcher::SetResourceSchedulingFilter(
     scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter) {
   resource_scheduling_filter_ = resource_scheduling_filter;
 }
 
 }  // namespace content