Dispatch encoded_data_length separately in content/child

content/child/web_url_loader_impl.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 367 matching lines @@
              SyncLoadResponse* sync_load_response);
   void SetTaskRunner(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 
   void OnUploadProgress(uint64_t position, uint64_t size);
   bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
                           const ResourceResponseInfo& info);
   void OnReceivedResponse(const ResourceResponseInfo& info);
   void OnDownloadedData(int len, int encoded_data_length);
   void OnReceivedData(std::unique_ptr<ReceivedData> data);
+  void OnTransferSizeUpdated(int transfer_size_diff);
   void OnReceivedCachedMetadata(const char* data, int len);
   void OnCompletedRequest(int error_code,
                           bool was_ignored_by_handler,
                           bool stale_copy_in_cache,
                           const base::TimeTicks& completion_time,
                           int64_t total_transfer_size,
                           int64_t encoded_body_size);
 
  private:
   friend class base::RefCounted<Context>;
@@ skipping 29 matching lines @@
  public:
   explicit RequestPeerImpl(Context* context);
 
   // RequestPeer methods:
   void OnUploadProgress(uint64_t position, uint64_t size) override;
   bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
                           const ResourceResponseInfo& info) override;
   void OnReceivedResponse(const ResourceResponseInfo& info) override;
   void OnDownloadedData(int len, int encoded_data_length) override;
   void OnReceivedData(std::unique_ptr<ReceivedData> data) override;
+  void OnTransferSizeUpdated(int transfer_size_diff) override;
   void OnReceivedCachedMetadata(const char* data, int len) override;
   void OnCompletedRequest(int error_code,
                           bool was_ignored_by_handler,
                           bool stale_copy_in_cache,
                           const base::TimeTicks& completion_time,
                           int64_t total_transfer_size,
                           int64_t encoded_body_size) override;
 
  private:
   scoped_refptr<Context> context_;
@@ skipping 346 matching lines @@
 void WebURLLoaderImpl::Context::OnDownloadedData(int len,
                                                  int encoded_data_length) {
   if (client_)
     client_->didDownloadData(len, encoded_data_length);
 }
 
 void WebURLLoaderImpl::Context::OnReceivedData(
     std::unique_ptr<ReceivedData> data) {
   const char* payload = data->payload();
   int data_length = data->length();
-  int encoded_data_length = data->encoded_data_length();
   if (!client_)
     return;
 
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedData",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   if (ftp_listing_delegate_) {
     // The FTP listing delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.
     ftp_listing_delegate_->OnReceivedData(payload, data_length);
   } else {
     // We dispatch the data even when |useStreamOnResponse()| is set, in order
     // to make Devtools work.
-    client_->didReceiveData(payload, data_length, encoded_data_length);
+    client_->didReceiveData(payload, data_length);
 
     if (request_.useStreamOnResponse()) {
       // We don't support ftp_listening_delegate_ for now.
       // TODO(yhirano): Support ftp listening.
       body_stream_writer_->AddData(std::move(data));
     }
   }
 }
 
+void WebURLLoaderImpl::Context::OnTransferSizeUpdated(int transfer_size_diff) {
+  client_->didReceiveTransferSizeUpdate(transfer_size_diff);
+}
+
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (!client_)
     return;
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedCachedMetadata",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
   client_->didReceiveCachedMetadata(data, len);
 }
 
@@ skipping 109 matching lines @@
 
   ResourceResponseInfo info;
   std::string data;
 
   int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
 
   if (error_code == net::OK) {
     OnReceivedResponse(info);
     auto size = data.size();
     if (size != 0)
-      OnReceivedData(base::MakeUnique<FixedReceivedData>(data.data(), size, 0));
+      OnReceivedData(base::MakeUnique<FixedReceivedData>(data.data(), size));
   }
 
   OnCompletedRequest(error_code, false, false, base::TimeTicks::Now(), 0,
                      data.size());
 }
 
 // WebURLLoaderImpl::RequestPeerImpl ------------------------------------------
 
 WebURLLoaderImpl::RequestPeerImpl::RequestPeerImpl(Context* context)
     : context_(context) {}
@@ skipping 18 matching lines @@
     int len,
     int encoded_data_length) {
   context_->OnDownloadedData(len, encoded_data_length);
 }
 
 void WebURLLoaderImpl::RequestPeerImpl::OnReceivedData(
     std::unique_ptr<ReceivedData> data) {
   context_->OnReceivedData(std::move(data));
 }
 
+void WebURLLoaderImpl::RequestPeerImpl::OnTransferSizeUpdated(
+    int transfer_size_diff) {
+  context_->OnTransferSizeUpdated(transfer_size_diff);
+}
+
 void WebURLLoaderImpl::RequestPeerImpl::OnReceivedCachedMetadata(
     const char* data,
     int len) {
   context_->OnReceivedCachedMetadata(data, len);
 }
 
 void WebURLLoaderImpl::RequestPeerImpl::OnCompletedRequest(
     int error_code,
     bool was_ignored_by_handler,
     bool stale_copy_in_cache,
@@ skipping 244 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 void WebURLLoaderImpl::setLoadingTaskRunner(
     base::SingleThreadTaskRunner* loading_task_runner) {
   context_->SetTaskRunner(loading_task_runner);
 }
 
 }  // namespace content