diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 0e8289c..543496f 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -310,7 +310,7 @@
                                client_session.GetMutableCryptoStream(),
                                server_conn, server);
 
-  if (server->handshake_confirmed() && server->encryption_established()) {
+  if (server->one_rtt_keys_available() && server->encryption_established()) {
     CompareClientAndServerKeys(client_session.GetMutableCryptoStream(), server);
   }
 
@@ -349,7 +349,8 @@
                                   PacketSavingConnection* server_conn,
                                   QuicCryptoStream* server) {
   size_t client_i = 0, server_i = 0;
-  while (!client->handshake_confirmed() || !server->handshake_confirmed()) {
+  while (!client->one_rtt_keys_available() ||
+         !server->one_rtt_keys_available()) {
     ASSERT_GT(client_conn->encrypted_packets_.size(), client_i);
     QUIC_LOG(INFO) << "Processing "
                    << client_conn->encrypted_packets_.size() - client_i
@@ -357,7 +358,7 @@
     MovePackets(client_conn, &client_i, server, server_conn,
                 Perspective::IS_SERVER);
 
-    if (client->handshake_confirmed() && server->handshake_confirmed() &&
+    if (client->one_rtt_keys_available() && server->one_rtt_keys_available() &&
         server_conn->encrypted_packets_.size() == server_i) {
       break;
     }
