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

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 372 matching lines @@
   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 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 total_transfer_size,
+                          int64_t encoded_body_size);
 
  private:
   friend class base::RefCounted<Context>;
   ~Context();
 
   // Called when the body data stream is detached from the reader side.
   void CancelBodyStreaming();
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURLRequestLocally() const;
   void HandleDataURL();
@@ skipping 27 matching lines @@
   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 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) override;
+                          int64_t total_transfer_size,
+                          int64_t encoded_body_size) override;
 
  private:
   scoped_refptr<Context> context_;
   DISALLOW_COPY_AND_ASSIGN(RequestPeerImpl);
 };
 
 // WebURLLoaderImpl::Context --------------------------------------------------
 
 WebURLLoaderImpl::Context::Context(WebURLLoaderImpl* loader,
                                    ResourceDispatcher* resource_dispatcher,
@@ skipping 354 matching lines @@
       "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(loader_, payload, data_length, encoded_data_length,
-                            data->encoded_body_length());
+    client_->didReceiveData(loader_, payload, data_length, encoded_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::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(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::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 total_transfer_size,
+    int64_t encoded_body_size) {
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   }
 
   if (body_stream_writer_ && error_code != net::OK)
     body_stream_writer_->Fail();
   body_stream_writer_.reset();
 
   if (client_) {
     TRACE_EVENT_WITH_FLOW0(
         "loading", "WebURLLoaderImpl::Context::OnCompletedRequest",
         this, TRACE_EVENT_FLAG_FLOW_IN);
 
     if (error_code != net::OK) {
       client_->didFail(loader_,
                        CreateWebURLError(request_.url(), stale_copy_in_cache,
                                          error_code, was_ignored_by_handler),
-                       total_transfer_size);
+                       total_transfer_size, encoded_body_size);
     } else {
       client_->didFinishLoading(loader_,
                                 (completion_time - TimeTicks()).InSecondsF(),
-                                total_transfer_size);
+                                total_transfer_size, encoded_body_size);
     }
   }
 }
 
 WebURLLoaderImpl::Context::~Context() {
   // We must be already cancelled at this point.
   DCHECK_LT(request_id_, 0);
 }
 
 void WebURLLoaderImpl::Context::CancelBodyStreaming() {
   scoped_refptr<Context> protect(this);
 
   // Notify renderer clients that the request is canceled.
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   }
 
   if (body_stream_writer_) {
     body_stream_writer_->Fail();
     body_stream_writer_.reset();
   }
   if (client_) {
     // TODO(yhirano): Set |stale_copy_in_cache| appropriately if possible.
     client_->didFail(loader_,
                      CreateWebURLError(request_.url(), false, net::ERR_ABORTED),
-                     WebURLLoaderClient::kUnknownEncodedDataLength);
+                     WebURLLoaderClient::kUnknownEncodedDataLength, 0);
   }
 
   // Notify the browser process that the request is canceled.
   Cancel();
 }
 
 bool WebURLLoaderImpl::Context::CanHandleDataURLRequestLocally() const {
   GURL url = request_.url();
   if (!url.SchemeIs(url::kDataScheme))
     return false;
@@ skipping 45 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, size));
+      OnReceivedData(base::MakeUnique<FixedReceivedData>(data.data(), size, 0));
   }
 
-  OnCompletedRequest(error_code, false, false, base::TimeTicks::Now(), 0);
+  OnCompletedRequest(error_code, false, false, base::TimeTicks::Now(), 0,
+                     data.size());
 }
 
 // WebURLLoaderImpl::RequestPeerImpl ------------------------------------------
 
 WebURLLoaderImpl::RequestPeerImpl::RequestPeerImpl(Context* context)
     : context_(context) {}
 
 void WebURLLoaderImpl::RequestPeerImpl::OnUploadProgress(uint64_t position,
                                                          uint64_t size) {
   context_->OnUploadProgress(position, size);
@@ skipping 25 matching lines @@
     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,
     const base::TimeTicks& completion_time,
-    int64_t total_transfer_size) {
+    int64_t total_transfer_size,
+    int64_t encoded_body_size) {
   context_->OnCompletedRequest(error_code, was_ignored_by_handler,
                                stale_copy_in_cache, completion_time,
-                               total_transfer_size);
+                               total_transfer_size, encoded_body_size);
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
 
 WebURLLoaderImpl::WebURLLoaderImpl(ResourceDispatcher* resource_dispatcher,
                                    mojom::URLLoaderFactory* url_loader_factory,
                                    mojo::AssociatedGroup* associated_group)
     : context_(new Context(this,
                            resource_dispatcher,
                            url_loader_factory,
@@ skipping 172 matching lines @@
   new_request.setHTTPMethod(WebString::fromUTF8(redirect_info.new_method));
   if (redirect_info.new_method == old_method)
     new_request.setHTTPBody(request.httpBody());
   return new_request;
 }
 
 void WebURLLoaderImpl::loadSynchronously(const WebURLRequest& request,
                                          WebURLResponse& response,
                                          WebURLError& error,
                                          WebData& data,
-                                         int64_t& encoded_data_length) {
+                                         int64_t& encoded_data_length,
+                                         int64_t& encoded_body_length) {
   TRACE_EVENT0("loading", "WebURLLoaderImpl::loadSynchronously");
   SyncLoadResponse sync_load_response;
   context_->Start(request, &sync_load_response);
 
   const GURL& final_url = sync_load_response.url;
 
   // TODO(tc): For file loads, we may want to include a more descriptive
   // status code or status text.
   int error_code = sync_load_response.error_code;
   if (error_code != net::OK) {
     response.setURL(final_url);
     error.domain = WebString::fromUTF8(net::kErrorDomain);
     error.reason = error_code;
     error.unreachableURL = final_url;
     return;
   }
 
   PopulateURLResponse(final_url, sync_load_response, &response,
                       request.reportRawHeaders());
-  response.addToEncodedBodyLength(sync_load_response.encoded_body_length);
   response.addToDecodedBodyLength(sync_load_response.data.size());
   encoded_data_length = sync_load_response.encoded_data_length;
+  encoded_body_length = sync_load_response.encoded_body_length;
 
   data.assign(sync_load_response.data.data(), sync_load_response.data.size());
 }
 
 void WebURLLoaderImpl::loadAsynchronously(const WebURLRequest& request,
                                           WebURLLoaderClient* client) {
   TRACE_EVENT_WITH_FLOW0("loading", "WebURLLoaderImpl::loadAsynchronously",
                          this, TRACE_EVENT_FLAG_FLOW_OUT);
   DCHECK(!context_->client());
 
@@ skipping 13 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