Implement QuicHttpStream::GetLoadTimingInfo

net/quic/chromium/quic_chromium_client_session.cc

 // Copyright (c) 2012 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 "net/quic/chromium/quic_chromium_client_session.h"
 
 #include <openssl/ssl.h>
 
 #include <utility>
 
@@ skipping 201 matching lines @@
     QuicClock* clock,
     TransportSecurityState* transport_security_state,
     std::unique_ptr<QuicServerInfo> server_info,
     const QuicServerId& server_id,
     int yield_after_packets,
     QuicTime::Delta yield_after_duration,
     int cert_verify_flags,
     const QuicConfig& config,
     QuicCryptoClientConfig* crypto_config,
     const char* const connection_description,
+    base::TimeTicks dns_resolution_start_time,
     base::TimeTicks dns_resolution_end_time,
     QuicClientPushPromiseIndex* push_promise_index,
     base::TaskRunner* task_runner,
     std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     NetLog* net_log)
     : QuicClientSessionBase(connection, push_promise_index, config),
       server_id_(server_id),
       require_confirmation_(false),
       stream_factory_(stream_factory),
       transport_security_state_(transport_security_state),
       server_info_(std::move(server_info)),
       pkp_bypassed_(false),
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLogSourceType::QUIC_SESSION)),
-      dns_resolution_end_time_(dns_resolution_end_time),
       logger_(new QuicConnectionLogger(this,
                                        connection_description,
                                        std::move(socket_performance_watcher),
                                        net_log_)),
       going_away_(false),
       port_migration_detected_(false),
       token_binding_signatures_(kTokenBindingSignatureMapSize),
       streams_pushed_count_(0),
       streams_pushed_and_claimed_count_(0),
       migration_pending_(false),
@@ skipping 11 matching lines @@
   connection->set_creator_debug_delegate(logger_.get());
   net_log_.BeginEvent(NetLogEventType::QUIC_SESSION,
                       base::Bind(NetLogQuicClientSessionCallback, &server_id,
                                  cert_verify_flags, require_confirmation_));
   IPEndPoint address;
   if (socket && socket->GetLocalAddress(&address) == OK &&
       address.GetFamily() == ADDRESS_FAMILY_IPV6) {
     connection->SetMaxPacketLength(connection->max_packet_length() -
                                    kAdditionalOverheadForIPv6);
   }
+  connect_timing_.dns_start = dns_resolution_start_time;
+  connect_timing_.dns_end = dns_resolution_end_time;
 }
 
 QuicChromiumClientSession::~QuicChromiumClientSession() {
   if (!dynamic_streams().empty())
     RecordUnexpectedOpenStreams(DESTRUCTOR);
   if (!observers_.empty())
     RecordUnexpectedObservers(DESTRUCTOR);
   if (!going_away_)
     RecordUnexpectedNotGoingAway(DESTRUCTOR);
 
@@ skipping 334 matching lines @@
   if (!SignTokenBindingEkm(key_material, key, out))
     return ERR_FAILED;
   token_binding_signatures_.Put(raw_public_key, *out);
   return OK;
 }
 
 int QuicChromiumClientSession::CryptoConnect(
     bool require_confirmation,
     const CompletionCallback& callback) {
   require_confirmation_ = require_confirmation;
-  handshake_start_ = base::TimeTicks::Now();
+  connect_timing_.connect_start = base::TimeTicks::Now();
   RecordHandshakeState(STATE_STARTED);
   DCHECK(flow_controller());
   crypto_stream_->CryptoConnect();
 
-  if (IsCryptoHandshakeConfirmed())
+  if (IsCryptoHandshakeConfirmed()) {
+    connect_timing_.connect_end = base::TimeTicks::Now();
     return OK;
+  }
 
   // Unless we require handshake confirmation, activate the session if
   // we have established initial encryption.
   if (!require_confirmation_ && IsEncryptionEstablished())
     return OK;
 
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int QuicChromiumClientSession::ResumeCryptoConnect(
     const CompletionCallback& callback) {
-  if (IsCryptoHandshakeConfirmed())
+  if (IsCryptoHandshakeConfirmed()) {
+    connect_timing_.connect_end = base::TimeTicks::Now();
     return OK;
+  }
 
   if (!connection()->connected())
     return ERR_QUIC_HANDSHAKE_FAILED;
 
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int QuicChromiumClientSession::GetNumSentClientHellos() const {
   return crypto_stream_->num_sent_client_hellos();
@@ skipping 129 matching lines @@
   if (!callback_.is_null() &&
       (!require_confirmation_ || event == HANDSHAKE_CONFIRMED ||
        event == ENCRYPTION_REESTABLISHED)) {
     // TODO(rtenneti): Currently for all CryptoHandshakeEvent events, callback_
     // could be called because there are no error events in CryptoHandshakeEvent
     // enum. If error events are added to CryptoHandshakeEvent, then the
     // following code needs to changed.
     base::ResetAndReturn(&callback_).Run(OK);
   }
   if (event == HANDSHAKE_CONFIRMED) {
-    UMA_HISTOGRAM_TIMES("Net.QuicSession.HandshakeConfirmedTime",
-                        base::TimeTicks::Now() - handshake_start_);
+    // Update |connect_end| only when handshake is confirmed. This should also
+    // take care of any failed 0-RTT request.
+    connect_timing_.connect_end = base::TimeTicks::Now();
+    DCHECK(connect_timing_.connect_start < connect_timing_.connect_end);
+    UMA_HISTOGRAM_TIMES(
+        "Net.QuicSession.HandshakeConfirmedTime",
+        connect_timing_.connect_end - connect_timing_.connect_start);
+
     if (server_info_) {
       // TODO(rtenneti): Should we delete this histogram?
       // Track how long it has taken to finish handshake once we start waiting
       // for reading of QUIC server information from disk cache. We could use
       // this data to compare total time taken if we were to cancel the disk
       // cache read vs waiting for the read to complete.
       base::TimeTicks wait_for_data_start_time =
           server_info_->wait_for_data_start_time();
       if (!wait_for_data_start_time.is_null()) {
         UMA_HISTOGRAM_TIMES(
             "Net.QuicServerInfo.WaitForDataReady.HandshakeConfirmedTime",
             base::TimeTicks::Now() - wait_for_data_start_time);
       }
     }
     // Track how long it has taken to finish handshake after we have finished
     // DNS host resolution.
-    if (!dns_resolution_end_time_.is_null()) {
+    if (!connect_timing_.dns_end.is_null()) {
       UMA_HISTOGRAM_TIMES(
           "Net.QuicSession.HostResolution.HandshakeConfirmedTime",
-          base::TimeTicks::Now() - dns_resolution_end_time_);
+          base::TimeTicks::Now() - connect_timing_.dns_end);
     }
 
     ObserverSet::iterator it = observers_.begin();
     while (it != observers_.end()) {
       Observer* observer = *it;
       ++it;
       observer->OnCryptoHandshakeConfirmed();
     }
     if (server_info_)
       server_info_->OnExternalCacheHit();
@@ skipping 548 matching lines @@
                                id, promised_id));
 }
 
 void QuicChromiumClientSession::DeletePromised(
     QuicClientPromisedInfo* promised) {
   if (IsOpenStream(promised->id()))
     streams_pushed_and_claimed_count_++;
   QuicClientSessionBase::DeletePromised(promised);
 }
 
+const LoadTimingInfo::ConnectTiming&
+QuicChromiumClientSession::GetConnectTiming() {
+  connect_timing_.ssl_start = connect_timing_.connect_start;
+  connect_timing_.ssl_end = connect_timing_.connect_end;
+  return connect_timing_;
+}
+
 }  // namespace net