[PageLoadMetrics] Create page load timing metrics for H2/QUIC/H1 pages

content/browser/loader/navigation_resource_throttle.cc

 // Copyright 2015 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/browser/loader/navigation_resource_throttle.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 105 matching lines @@
 }
 
 void CheckWillRedirectRequestOnUIThread(
     UIChecksPerformedCallback callback,
     int render_process_id,
     int render_frame_host_id,
     const GURL& new_url,
     const std::string& new_method,
     const GURL& new_referrer_url,
     bool new_is_external_protocol,
-    scoped_refptr<net::HttpResponseHeaders> headers) {
+    scoped_refptr<net::HttpResponseHeaders> headers,
+    net::HttpResponseInfo::ConnectionInfo connection_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NavigationHandleImpl* navigation_handle =
       FindNavigationHandle(render_process_id, render_frame_host_id, callback);
   if (!navigation_handle)
     return;
 
   GURL new_validated_url(new_url);
   RenderProcessHost::FromID(render_process_id)
       ->FilterURL(false, &new_validated_url);
   navigation_handle->WillRedirectRequest(
       new_validated_url, new_method, new_referrer_url, new_is_external_protocol,
-      headers, base::Bind(&SendCheckResultToIOThread, callback));
+      headers, connection_info,
+      base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 void WillProcessResponseOnUIThread(
     UIChecksPerformedCallback callback,
     int render_process_id,
     int render_frame_host_id,
     scoped_refptr<net::HttpResponseHeaders> headers,
+    net::HttpResponseInfo::ConnectionInfo connection_info,
     const SSLStatus& ssl_status,
     const GlobalRequestID& request_id,
     bool should_replace_current_entry,
     bool is_download,
     bool is_stream,
     const base::Closure& transfer_callback,
     std::unique_ptr<NavigationData> navigation_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (g_force_transfer) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, transfer_callback);
   }
 
   NavigationHandleImpl* navigation_handle =
       FindNavigationHandle(render_process_id, render_frame_host_id, callback);
   if (!navigation_handle)
     return;
 
   if (navigation_data)
     navigation_handle->set_navigation_data(std::move(navigation_data));
 
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
   DCHECK(render_frame_host);
   navigation_handle->WillProcessResponse(
-      render_frame_host, headers, ssl_status, request_id,
+      render_frame_host, headers, connection_info, ssl_status, request_id,
       should_replace_current_entry, is_download, is_stream, transfer_callback,
       base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 }  // namespace
 
 NavigationResourceThrottle::NavigationResourceThrottle(
     net::URLRequest* request,
     ResourceDispatcherHostDelegate* resource_dispatcher_host_delegate,
     RequestContextType request_context_type)
@@ skipping 67 matching lines @@
   if (request_->response_headers()) {
     response_headers = new net::HttpResponseHeaders(
         request_->response_headers()->raw_headers());
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CheckWillRedirectRequestOnUIThread, callback,
                  render_process_id, render_frame_id, redirect_info.new_url,
                  redirect_info.new_method, GURL(redirect_info.new_referrer),
-                 new_is_external_protocol, response_headers));
+                 new_is_external_protocol, response_headers,
+                 request_->response_info().connection_info));
   *defer = true;
 }
 
 void NavigationResourceThrottle::WillProcessResponse(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   if (!info)
     return;
 
@@ skipping 29 matching lines @@
 
   SSLStatus ssl_status;
   if (request_->ssl_info().cert.get()) {
     NavigationResourceHandler::GetSSLStatusForRequest(
         request_->url(), request_->ssl_info(), info->GetChildID(), &ssl_status);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WillProcessResponseOnUIThread, callback, render_process_id,
-                 render_frame_id, response_headers, ssl_status,
+                 render_frame_id, response_headers,
+                 request_->response_info().connection_info, ssl_status,
                  info->GetGlobalRequestID(),
                  info->should_replace_current_entry(), info->IsDownload(),
                  info->is_stream(), transfer_callback,
                  base::Passed(&cloned_data)));
   *defer = true;
 }
 
 const char* NavigationResourceThrottle::GetNameForLogging() const {
   return "NavigationResourceThrottle";
 }
@@ skipping 46 matching lines @@
 
   // If the results of the checks on the UI thread are known, unblock the
   // navigation. Otherwise, wait until the callback has executed.
   if (on_transfer_done_result_ != NavigationThrottle::DEFER) {
     OnUIChecksPerformed(on_transfer_done_result_);
     on_transfer_done_result_ = NavigationThrottle::DEFER;
   }
 }
 
 }  // namespace content