Implement QuicHttpStream::GetLoadTimingInfo

net/quic/chromium/quic_http_stream.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_http_stream.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
@@ skipping 40 matching lines @@
       request_info_(nullptr),
       request_body_stream_(nullptr),
       priority_(MINIMUM_PRIORITY),
       response_info_(nullptr),
       response_status_(OK),
       response_headers_received_(false),
       headers_bytes_received_(0),
       headers_bytes_sent_(0),
       closed_stream_received_bytes_(0),
       closed_stream_sent_bytes_(0),
+      closed_is_first_stream_(false),
       user_buffer_len_(0),
       quic_connection_error_(QUIC_NO_ERROR),
       port_migration_detected_(false),
       found_promise_(false),
       push_handle_(nullptr),
       in_loop_(false),
       weak_factory_(this) {
   DCHECK(session_);
   session_->AddObserver(this);
 }
@@ skipping 320 matching lines @@
   int64_t total_sent_bytes = headers_bytes_sent_;
   if (stream_) {
     total_sent_bytes += stream_->stream_bytes_written();
   } else {
     total_sent_bytes += closed_stream_sent_bytes_;
   }
   return total_sent_bytes;
 }
 
 bool QuicHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
-  // TODO(mmenke):  Figure out what to do here.
+  bool is_first_stream = closed_is_first_stream_;
+  if (stream_)
+    is_first_stream = stream_->IsFirstStream();
+  if (is_first_stream) {
+    load_timing_info->socket_reused = false;
+    load_timing_info->connect_timing = connect_timing_;
+  } else {
+    load_timing_info->socket_reused = true;
+  }
   return true;
 }
 
 void QuicHttpStream::GetSSLInfo(SSLInfo* ssl_info) {
   *ssl_info = ssl_info_;
 }
 
 void QuicHttpStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
@@ skipping 381 matching lines @@
   response_info_->connection_info =
       HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3;
   response_info_->vary_data.Init(*request_info_,
                                  *response_info_->headers.get());
   response_info_->was_npn_negotiated = true;
   response_info_->npn_negotiated_protocol = "quic/1+spdy/3";
   response_info_->response_time = base::Time::Now();
   response_info_->request_time = request_time_;
   response_headers_received_ = true;
 
+  // Populate |connect_timing_| when response headers are received. This should
+  // take care of 0-RTT where request is sent before handshake is confirmed.
+  connect_timing_ = session_->GetConnectTiming();
   return OK;
 }
 
 int QuicHttpStream::ReadAvailableData(IOBuffer* buf, int buf_len) {
   int rv = stream_->Read(buf, buf_len);
   // TODO(rtenneti): Temporary fix for crbug.com/585591. Added a check for null
   // |stream_| to fix crash bug. Delete |stream_| check and histogram after fix
   // is merged.
   bool null_stream = stream_ == nullptr;
   UMA_HISTOGRAM_BOOLEAN("Net.QuicReadAvailableData.NullStream", null_stream);
   if (null_stream)
     return rv;
   if (stream_->IsDoneReading()) {
     stream_->SetDelegate(nullptr);
     stream_->OnFinRead();
     ResetStream();
   }
   return rv;
 }
 
 void QuicHttpStream::ResetStream() {
   if (push_handle_) {
     push_handle_->Cancel();
     push_handle_ = nullptr;
   }
   if (!stream_)
     return;
   closed_stream_received_bytes_ = stream_->stream_bytes_read();
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
+  closed_is_first_stream_ = stream_->IsFirstStream();
   stream_ = nullptr;
 
   // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
   // read.
   if (request_body_stream_)
     request_body_stream_->Reset();
 }
 
 }  // namespace net