PlzNavigate: Support ResourceTiming API

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 276 matching lines @@
   blink::WebURLResponse::WebSecurityDetails webSecurityDetails(
       WebString::fromUTF8(protocol), WebString::fromUTF8(key_exchange),
       WebString::fromUTF8(cipher), WebString::fromUTF8(mac), ssl_status.cert_id,
       sct_list);
 
   response->setSecurityDetails(webSecurityDetails);
 }
 
 }  // namespace
 
+StreamOverrideParameters::StreamOverrideParameters() {}
+StreamOverrideParameters::~StreamOverrideParameters() {}
+
 // This inner class exists since the WebURLLoader may be deleted while inside a
 // call to WebURLLoaderClient.  Refcounting is to keep the context from being
 // deleted if it may have work to do after calling into the client.
 class WebURLLoaderImpl::Context : public base::RefCounted<Context> {
  public:
   using ReceivedData = RequestPeer::ReceivedData;
 
   Context(WebURLLoaderImpl* loader,
           ResourceDispatcher* resource_dispatcher,
           mojom::URLLoaderFactory* factory);
@@ skipping 284 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,
-                              info.encoded_data_length);
+  client_->willFollowRedirect(loader_, new_request, response);
   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 20 matching lines @@
   // received on the browser side, and has been passed down to the renderer.
   if (stream_override_.get()) {
     CHECK(IsBrowserSideNavigationEnabled());
     info = stream_override_->response;
   }
 
   WebURLResponse response;
   PopulateURLResponse(request_.url(), info, &response,
                       request_.reportRawHeaders());
 
+  if (stream_override_.get()) {
+    CHECK(IsBrowserSideNavigationEnabled());
+    DCHECK(stream_override_->redirect_responses.size() ==
+           stream_override_->redirects.size());
+    for (size_t i = 0; i < stream_override_->redirects.size(); ++i) {
+      WebURLResponse previous_response;
+      // TODO(arthursonzogni) Once Devtool is supported by PlzNavigate, the
+      // |report_raw_header| argument must be checked.
+      WebURLLoaderImpl::PopulateURLResponse(
+          stream_override_->redirects[i],
+          stream_override_->redirect_responses[i],
+          &previous_response,
+          request_.reportRawHeaders());
+      response.appendRedirectResponse(previous_response);
+    }
+  }
+
   bool show_raw_listing = (GURL(request_.url()).query() == "raw");
 
   if (info.mime_type == "text/vnd.chromium.ftp-dir") {
     if (show_raw_listing) {
       // Set the MIME type to plain text to prevent any active content.
       response.setMIMEType("text/plain");
     } else {
       // We're going to produce a parsed listing in HTML.
       response.setMIMEType("text/html");
     }
@@ skipping 318 matching lines @@
       info.is_in_cache_storage
           ? blink::WebString::fromUTF8(info.cache_storage_cache_name)
           : blink::WebString());
   blink::WebVector<blink::WebString> cors_exposed_header_names(
       info.cors_exposed_header_names.size());
   std::transform(
       info.cors_exposed_header_names.begin(),
       info.cors_exposed_header_names.end(), cors_exposed_header_names.begin(),
       [](const std::string& h) { return blink::WebString::fromLatin1(h); });
   response->setCorsExposedHeaderNames(cors_exposed_header_names);
+  response->addToEncodedDataLength(info.encoded_data_length);
 
   SetSecurityStyleAndDetails(url, info, response, report_security_info);
 
   WebURLResponseExtraDataImpl* extra_data =
       new WebURLResponseExtraDataImpl(info.npn_negotiated_protocol);
   response->setExtraData(extra_data);
   extra_data->set_was_fetched_via_spdy(info.was_fetched_via_spdy);
   extra_data->set_was_npn_negotiated(info.was_npn_negotiated);
   extra_data->set_was_alternate_protocol_available(
       info.was_alternate_protocol_available);
@@ skipping 222 matching lines @@
     response->clearHTTPHeaderField(webStringName);
     while (response_headers->EnumerateHeader(&iterator, name, &value)) {
       response->addHTTPHeaderField(webStringName,
                                    WebString::fromLatin1(value));
     }
   }
   return true;
 }
 
 }  // namespace content