Various cleanups to QUIC end to end test to sync up with the internal version.

net/tools/quic/end_to_end_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 <stddef.h>
 #include <sys/epoll.h>
 
+#include <cstdint>
 #include <list>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 38 matching lines @@
 #include "net/tools/quic/test_tools/quic_server_peer.h"
 #include "net/tools/quic/test_tools/quic_test_client.h"
 #include "net/tools/quic/test_tools/quic_test_server.h"
 #include "net/tools/quic/test_tools/server_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::IntToString;
 using base::StringPiece;
 using base::WaitableEvent;
 using net::EpollServer;
-using net::test::ConstructEncryptedPacket;
-using net::test::CryptoTestUtils;
-using net::test::GenerateBody;
-using net::test::Loopback4;
-using net::test::MockQuicConnectionDebugVisitor;
-using net::test::QuicConnectionPeer;
-using net::test::QuicFlowControllerPeer;
-using net::test::QuicSentPacketManagerPeer;
-using net::test::QuicSessionPeer;
-using net::test::QuicSpdySessionPeer;
-using net::test::ReliableQuicStreamPeer;
-using net::test::kClientDataStreamId1;
-using net::test::kInitialSessionFlowControlWindowForTest;
-using net::test::kInitialStreamFlowControlWindowForTest;
-using net::test::PacketDroppingTestWriter;
-using net::test::QuicDispatcherPeer;
-using net::test::QuicServerPeer;
 using std::ostream;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace test {
 namespace {
 
 const char kFooResponseBody[] = "Artichoke hearts make me happy.";
 const char kBarResponseBody[] = "Palm hearts are pretty delicious, also.";
@@ skipping 53 matching lines @@
   bool use_cheap_stateless_reject;
   bool buffer_packet_till_chlo;
 };
 
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   // Divide the versions into buckets in which the intra-frame format
   // is compatible. When clients encounter QUIC version negotiation
   // they simply retransmit all packets using the new version's
   // QUIC framing. However, they are unable to change the intra-frame
-  // layout (for example to change HTTP2 headers to SPDY/3). So
+  // layout (for example to change HTTP/2 headers to SPDY/3). So
   // these tests need to ensure that clients are never attempting
   // to do 0-RTT across incompatible versions. Chromium only supports
   // a single version at a time anyway. :)
   QuicVersionVector all_supported_versions = AllSupportedVersions();
   QuicVersionVector version_buckets[3];
 
   for (const QuicVersion version : all_supported_versions) {
     if (version <= QUIC_VERSION_32) {
       // Versions: 31-32
       // v31 adds a hash of the CHLO into the proof signature.
@@ skipping 10 matching lines @@
     }
   }
 
   // This must be kept in sync with the number of nested for-loops below as it
   // is used to prune the number of tests that are run.
   const int kMaxEnabledOptions = 6;
   int max_enabled_options = 0;
   std::vector<TestParams> params;
   for (bool server_uses_stateless_rejects_if_peer_supported : {true, false}) {
     for (bool client_supports_stateless_rejects : {true, false}) {
-      for (const QuicTag congestion_control_tag : {kRENO, kQBIC}) {
+      for (const QuicTag congestion_control_tag : {kRENO, kTBBR, kQBIC}) {
         for (bool disable_hpack_dynamic_table : {false}) {
           for (bool force_hol_blocking : {true, false}) {
             for (bool use_cheap_stateless_reject : {true, false}) {
               for (bool buffer_packet_till_chlo : {true, false}) {
                 if (!buffer_packet_till_chlo && use_cheap_stateless_reject) {
                   // Doing stateless reject while not buffering packet
                   // before CHLO is not allowed.
                   break;
                 }
                 int enabled_options = 0;
@@ skipping 240 matching lines @@
     client_config_.SetConnectionOptionsToSend(copt);
 
     // Start the server first, because CreateQuicClient() attempts
     // to connect to the server.
     StartServer();
 
     CreateClientWithWriter();
     static EpollEvent event(EPOLLOUT, false);
     if (client_writer_ != nullptr) {
       client_writer_->Initialize(
-          reinterpret_cast<QuicEpollConnectionHelper*>(
-              QuicConnectionPeer::GetHelper(
-                  client_->client()->session()->connection())),
+          QuicConnectionPeer::GetHelper(
+              client_->client()->session()->connection()),
           QuicConnectionPeer::GetAlarmFactory(
               client_->client()->session()->connection()),
           new ClientDelegate(client_->client()));
     }
     initialized_ = true;
     return client_->client()->connected();
   }
 
   void SetUp() override {
     // The ownership of these gets transferred to the QuicPacketWriterWrapper
@@ skipping 319 matching lines @@
 }
 
 TEST_P(EndToEndTest, LargePostNoPacketLoss) {
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // 1 MB body.
   string body;
   GenerateBody(&body, 1024 * 1024);
-
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   // TODO(ianswett): There should not be packet loss in this test, but on some
   // platforms the receive buffer overflows.
@@ skipping 31 matching lines @@
   }
   ASSERT_TRUE(Initialize());
 
   // Wait for the server SHLO before upping the packet loss.
   client_->client()->WaitForCryptoHandshakeConfirmed();
   SetPacketLossPercentage(30);
 
   // 10 KB body.
   string body;
   GenerateBody(&body, 1024 * 10);
-  test::GenerateBody(&body, 1024 * 10);
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   VerifyCleanConnection(true);
 }
@@ skipping 73 matching lines @@
   const int expected_num_hellos_latest_session =
       BothSidesSupportStatelessRejects() ? 1 : 2;
   EXPECT_EQ(expected_num_hellos_latest_session,
             client_->client()->session()->GetNumSentClientHellos());
   EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
 
   client_->Disconnect();
 
   // The 0-RTT handshake should succeed.
   client_->Connect();
-  client_->WaitForResponseForMs(-1);
+  client_->WaitForInitialResponse();
   ASSERT_TRUE(client_->client()->connected());
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
 
   if (negotiated_version_ <= QUIC_VERSION_32) {
     EXPECT_EQ(expected_num_hellos_latest_session,
               client_->client()->session()->GetNumSentClientHellos());
     EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
   } else {
     EXPECT_EQ(1, client_->client()->session()->GetNumSentClientHellos());
@@ skipping 251 matching lines @@
       QuicConnectionPeer::GetResumeWritesAlarm(session->connection());
   EXPECT_FALSE(resume_writes_alarm->IsSet());
 }
 
 TEST_P(EndToEndTest, InvalidStream) {
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   string body;
   GenerateBody(&body, kMaxPacketSize);
-
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
+
   // Force the client to write with a stream ID belonging to a nonexistent
   // server-side stream.
   QuicSessionPeer::SetNextOutgoingStreamId(client_->client()->session(), 2);
 
   client_->SendCustomSynchronousRequest(headers, body);
-  // EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_INVALID_STREAM_ID, client_->connection_error());
 }
 
 // Test that if the the server will close the connection if the client attempts
 // to send a request with overly large headers.
 TEST_P(EndToEndTest, LargeHeaders) {
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   string body;
-  test::GenerateBody(&body, kMaxPacketSize);
-
+  GenerateBody(&body, kMaxPacketSize);
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   headers["key1"] = string(15 * 1024, 'a');
   headers["key2"] = string(15 * 1024, 'a');
   headers["key3"] = string(15 * 1024, 'a');
 
   client_->SendCustomSynchronousRequest(headers, body);
   if (FLAGS_quic_limit_uncompressed_headers) {
     EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error());
   } else {
     EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
     EXPECT_EQ(kFooResponseBody, client_->response_body());
     EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
   }
   EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
 }
 
 TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) {
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   string large_body;
   GenerateBody(&large_body, 1024 * 1024);
-
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
-
   // Insert an invalid content_length field in request to trigger an early
   // response from server.
   headers["content-length"] = "-3";
 
   client_->SendCustomSynchronousRequest(headers, large_body);
   EXPECT_EQ("bad", client_->response_body());
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
 }
@@ skipping 305 matching lines @@
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
       client_->client()->session()->connection());
   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
             header->public_header.connection_id_length);
 }
 
 TEST_P(EndToEndTest, ResetConnection) {
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
   client_->ResetConnection();
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
 }
 
 TEST_P(EndToEndTest, MaxStreamsUberTest) {
   if (!BothSidesSupportStatelessRejects()) {
@@ skipping 378 matching lines @@
 
   // Send the request, and register the delegate for ACKs.
   client_->SendData(request_string, true, delegate.get());
   client_->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client_->response_body());
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
 
   // Send another request to flush out any pending ACKs on the server.
   client_->SendSynchronousRequest("/bar");
 
-  // Pause the server to avoid races.
-  server_thread_->Pause();

[Jana, 2016/11/03 17:51:40]

Assuming that this doesn't cause races now?

[Ryan Hamilton, 2016/11/03 17:57:29]

Right. To be safe, I took the chrome code and attempted to use it internally but
that causes hangs! Calling Pause() is actually a terrible idea, as it turns out,
because if the client has not yet received a response, then stopping the server
guarantees that it will *never* get a response :> And the code here doesn't
actually tickle any races, as far as I can tell.  perhaps this code did
something different in a previous incarnation?

   // Make sure the delegate does get the notification it expects.
   while (!delegate->has_been_notified()) {
     // Waits for up to 50 ms.
     client_->client()->WaitForEvents();
   }
-  server_thread_->Resume();
 }
 
 // Send a public reset from the server.
 TEST_P(EndToEndTest, ServerSendPublicReset) {
   ASSERT_TRUE(Initialize());
 
   // Send the public reset.
   QuicConnectionId connection_id =
       client_->client()->session()->connection()->connection_id();
   QuicPublicResetPacket header;
@@ skipping 324 matching lines @@
                                     QuicSpdySession* session,
                                     int64_t body_bytes)
       : QuicSimpleServerStream(id, session), body_bytes_(body_bytes) {}
 
   ~ServerStreamThatSendsHugeResponse() override {}
 
  protected:
   void SendResponse() override {
     QuicInMemoryCache::Response response;
     string body;
-    test::GenerateBody(&body, body_bytes_);
+    GenerateBody(&body, body_bytes_);
     response.set_body(body);
     SendHeadersAndBodyAndTrailers(response.headers().Clone(), response.body(),
                                   response.trailers().Clone());
   }
 
  private:
-  // Use a explicit int64 rather than size_t to simulate a 64-bit server talking
-  // to a 32-bit client.
+  // Use a explicit int64_t rather than size_t to simulate a 64-bit server
+  // talking to a 32-bit client.
   int64_t body_bytes_;
 };
 
 class ServerStreamThatSendsHugeResponseFactory
     : public QuicTestServer::StreamFactory {
  public:
   explicit ServerStreamThatSendsHugeResponseFactory(int64_t body_bytes)
       : body_bytes_(body_bytes) {}
 
   ~ServerStreamThatSendsHugeResponseFactory() override{};
@@ skipping 113 matching lines @@
 
   StreamWithErrorFactory stream_factory(response_body);
   SetSpdyStreamFactory(&stream_factory);
 
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // A POST that gets an early error response, after the headers are received
   // and before the body is received, due to invalid content-length.
+  // Set an invalid content-length, so the request will receive an early 500
+  // response.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/garbage";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
+  headers["content-length"] = "-1";
 
   // The body must be large enough that the FIN will be in a different packet
   // than the end of the headers, but short enough to not require a flow control
   // update.  This allows headers processing to trigger the error response
   // before the request FIN is processed but receive the request FIN before the
   // response is sent completely.
   const uint32_t kRequestBodySize = kMaxPacketSize + 10;
   string request_body;
   GenerateBody(&request_body, kRequestBodySize);
-  // Set an invalid content-length, so the request will receive an early 500
-  // response.  Must be done after AddBody, which also sets content-length.
-  headers["content-length"] = "-1";
 
   // Send the request.
   client_->SendMessage(headers, request_body);
   client_->WaitForResponse();
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
 
   QuicDispatcher* dispatcher =
@@ skipping 20 matching lines @@
   set_server_initial_session_flow_control_receive_window(kWindowSize);
 
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // POST to a URL that gets an early error response, after the headers are
   // received and before the body is received.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
-  headers[":path"] = "/garbage";
+  headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
-
-  // Invalid content-length so the request will receive an early 500 response.

[Jana, 2016/11/03 17:51:40]

nit: move this comment to the comment block above instead of deleting?

[Ryan Hamilton, 2016/11/03 17:57:28]

meh. the comment above headers already talks about generating an early response
on this matches the internal code.

   headers["content-length"] = "-1";
 
   // Tell the client to not close the stream if it receives an early response.
   client_->set_allow_bidirectional_data(true);
   // Send the headers.
-  client_->SendMessage(headers, "", false);
+  client_->SendMessage(headers, "", /*fin=*/false);
+
   // Receive the response and let the server close writing.
   client_->WaitForInitialResponse();
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
 
   // Receive the reset stream from server on early response.
   ReliableQuicStream* stream =
       client_->client()->session()->GetOrCreateStream(kClientDataStreamId1);
   // The stream is reset by server's reset stream.
   EXPECT_EQ(stream, nullptr);
 }
@@ skipping 48 matching lines @@
                                            string path,
                                            string response_body,
                                            string* push_urls,
                                            const size_t num_resources,
                                            const size_t resource_size) {
     bool use_large_response = resource_size != 0;
     string large_resource;
     if (use_large_response) {
       // Generate a response common body larger than flow control window for
       // push response.
-      test::GenerateBody(&large_resource, resource_size);
+      GenerateBody(&large_resource, resource_size);
     }
     std::list<QuicInMemoryCache::ServerPushInfo> push_resources;
     for (size_t i = 0; i < num_resources; ++i) {
       string url = push_urls[i];
       GURL resource_url(url);
       string body = use_large_response
                         ? large_resource
                         : "This is server push response body for " + url;
       SpdyHeaderBlock response_headers;
       response_headers[":version"] = "HTTP/1.1";
@@ skipping 17 matching lines @@
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
   size_t kNumResources = 4;
-  string push_urls[] = {
-      "https://google.com/font.woff", "https://google.com/script.js",
-      "https://fonts.google.com/font.woff", "https://google.com/logo-hires.jpg",
-  };
+  string push_urls[] = {"https://example.com/font.woff",
+                        "https://example.com/script.js",
+                        "https://fonts.example.com/font.woff",
+                        "https://example.com/logo-hires.jpg"};
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, 0);
 
   client_->client()->set_response_listener(
       std::unique_ptr<QuicClientBase::ResponseListener>(
           new TestResponseListener));
 
   DVLOG(1) << "send request for /push_example";
   EXPECT_EQ(kBody, client_->SendSynchronousRequest(
                        "https://example.com/push_example"));
@@ skipping 75 matching lines @@
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
 
   // One more resource than max number of outgoing stream of this session.
   const size_t kNumResources = 1 + kNumMaxStreams;  // 11.
   string push_urls[11];
-  for (uint32_t i = 0; i < kNumResources; ++i) {
+  for (size_t i = 0; i < kNumResources; ++i) {
     push_urls[i] = "https://example.com/push_resources" + base::UintToString(i);
   }
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, 0);
   client_->client()->set_response_listener(
       std::unique_ptr<QuicClientBase::ResponseListener>(
           new TestResponseListener));
 
   // Send the first request: this will trigger the server to send all the push
   // resources associated with this request, and these will be cached by the
@@ skipping 36 matching lines @@
 
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
 
   const size_t kNumResources = kNumMaxStreams + 1;
   string push_urls[11];
-  for (uint32_t i = 0; i < kNumResources; ++i) {
+  for (size_t i = 0; i < kNumResources; ++i) {
     push_urls[i] = "http://example.com/push_resources" + base::UintToString(i);
   }
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, kBodySize);
 
   client_->client()->set_response_listener(
       std::unique_ptr<QuicClientBase::ResponseListener>(
           new TestResponseListener));
 
   client_->SendRequest("https://example.com/push_example");
@@ skipping 21 matching lines @@
 
   // "Send" request for a promised resources will not really send out it because
   // its response is being pushed(but blocked). And the following ack and
   // flow control behavior of SendSynchronousRequests()
   // will unblock the stream to finish receiving response.
   client_->SendSynchronousRequest(push_urls[0]);
   EXPECT_EQ(1u, client_->num_requests());
   EXPECT_EQ(2u, client_->num_responses());
 
   // Do same thing for the rest 10 resources.
-  for (uint32_t i = 1; i < kNumResources; ++i) {
+  for (size_t i = 1; i < kNumResources; ++i) {
     client_->SendSynchronousRequest(push_urls[i]);
   }
 
   // Because of server push, client gets all pushed resources without actually
   // sending requests for them.
   EXPECT_EQ(1u, client_->num_requests());
   // Including response to original request, 12 responses in total were
   // recieved.
   EXPECT_EQ(12u, client_->num_responses());
 }
@@ skipping 44 matching lines @@
   ASSERT_TRUE(Initialize());
   // Set client's epoll server's time out to 0 to make this test be finished
   // within a short time.
   client_->epoll_server()->set_timeout_in_us(0);
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
   SetPacketLossPercentage(1);
   // To avoid storing the whole request body in memory, use a loop to repeatedly
   // send body size of kSizeBytes until the whole request body size is reached.
   const int kSizeBytes = 128 * 1024;
+  // Request body size is 4G plus one more kSizeBytes.
+  int64_t request_body_size_bytes = pow(2, 32) + kSizeBytes;
+  ASSERT_LT(INT64_C(4294967296), request_body_size_bytes);
+  string body;
+  GenerateBody(&body, kSizeBytes);
+
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
-
-  // Request body size is 4G plus one more kSizeBytes.
-  int64_t request_body_size_bytes = pow(2, 32) + kSizeBytes;
-  ASSERT_LT(INT64_C(4294967296), request_body_size_bytes);
   headers["content-length"] = IntToString(request_body_size_bytes);
-  string body;
-  test::GenerateBody(&body, kSizeBytes);
 
   client_->SendMessage(headers, "", /*fin=*/false);
+
   for (int i = 0; i < request_body_size_bytes / kSizeBytes; ++i) {
     bool fin = (i == request_body_size_bytes - 1);
     client_->SendData(string(body.data(), kSizeBytes), fin);
     client_->client()->WaitForEvents();
   }
   VerifyCleanConnection(true);
 }
 
 // TODO(fayang): this test seems to cause net_unittests timeouts :|
 TEST_P(EndToEndTest, DISABLED_TestHugeResponseWithPacketLoss) {
@@ skipping 86 matching lines @@
   // Disconnect for next 0-rtt request.
   client_->Disconnect();
 
   // Client get valid STK now. Do a 0-rtt request.
   // Buffer a CHLO till another packets sent out.
   reorder_writer_->SetDelay(1);
   // Only send out a CHLO.
   client_->client()->Initialize();
   client_->client()->StartConnect();
   ASSERT_TRUE(client_->client()->connected());
+
   // Send a request before handshake finishes.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/bar";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   client_->SendMessage(headers, "");
   client_->WaitForResponse();
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 }  // namespace
 }  // namespace test
 }  // namespace net