Render process changes for ResourceTiming sizes.

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 166 matching lines @@
       url, &mime_type, &charset, data, headers.get());
   if (result != net::OK)
     return result;
 
   info->headers = headers;
   info->mime_type.swap(mime_type);
   info->charset.swap(charset);
   info->security_info.clear();
   info->content_length = data->length();
   info->encoded_data_length = 0;
+  info->encoded_body_length = 0;
 
   return net::OK;
 }
 
 // Convert a net::SignedCertificateTimestampAndStatus object to a
 // blink::WebURLResponse::SignedCertificateTimestamp object.
 blink::WebURLResponse::SignedCertificateTimestamp NetSCTToBlinkSCT(
     const net::SignedCertificateTimestampAndStatus& sct_and_status) {
   return blink::WebURLResponse::SignedCertificateTimestamp(
       WebString::fromUTF8(net::ct::StatusToString(sct_and_status.status)),
@@ skipping 411 matching lines @@
                       request_.reportRawHeaders());
 
   WebURLRequest new_request;
   PopulateURLRequestForRedirect(
       request_, redirect_info, referrer_policy_,
       info.was_fetched_via_service_worker
           ? blink::WebURLRequest::SkipServiceWorker::None
           : blink::WebURLRequest::SkipServiceWorker::All,
       &new_request);
 
-  client_->willFollowRedirect(loader_, new_request, response);
+  client_->willFollowRedirect(loader_, new_request, response,
+                              info.encoded_data_length);
   request_ = new_request;
 
   // Only follow the redirect if WebKit left the URL unmodified.
   if (redirect_info.new_url == GURL(new_request.url())) {
     // First-party cookie logic moved from DocumentLoader in Blink to
     // net::URLRequest in the browser. Assert that Blink didn't try to change it
     // to something else.
     DCHECK_EQ(redirect_info.new_first_party_for_cookies.spec(),
               request_.firstPartyForCookies().string().utf8());
     return true;
@@ skipping 93 matching lines @@
 void WebURLLoaderImpl::Context::OnDownloadedData(int len,
                                                  int encoded_data_length) {
   if (client_)
     client_->didDownloadData(loader_, 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_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(loader_, payload, data_length, encoded_data_length);
+    client_->didReceiveData(loader_, payload, data_length, encoded_data_length,
+                            data->encoded_body_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(
@@ skipping 118 matching lines @@
       return;
   }
 
   ResourceResponseInfo info;
   std::string data;
 
   int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
 
   if (error_code == net::OK) {
     OnReceivedResponse(info);
-    if (!data.empty())
+    auto size = data.size();
+    if (size != 0)
       OnReceivedData(
-          base::WrapUnique(new FixedReceivedData(data.data(), data.size(), 0)));
+          base::WrapUnique(new FixedReceivedData(data.data(), size, 0, size)));
   }
 
   OnCompletedRequest(error_code, false, false, info.security_info,
                      base::TimeTicks::Now(), 0);
 }
 
 // WebURLLoaderImpl::RequestPeerImpl ------------------------------------------
 
 WebURLLoaderImpl::RequestPeerImpl::RequestPeerImpl(Context* context)
     : context_(context) {}
@@ skipping 244 matching lines @@
   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());
 
-  data.assign(sync_load_response.data.data(),
-              sync_load_response.data.size());
+  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());
 
   context_->set_client(client);
   context_->Start(request, NULL);
@@ skipping 61 matching lines @@
     response->clearHTTPHeaderField(webStringName);
     while (response_headers->EnumerateHeader(&iterator, name, &value)) {
       response->addHTTPHeaderField(webStringName,
                                    WebString::fromLatin1(value));
     }
   }
   return true;
 }
 
 }  // namespace content