Implement QuicHttpStream::GetLoadTimingInfo

net/quic/chromium/quic_http_stream_test.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 <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 300 matching lines @@
     session_.reset(new QuicChromiumClientSession(
         connection_, std::move(socket),
         /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
         &transport_security_state_,
         base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
         QuicServerId(kDefaultServerHostName, kDefaultServerPort,
                      PRIVACY_MODE_DISABLED),
         kQuicYieldAfterPacketsRead,
         QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
         /*cert_verify_flags=*/0, DefaultQuicConfig(), &crypto_config_,
-        "CONNECTION_UNKNOWN", base::TimeTicks::Now(), &push_promise_index_,
-        base::ThreadTaskRunnerHandle::Get().get(),
+        "CONNECTION_UNKNOWN", base::TimeTicks::Now(), base::TimeTicks::Now(),
+        &push_promise_index_, base::ThreadTaskRunnerHandle::Get().get(),
         /*socket_performance_watcher=*/nullptr, net_log_.bound().net_log()));
     session_->Initialize();
     session_->GetCryptoStream()->CryptoConnect();
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_
                       ? new AutoClosingStream(session_->GetWeakPtr())
                       : new QuicHttpStream(session_->GetWeakPtr()));
 
     promised_stream_.reset(use_closing_stream_
                                ? new AutoClosingStream(session_->GetWeakPtr())
@@ skipping 59 matching lines @@
                                     should_include_version, fin, offset, data,
                                     &server_maker_);
   }
 
   std::unique_ptr<QuicReceivedPacket> InnerConstructRequestHeadersPacket(
       QuicPacketNumber packet_number,
       QuicStreamId stream_id,
       bool should_include_version,
       bool fin,
       RequestPriority request_priority,
-      size_t* spdy_headers_frame_length) {
+      size_t* spdy_headers_frame_length,
+      QuicStreamOffset* offset) {
     SpdyPriority priority =
         ConvertRequestPriorityToQuicPriority(request_priority);
     return client_maker_.MakeRequestHeadersPacket(
         packet_number, stream_id, should_include_version, fin, priority,
-        std::move(request_headers_), spdy_headers_frame_length);
+        std::move(request_headers_), spdy_headers_frame_length, offset);
   }
 
   std::unique_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
       QuicPacketNumber packet_number,
       bool fin,
       RequestPriority request_priority,
       size_t* spdy_headers_frame_length) {
     return InnerConstructRequestHeadersPacket(
         packet_number, stream_id_, kIncludeVersion, fin, request_priority,
-        spdy_headers_frame_length);
+        spdy_headers_frame_length, nullptr);
   }
 
   std::unique_ptr<QuicReceivedPacket> InnerConstructResponseHeadersPacket(
       QuicPacketNumber packet_number,
       QuicStreamId stream_id,
       bool fin,
       size_t* spdy_headers_frame_length) {
     return server_maker_.MakeResponseHeadersPacket(
         packet_number, stream_id, !kIncludeVersion, fin,
         std::move(response_headers_), spdy_headers_frame_length,
@@ skipping 91 matching lines @@
   }
 
   void ReceivePromise(QuicStreamId id) {
     QuicChromiumClientStream* stream =
         QuicHttpStreamPeer::GetQuicChromiumClientStream(stream_.get());
     stream->OnStreamHeaders(serialized_push_promise_);
 
     stream->OnPromiseHeadersComplete(id, serialized_push_promise_.size());
   }
 
+  void assertLoadTimingValid(const LoadTimingInfo& load_timing_info,
+                             bool session_reused) {
+    EXPECT_EQ(session_reused, load_timing_info.socket_reused);
+    // Connect time and SSL time are null because test fixture does not do a
+    // real connect.
+    EXPECT_TRUE(load_timing_info.connect_timing.connect_start.is_null());
+    EXPECT_TRUE(load_timing_info.connect_timing.connect_end.is_null());
+    EXPECT_TRUE(load_timing_info.connect_timing.ssl_start.is_null());
+    EXPECT_TRUE(load_timing_info.connect_timing.ssl_end.is_null());
+
+    // DNS times are passed in through constructor so they can't be null.
+    // If |session_reused| is true, these fields should all be null, non-null
+    // otherwise.
+    EXPECT_EQ(session_reused,
+              load_timing_info.connect_timing.dns_start.is_null());
+    EXPECT_EQ(session_reused,
+              load_timing_info.connect_timing.dns_end.is_null());
+  }
+
   BoundTestNetLog net_log_;
   bool use_closing_stream_;
   MockSendAlgorithm* send_algorithm_;
   scoped_refptr<TestTaskRunner> runner_;
   std::unique_ptr<MockWrite[]> mock_writes_;
   MockClock clock_;
   TestQuicConnection* connection_;
   std::unique_ptr<QuicChromiumConnectionHelper> helper_;
   std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
   testing::StrictMock<MockQuicConnectionVisitor> visitor_;
@@ skipping 62 matching lines @@
 TEST_P(QuicHttpStreamTest, GetRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   size_t spdy_request_header_frame_length;
   AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
                                          &spdy_request_header_frame_length));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.example.org/");
 
+  // Make sure getting load timing from the stream early does not crash.
+  LoadTimingInfo load_timing_info;
+  EXPECT_FALSE(stream_->GetLoadTimingInfo(&load_timing_info));
+
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                       net_log_.bound(), callback_.callback()));
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Ack the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
@@ skipping 12 matching lines @@
   EXPECT_FALSE(response_.response_time.is_null());
   EXPECT_FALSE(response_.request_time.is_null());
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0,
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 
+  EXPECT_TRUE(stream_->GetLoadTimingInfo(&load_timing_info));
+  assertLoadTimingValid(load_timing_info, /*session_reused=*/false);
+
   // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the
   // headers and payload.
   EXPECT_EQ(static_cast<int64_t>(spdy_request_header_frame_length),
             stream_->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(spdy_response_header_frame_length),
             stream_->GetTotalReceivedBytes());
 }
 
+TEST_P(QuicHttpStreamTest, LoadTimingTwoRequests) {
+  SetRequest("GET", "/", DEFAULT_PRIORITY);
+  size_t spdy_request_header_frame_length;
+
+  QuicStreamOffset offset = 0;
+  AddWrite(InnerConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY,
+      &spdy_request_header_frame_length, &offset));
+
+  // SetRequest() again for second request as |request_headers_| was moved.
+  SetRequest("GET", "/", DEFAULT_PRIORITY);
+  AddWrite(InnerConstructRequestHeadersPacket(
+      2, kClientDataStreamId2, kIncludeVersion, kFin, DEFAULT_PRIORITY,
+      &spdy_request_header_frame_length, &offset));
+  AddWrite(ConstructClientAckPacket(3, 3, 1));  // Ack the responses.
+
+  Initialize();
+
+  request_.method = "GET";
+  request_.url = GURL("http://www.example.org/");
+  // Start first request.
+  EXPECT_EQ(OK,
+            stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
+                                      net_log_.bound(), callback_.callback()));
+  EXPECT_EQ(OK,
+            stream_->SendRequest(headers_, &response_, callback_.callback()));
+
+  // Start a second request.
+  QuicHttpStream stream2(session_->GetWeakPtr());
+  TestCompletionCallback callback2;
+  EXPECT_EQ(OK,
+            stream2.InitializeStream(&request_, DEFAULT_PRIORITY,
+                                     net_log_.bound(), callback2.callback()));
+  EXPECT_EQ(OK,
+            stream2.SendRequest(headers_, &response_, callback2.callback()));
+
+  // Ack both requests.
+  ProcessPacket(ConstructServerAckPacket(1, 0, 0));
+
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()),
+              IsError(ERR_IO_PENDING));
+  size_t spdy_response_header_frame_length;
+  SetResponse("200 OK", string());
+  ProcessPacket(InnerConstructResponseHeadersPacket(
+      2, kClientDataStreamId1, kFin, &spdy_response_header_frame_length));
+
+  // Now that the headers have been processed, the callback will return.
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
+  EXPECT_EQ(200, response_.headers->response_code());
+
+  // There is no body, so this should return immediately.
+  EXPECT_EQ(0,
+            stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
+                                      callback_.callback()));
+  EXPECT_TRUE(stream_->IsResponseBodyComplete());
+
+  LoadTimingInfo load_timing_info;
+  EXPECT_TRUE(stream_->GetLoadTimingInfo(&load_timing_info));
+  assertLoadTimingValid(load_timing_info, /*session_reused=*/false);
+
+  // SetResponse() again for second request as |response_headers_| was moved.
+  SetResponse("200 OK", string());
+  EXPECT_THAT(stream2.ReadResponseHeaders(callback2.callback()),
+              IsError(ERR_IO_PENDING));
+
+  ProcessPacket(InnerConstructResponseHeadersPacket(
+      3, kClientDataStreamId2, kFin, &spdy_response_header_frame_length));
+
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
+
+  // There is no body, so this should return immediately.
+  EXPECT_EQ(0,
+            stream2.ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
+                                     callback2.callback()));
+  EXPECT_TRUE(stream2.IsResponseBodyComplete());
+
+  LoadTimingInfo load_timing_info2;
+  EXPECT_TRUE(stream2.GetLoadTimingInfo(&load_timing_info2));
+  assertLoadTimingValid(load_timing_info2, /*session_reused=*/true);
+}
+
 // QuicHttpStream does not currently support trailers. It should ignore
 // trailers upon receiving them.
 TEST_P(QuicHttpStreamTest, GetRequestWithTrailers) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   size_t spdy_request_header_frame_length;
   AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
                                          &spdy_request_header_frame_length));
   AddWrite(ConstructClientAckPacket(2, 3, 1));  // Ack the data packet.
 
   Initialize();
@@ skipping 1116 matching lines @@
 TEST_P(QuicHttpStreamTest, ServerPushVaryCheckFail) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   request_headers_[":scheme"] = "https";
   request_headers_[":path"] = "/bar";
   request_headers_["accept-encoding"] = "sdch";
 
   size_t spdy_request_header_frame_length;
   AddWrite(ConstructClientRstStreamVaryMismatchPacket(1));
   AddWrite(InnerConstructRequestHeadersPacket(
       2, stream_id_ + 2, !kIncludeVersion, kFin, DEFAULT_PRIORITY,
-      &spdy_request_header_frame_length));
+      &spdy_request_header_frame_length, /*offset=*/nullptr));
   AddWrite(ConstructClientAckPacket(3, 3, 1));
   AddWrite(ConstructClientRstStreamCancelledPacket(4));
   Initialize();
 
   // Initialize the first stream, for receiving the promise on.
   request_.method = "GET";
   request_.url = GURL("http://www.example.org/");
 
   EXPECT_EQ(OK,
             stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
@@ skipping 155 matching lines @@
   EXPECT_TRUE(AtEof());
 
   // QuicHttpStream::GetTotalSent/ReceivedBytes includes only headers.
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 }  // namespace test
 }  // namespace net