Enabled actual transfer size in chromium

content/common/resource_dispatcher.cc

 // Copyright (c) 2011 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/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 194 matching lines @@
     return;
   }
 
   response->status = result.status;
   response->url = result.final_url;
   response->headers = result.headers;
   response->mime_type = result.mime_type;
   response->charset = result.charset;
   response->request_time = result.request_time;
   response->response_time = result.response_time;
+  response->raw_data_length = result.raw_data_length;
   response->connection_id = result.connection_id;
   response->connection_reused = result.connection_reused;
   response->load_timing = result.load_timing;
   response->devtools_info = result.devtools_info;
   response->data.swap(result.data);
   response->download_file_path = result.download_file_path;
 }
 
 }  // namespace webkit_glue
 
@@ skipping 104 matching lines @@
   if (!request_info)
     return;
 
   if (data.size())
     request_info->peer->OnReceivedCachedMetadata(&data.front(), data.size());
 }
 
 void ResourceDispatcher::OnReceivedData(const IPC::Message& message,
                                         int request_id,
                                         base::SharedMemoryHandle shm_handle,
-                                        int data_len) {
+                                        int data_len,
+                                        int raw_data_length) {
   // Acknowledge the reception of this data.
   message_sender()->Send(
       new ResourceHostMsg_DataReceived_ACK(message.routing_id(), request_id));
 
   const bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
   DCHECK((shm_valid && data_len > 0) || (!shm_valid && !data_len));
   base::SharedMemory shared_mem(shm_handle, true);  // read only
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   if (data_len > 0 && shared_mem.Map(data_len)) {
     const char* data = static_cast<char*>(shared_mem.memory());
-    request_info->peer->OnReceivedData(data, data_len);
+    request_info->peer->OnReceivedData(data, data_len, raw_data_length);
   }
 }
 
 void ResourceDispatcher::OnDownloadedData(const IPC::Message& message,
                                           int request_id,
                                           int data_len) {
   // Acknowledge the reception of this message.
   message_sender()->Send(
       new ResourceHostMsg_DataDownloaded_ACK(message.routing_id(), request_id));
 
@@ skipping 219 matching lines @@
 
 // static
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }