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

content/browser/frame_host/navigation_handle_impl.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/frame_host/navigation_handle_impl.h"
 
 #include <utility>
 
 #include "base/debug/dump_without_crashing.h"
 #include "base/logging.h"
@@ skipping 57 matching lines @@
     : url_(url),
       has_user_gesture_(false),
       transition_(ui::PAGE_TRANSITION_LINK),
       is_external_protocol_(false),
       net_error_code_(net::OK),
       render_frame_host_(nullptr),
       is_renderer_initiated_(is_renderer_initiated),
       is_same_page_(is_same_page),
       is_srcdoc_(is_srcdoc),
       was_redirected_(false),
+      connection_info_(net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN),
       original_url_(url),
       state_(INITIAL),
       is_transferring_(false),
       frame_tree_node_(frame_tree_node),
       next_index_(0),
       navigation_start_(navigation_start),
       pending_nav_entry_id_(pending_nav_entry_id),
       request_context_type_(REQUEST_CONTEXT_TYPE_UNSPECIFIED),
       should_replace_current_entry_(false),
       is_download_(false),
@@ skipping 130 matching lines @@
 }
 
 bool NavigationHandleImpl::IsSamePage() {
   return is_same_page_;
 }
 
 const net::HttpResponseHeaders* NavigationHandleImpl::GetResponseHeaders() {
   return response_headers_.get();
 }
 
+net::HttpResponseInfo::ConnectionInfo
+NavigationHandleImpl::GetConnectionInfo() {
+  return connection_info_;

[Charlie Harrison, 2016/10/31 15:27:17]

Hm it seems strange that we will get something unknown if this method is called
before the connection info is set in this class.

I wonder if we can DCHECK that accesses here are definitely after the value is
set?

[jkarlin, 2016/10/31 16:50:06]

Thanks. I've documented the behavior in the header file.  If we want to verify
that it was set here, it'd be better to use a unique_ptr and check that it's not
nullptr. The check will fail in some tests that mock this stuff, not sure how
hard that would be to fix. Let me know what you think.

[Charlie Harrison, 2016/10/31 16:54:58]

It is unfortunate to add more things to NavigationHandle which require plumbing
through the navigation unit testing code if we want to do things "properly".
Still, this approach lgtm assuming clamy@ is fine with it.

+}
+
 bool NavigationHandleImpl::HasCommitted() {
   return state_ == DID_COMMIT || state_ == DID_COMMIT_ERROR_PAGE;
 }
 
 bool NavigationHandleImpl::IsErrorPage() {
   return state_ == DID_COMMIT_ERROR_PAGE;
 }
 
 void NavigationHandleImpl::Resume() {
   if (state_ != DEFERRING_START && state_ != DEFERRING_REDIRECT &&
@@ skipping 69 matching lines @@
 NavigationThrottle::ThrottleCheckResult
 NavigationHandleImpl::CallWillRedirectRequestForTesting(
     const GURL& new_url,
     bool new_method_is_post,
     const GURL& new_referrer_url,
     bool new_is_external_protocol) {
   NavigationThrottle::ThrottleCheckResult result = NavigationThrottle::DEFER;
   WillRedirectRequest(new_url, new_method_is_post ? "POST" : "GET",
                       new_referrer_url, new_is_external_protocol,
                       scoped_refptr<net::HttpResponseHeaders>(),
+                      net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN,
                       base::Bind(&UpdateThrottleCheckResult, &result));
 
   // Reset the callback to ensure it will not be called later.
   complete_callback_.Reset();
   return result;
 }
 
 NavigationThrottle::ThrottleCheckResult
 NavigationHandleImpl::CallWillProcessResponseForTesting(
     content::RenderFrameHost* render_frame_host,
     const std::string& raw_response_headers) {
   scoped_refptr<net::HttpResponseHeaders> headers =
       new net::HttpResponseHeaders(raw_response_headers);
   NavigationThrottle::ThrottleCheckResult result = NavigationThrottle::DEFER;
   WillProcessResponse(static_cast<RenderFrameHostImpl*>(render_frame_host),
-                      headers, SSLStatus(), GlobalRequestID(), false, false,
-                      false, base::Closure(),
+                      headers, net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN,
+                      SSLStatus(), GlobalRequestID(), false, false, false,
+                      base::Closure(),
                       base::Bind(&UpdateThrottleCheckResult, &result));
 
   // Reset the callback to ensure it will not be called later.
   complete_callback_.Reset();
   return result;
 }
 
 void NavigationHandleImpl::CallDidCommitNavigationForTesting(const GURL& url) {
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
 
@@ skipping 65 matching lines @@
   if (result != NavigationThrottle::DEFER)
     RunCompleteCallback(result);
 }
 
 void NavigationHandleImpl::WillRedirectRequest(
     const GURL& new_url,
     const std::string& new_method,
     const GURL& new_referrer_url,
     bool new_is_external_protocol,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
+    net::HttpResponseInfo::ConnectionInfo connection_info,
     const ThrottleChecksFinishedCallback& callback) {
   // Update the navigation parameters.
   url_ = new_url;
   method_ = new_method;
   sanitized_referrer_.url = new_referrer_url;
   sanitized_referrer_ = Referrer::SanitizeForRequest(url_, sanitized_referrer_);
   is_external_protocol_ = new_is_external_protocol;
   response_headers_ = response_headers;
+  connection_info_ = connection_info;
   was_redirected_ = true;
   redirect_chain_.push_back(new_url);
   if (new_method != "POST")
     resource_request_body_ = nullptr;
 
   state_ = WILL_REDIRECT_REQUEST;
   complete_callback_ = callback;
 
   // Notify each throttle of the request.
   NavigationThrottle::ThrottleCheckResult result = CheckWillRedirectRequest();
 
   // If the navigation is not deferred, run the callback.
   if (result != NavigationThrottle::DEFER)
     RunCompleteCallback(result);
 }
 
 void NavigationHandleImpl::WillProcessResponse(
     RenderFrameHostImpl* render_frame_host,
     scoped_refptr<net::HttpResponseHeaders> response_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,
     const ThrottleChecksFinishedCallback& callback) {
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
   render_frame_host_ = render_frame_host;
   response_headers_ = response_headers;
+  connection_info_ = connection_info;
   request_id_ = request_id;
   should_replace_current_entry_ = should_replace_current_entry;
   is_download_ = is_download;
   is_stream_ = is_stream;
   state_ = WILL_PROCESS_RESPONSE;
   ssl_status_ = ssl_status;
   complete_callback_ = callback;
   transfer_callback_ = transfer_callback;
 
   // Notify each throttle of the response.
@@ skipping 277 matching lines @@
                       throttles_to_register.end());
     throttles_to_register.weak_clear();
   }
 }
 
 bool NavigationHandleImpl::WasStartedFromContextMenu() const {
   return started_from_context_menu_;
 }
 
 }  // namespace content