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_stream_id_(kInvalidStreamId),
       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 338 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.
+  QuicStreamId stream_id = closed_stream_id_;
+  if (stream_)
+    stream_id = stream_->id();
+  if (stream_id == kInvalidStreamId)
+    return false;
+  // First stream on a session starts at 5. Any id larger on 5 means session is
+  // reused. If session is reused, do not populate |connect_timing|.
+  // FIXME: any constant that I can use to avoid hardcoding 5?

[Ryan Hamilton, 2016/09/09 20:02:49]

kHeadersStreamId + 2.

But that being said, I think the logic of "is this reused" should probably be
implemented down in the QUIC stream layer. I'd be inclined to add a bool
IsFirstStream() or something method which does this logic.

[xunjieli, 2016/09/09 21:26:59]

Done. I added a static method to QuicChromiumClientStream. I didn't add a member
method because I need the id() to check whether |stream| creation is successful
as well. Let me know if there's a better place for the IsFirstStream(id) method.

+  if (stream_id > 5) {
+    load_timing_info->socket_reused = true;
+  } else {
+    load_timing_info->connect_timing = connect_timing_;
+    load_timing_info->socket_reused = false;
+  }
   return true;
 }
 
 void QuicHttpStream::GetSSLInfo(SSLInfo* ssl_info) {
   *ssl_info = ssl_info_;
 }
 
 void QuicHttpStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
@@ skipping 204 matching lines @@
   // TODO(rtenneti) Bug: b/28676259 - a temporary fix until we find out why
   // |session_| could be a nullptr. Delete |null_session| check and histogram if
   // session is never a nullptr.
   bool null_session = session_ == nullptr;
   if (null_session) {
     UMA_HISTOGRAM_BOOLEAN("Net.QuicHttpStream::DoStreamRequest.IsNullSession",
                           null_session);
     return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
                                     : ERR_QUIC_HANDSHAKE_FAILED;
   }
+  connect_timing_ = session_->GetConnectTiming();
   int rv = stream_request_.StartRequest(
       session_, &stream_,
       base::Bind(&QuicHttpStream::OnStreamReady, weak_factory_.GetWeakPtr()));
   if (rv == OK) {
     stream_->SetDelegate(this);
     if (request_info_->load_flags & LOAD_DISABLE_CONNECTION_MIGRATION) {
       stream_->DisableConnectionMigration();
     }
     if (response_info_) {
       next_state_ = STATE_SET_REQUEST_PRIORITY;
@@ skipping 173 matching lines @@
 
 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_stream_id_ = stream_->id();
   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