Add WaitForHandshakeConfirmed. In those tests with large packet loss, wait for handshake confirmed before upping the loss rate. Also disable T050 for those tests, as there is T050 does not have HANDSHAKE_DONE frame.

PiperOrigin-RevId: 314773977
Change-Id: Iee43903a0fcff70e0443ffe82c0781aa8cccb2d8

quic/core/http/end_to_end_test.cc

diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index fa97272..f3b5d35 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -1144,9 +1144,10 @@
   // brutal.
   SetPacketLossPercentage(5);
   ASSERT_TRUE(Initialize());
-
-  // Wait for the server SHLO before upping the packet loss.
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
+  if (version_.UsesTls() && !version_.HasHandshakeDone()) {
+    return;
+  }
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
   SetPacketLossPercentage(30);
 
   // 10 KB body.
@@ -1165,9 +1166,10 @@
 // Regression test for b/80090281.
 TEST_P(EndToEndTest, LargePostWithPacketLossAndAlwaysBundleWindowUpdates) {
   ASSERT_TRUE(Initialize());
-
-  // Wait for the server SHLO before upping the packet loss.
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
+  if (version_.UsesTls() && !version_.HasHandshakeDone()) {
+    return;
+  }
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Normally server only bundles a retransmittable frame once every other
@@ -1198,9 +1200,10 @@
   // b/10126687 is fixed, losing handshake packets is pretty brutal.
   SetPacketLossPercentage(5);
   ASSERT_TRUE(Initialize());
-
-  // Wait for the server SHLO before upping the packet loss.
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
+  if (version_.UsesTls() && !version_.HasHandshakeDone()) {
+    return;
+  }
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
   SetPacketLossPercentage(10);
   client_writer_->set_fake_blocked_socket_percentage(10);
 
@@ -1218,8 +1221,10 @@
 
 TEST_P(EndToEndTest, LargePostNoPacketLossWithDelayAndReordering) {
   ASSERT_TRUE(Initialize());
-
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
+  if (version_.UsesTls() && !version_.HasHandshakeDone()) {
+    return;
+  }
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
   // Both of these must be called when the writer is not actively used.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
@@ -2406,9 +2411,11 @@
   // demonstrates that retransmissions do not break this functionality.
   SetPacketLossPercentage(5);
   ASSERT_TRUE(Initialize());
-
+  if (version_.UsesTls() && !version_.HasHandshakeDone()) {
+    return;
+  }
   // Wait for the server SHLO before upping the packet loss.
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
   SetPacketLossPercentage(30);
   client_writer_->set_fake_blocked_socket_percentage(10);
 
@@ -3777,7 +3784,10 @@
 
 TEST_P(EndToEndTest, ResetStreamOnTtlExpires) {
   ASSERT_TRUE(Initialize());
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
+  if (version_.UsesTls() && !version_.HasHandshakeDone()) {
+    return;
+  }
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
   SetPacketLossPercentage(30);
 
   QuicSpdyClientStream* stream = client_->GetOrCreateStream();

quic/tools/quic_client_base.cc

diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index 73715da..bc09d8c 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -247,6 +247,19 @@
   return connected();
 }
 
+bool QuicClientBase::WaitForHandshakeConfirmed() {
+  if (!session_->connection()->version().HasHandshakeDone()) {
+    return WaitForOneRttKeysAvailable();
+  }
+  while (connected() && session_->GetHandshakeState() < HANDSHAKE_CONFIRMED) {
+    WaitForEvents();
+  }
+
+  // If the handshake fails due to a timeout, the connection will be closed.
+  QUIC_LOG_IF(ERROR, !connected()) << "Handshake with server failed.";
+  return connected();
+}
+
 bool QuicClientBase::connected() const {
   return session_.get() && session_->connection() &&
          session_->connection()->connected();

quic/tools/quic_client_base.h

diff --git a/quic/tools/quic_client_base.h b/quic/tools/quic_client_base.h
index 1ac64e3..74fc2af 100644
--- a/quic/tools/quic_client_base.h
+++ b/quic/tools/quic_client_base.h
@@ -106,6 +106,11 @@
   // Returns true once 1-RTT keys are available, false otherwise.
   QUIC_MUST_USE_RESULT bool WaitForOneRttKeysAvailable();
 
+  // Wait for handshake state proceeds to HANDSHAKE_CONFIRMED.
+  // In QUIC crypto, this does the same as WaitForOneRttKeysAvailable, while in
+  // TLS, this waits for HANDSHAKE_DONE frame is received.
+  QUIC_MUST_USE_RESULT bool WaitForHandshakeConfirmed();
+
   // Wait up to 50ms, and handle any events which occur.
   // Returns true if there are any outstanding requests.
   bool WaitForEvents();