Use load_timing_info_test_util.cc in quic_http_stream_test.cc

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>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
+#include "net/base/load_timing_info.h"
+#include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_util.h"
 #include "net/quic/chromium/crypto/proof_verifier_chromium.h"
 #include "net/quic/chromium/quic_chromium_alarm_factory.h"
@@ skipping 273 matching lines @@
 
     // Load a certificate that is valid for *.example.org
     scoped_refptr<X509Certificate> test_cert(
         ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
     EXPECT_TRUE(test_cert.get());
 
     verify_details_.cert_verify_result.verified_cert = test_cert;
     verify_details_.cert_verify_result.is_issued_by_known_root = true;
     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
 
+    base::TimeTicks dns_end = base::TimeTicks::Now();
+    base::TimeTicks dns_start = dns_end - base::TimeDelta::FromMilliseconds(1);
     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(), base::TimeTicks::Now(),
-        &push_promise_index_, base::ThreadTaskRunnerHandle::Get().get(),
+        "CONNECTION_UNKNOWN", dns_start, dns_end, &push_promise_index_,
+        base::ThreadTaskRunnerHandle::Get().get(),
         /*socket_performance_watcher=*/nullptr, net_log_.bound().net_log()));
     session_->Initialize();
     TestCompletionCallback callback;
     session_->CryptoConnect(/*require_confirmation=*/false,
                             callback.callback());
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_
                       ? new AutoClosingStream(session_->GetWeakPtr())
                       : new QuicHttpStream(session_->GetWeakPtr()));
 
@@ skipping 189 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,
+  void ExpectLoadTimingValid(const LoadTimingInfo& load_timing_info,
                              bool session_reused) {
     EXPECT_EQ(session_reused, load_timing_info.socket_reused);
-
-    // If |session_reused| is true, these fields should all be null, non-null
-    // otherwise.
-    EXPECT_EQ(session_reused,
-              load_timing_info.connect_timing.connect_start.is_null());
-    EXPECT_EQ(session_reused,
-              load_timing_info.connect_timing.connect_end.is_null());
-    EXPECT_EQ(session_reused,
-              load_timing_info.connect_timing.ssl_start.is_null());
-    EXPECT_EQ(session_reused,
-              load_timing_info.connect_timing.ssl_end.is_null());
-    EXPECT_EQ(load_timing_info.connect_timing.connect_start,
-              load_timing_info.connect_timing.ssl_start);
-    EXPECT_EQ(load_timing_info.connect_timing.connect_end,
-              load_timing_info.connect_timing.ssl_end);
-
-    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());
+    if (session_reused) {
+      ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
+    } else {
+      ExpectConnectTimingHasTimes(
+          load_timing_info.connect_timing,
+          CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES);
+    }
+    ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
   }
 
   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_;
@@ skipping 101 matching lines @@
   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);
+  ExpectLoadTimingValid(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) {
@@ skipping 47 matching lines @@
   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);
+  ExpectLoadTimingValid(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);
+  ExpectLoadTimingValid(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.
@@ skipping 1294 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