diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 2d3702f..042d973 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -352,115 +352,6 @@
             client_version_label);
 }
 
-class QuicCryptoClientStreamStatelessTest : public QuicTest {
- public:
-  QuicCryptoClientStreamStatelessTest()
-      : client_crypto_config_(crypto_test_utils::ProofVerifierForTesting(),
-                              TlsClientHandshaker::CreateSslCtx()),
-        server_crypto_config_(QuicCryptoServerConfig::TESTING,
-                              QuicRandom::GetInstance(),
-                              crypto_test_utils::ProofSourceForTesting(),
-                              KeyExchangeSource::Default(),
-                              TlsServerHandshaker::CreateSslCtx()),
-        server_compressed_certs_cache_(
-            QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
-        server_id_(kServerHostname, kServerPort, false) {
-    TestQuicSpdyClientSession* client_session = nullptr;
-    CreateClientSessionForTest(server_id_,
-                               /* supports_stateless_rejects= */ true,
-                               QuicTime::Delta::FromSeconds(100000),
-                               AllSupportedVersions(), &helper_,
-                               &alarm_factory_, &client_crypto_config_,
-                               &client_connection_, &client_session);
-    CHECK(client_session);
-    client_session_.reset(client_session);
-  }
-
-  QuicCryptoServerStream* server_stream() {
-    return server_session_->GetMutableCryptoStream();
-  }
-
-  void AdvanceHandshakeWithFakeServer() {
-    client_session_->GetMutableCryptoStream()->CryptoConnect();
-    EXPECT_CALL(*server_session_->helper(), CanAcceptClientHello(_, _, _, _, _))
-        .Times(testing::AnyNumber());
-    EXPECT_CALL(*server_session_->helper(), GenerateConnectionIdForReject(_, _))
-        .Times(testing::AnyNumber());
-    crypto_test_utils::AdvanceHandshake(
-        client_connection_, client_session_->GetMutableCryptoStream(), 0,
-        server_connection_, server_stream(), 0);
-  }
-
-  // Initializes the server_stream_ for stateless rejects.
-  void InitializeFakeStatelessRejectServer() {
-    TestQuicSpdyServerSession* server_session = nullptr;
-    CreateServerSessionForTest(
-        server_id_, QuicTime::Delta::FromSeconds(100000),
-        ParsedVersionOfIndex(AllSupportedVersions(), 0), &helper_,
-        &alarm_factory_, &server_crypto_config_,
-        &server_compressed_certs_cache_, &server_connection_, &server_session);
-    CHECK(server_session);
-    server_session_.reset(server_session);
-    server_session_->OnSuccessfulVersionNegotiation(AllSupportedVersions()[0]);
-    crypto_test_utils::FakeServerOptions options;
-    crypto_test_utils::SetupCryptoServerConfigForTest(
-        server_connection_->clock(), server_connection_->random_generator(),
-        &server_crypto_config_, options);
-    SetQuicReloadableFlag(enable_quic_stateless_reject_support, true);
-  }
-
-  MockQuicConnectionHelper helper_;
-  MockAlarmFactory alarm_factory_;
-
-  // Client crypto stream state
-  PacketSavingConnection* client_connection_;
-  std::unique_ptr<TestQuicSpdyClientSession> client_session_;
-  QuicCryptoClientConfig client_crypto_config_;
-
-  // Server crypto stream state
-  PacketSavingConnection* server_connection_;
-  std::unique_ptr<TestQuicSpdyServerSession> server_session_;
-  QuicCryptoServerConfig server_crypto_config_;
-  QuicCompressedCertsCache server_compressed_certs_cache_;
-  QuicServerId server_id_;
-};
-
-TEST_F(QuicCryptoClientStreamStatelessTest, StatelessReject) {
-  SetQuicReloadableFlag(enable_quic_stateless_reject_support, true);
-
-  QuicCryptoClientConfig::CachedState* client_state =
-      client_crypto_config_.LookupOrCreate(server_id_);
-
-  EXPECT_FALSE(client_state->has_server_designated_connection_id());
-  EXPECT_CALL(*client_session_, OnProofValid(testing::_));
-
-  InitializeFakeStatelessRejectServer();
-  EXPECT_CALL(*client_connection_,
-              CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-  EXPECT_CALL(*server_connection_,
-              CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-  AdvanceHandshakeWithFakeServer();
-
-  EXPECT_EQ(1, server_stream()->NumHandshakeMessages());
-  EXPECT_EQ(0, server_stream()->NumHandshakeMessagesWithServerNonces());
-
-  EXPECT_FALSE(client_session_->IsEncryptionEstablished());
-  EXPECT_FALSE(client_session_->IsCryptoHandshakeConfirmed());
-  // Even though the handshake was not complete, the cached client_state is
-  // complete, and can be used for a subsequent successful handshake.
-  EXPECT_TRUE(client_state->IsComplete(QuicWallTime::FromUNIXSeconds(0)));
-
-  ASSERT_TRUE(client_state->has_server_nonce());
-  ASSERT_FALSE(client_state->GetNextServerNonce().empty());
-  ASSERT_TRUE(client_state->has_server_designated_connection_id());
-  QuicConnectionId server_designated_id =
-      client_state->GetNextServerDesignatedConnectionId();
-  QuicConnectionId expected_id = QuicUtils::CreateRandomConnectionId(
-      server_session_->connection()->random_generator());
-  EXPECT_EQ(expected_id, server_designated_id);
-  EXPECT_FALSE(client_state->has_server_designated_connection_id());
-}
-
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc
index c0e61ef..9e46d6d 100644
--- a/quic/core/quic_crypto_server_handshaker.cc
+++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -138,18 +138,11 @@
     QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
         result,
     std::unique_ptr<ProofSource::Details> details) {
-  const CryptoHandshakeMessage& message = result->client_hello;
-
   // Clear the callback that got us here.
   DCHECK(validate_client_hello_cb_ != nullptr);
   DCHECK(process_client_hello_cb_ == nullptr);
   validate_client_hello_cb_ = nullptr;
 
-  if (stream_->UseStatelessRejectsIfPeerSupported()) {
-    stream_->SetPeerSupportsStatelessRejects(
-        QuicCryptoServerStreamBase::DoesPeerSupportStatelessRejects(message));
-  }
-
   std::unique_ptr<ProcessClientHelloCallback> cb(
       new ProcessClientHelloCallback(this, result));
   process_client_hello_cb_ = cb.get();
@@ -177,8 +170,7 @@
 
   if (reply->tag() != kSHLO) {
     if (reply->tag() == kSREJ) {
-      DCHECK(stream_->UseStatelessRejectsIfPeerSupported());
-      DCHECK(stream_->PeerSupportsStatelessRejects());
+      DCHECK(false) << "Unexpected SREJ reply.";
       // Before sending the SREJ, cause the connection to save crypto packets
       // so that they can be added to the time wait list manager and
       // retransmitted.
@@ -189,8 +181,7 @@
     SendHandshakeMessage(*reply);
 
     if (reply->tag() == kSREJ) {
-      DCHECK(stream_->UseStatelessRejectsIfPeerSupported());
-      DCHECK(stream_->PeerSupportsStatelessRejects());
+      DCHECK(false) << "Unexpected SREJ reply.";
       DCHECK(!handshake_confirmed());
       QUIC_DLOG(INFO) << "Closing connection "
                       << session()->connection()->connection_id()
@@ -431,16 +422,13 @@
   }
   previous_source_address_tokens_ = result->info.source_address_tokens;
 
-  const bool use_stateless_rejects_in_crypto_config =
-      stream_->UseStatelessRejectsIfPeerSupported() &&
-      stream_->PeerSupportsStatelessRejects();
   QuicConnection* connection = session()->connection();
   const QuicConnectionId server_designated_connection_id =
-      GenerateConnectionIdForReject(use_stateless_rejects_in_crypto_config);
+      GenerateConnectionIdForReject(/*use_stateless_rejects=*/false);
   crypto_config_->ProcessClientHello(
       result, /*reject_only=*/false, connection->connection_id(),
       connection->self_address(), GetClientAddress(), connection->version(),
-      session()->supported_versions(), use_stateless_rejects_in_crypto_config,
+      session()->supported_versions(), /*use_stateless_rejects=*/false,
       server_designated_connection_id, connection->clock(),
       connection->random_generator(), compressed_certs_cache_,
       crypto_negotiated_params_, signed_config_,
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 010ac36..3375e46 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -97,23 +97,10 @@
   return handshaker()->PreviousCachedNetworkParams();
 }
 
-bool QuicCryptoServerStream::UseStatelessRejectsIfPeerSupported() const {
-  return use_stateless_rejects_if_peer_supported_;
-}
-
-bool QuicCryptoServerStream::PeerSupportsStatelessRejects() const {
-  return peer_supports_stateless_rejects_;
-}
-
 bool QuicCryptoServerStream::ZeroRttAttempted() const {
   return handshaker()->ZeroRttAttempted();
 }
 
-void QuicCryptoServerStream::SetPeerSupportsStatelessRejects(
-    bool peer_supports_stateless_rejects) {
-  peer_supports_stateless_rejects_ = peer_supports_stateless_rejects;
-}
-
 void QuicCryptoServerStream::SetPreviousCachedNetworkParams(
     CachedNetworkParameters cached_network_params) {
   handshaker()->SetPreviousCachedNetworkParams(cached_network_params);
diff --git a/quic/core/quic_crypto_server_stream.h b/quic/core/quic_crypto_server_stream.h
index a003027..a31f133 100644
--- a/quic/core/quic_crypto_server_stream.h
+++ b/quic/core/quic_crypto_server_stream.h
@@ -51,10 +51,7 @@
   // These are all accessors and setters to their respective counters.
   virtual uint8_t NumHandshakeMessages() const = 0;
   virtual uint8_t NumHandshakeMessagesWithServerNonces() const = 0;
-  virtual bool UseStatelessRejectsIfPeerSupported() const = 0;
-  virtual bool PeerSupportsStatelessRejects() const = 0;
   virtual bool ZeroRttAttempted() const = 0;
-  virtual void SetPeerSupportsStatelessRejects(bool set) = 0;
   virtual const CachedNetworkParameters* PreviousCachedNetworkParams()
       const = 0;
   virtual void SetPreviousCachedNetworkParams(
@@ -171,11 +168,7 @@
   uint8_t NumHandshakeMessagesWithServerNonces() const override;
   int NumServerConfigUpdateMessagesSent() const override;
   const CachedNetworkParameters* PreviousCachedNetworkParams() const override;
-  bool UseStatelessRejectsIfPeerSupported() const override;
-  bool PeerSupportsStatelessRejects() const override;
   bool ZeroRttAttempted() const override;
-  void SetPeerSupportsStatelessRejects(
-      bool peer_supports_stateless_rejects) override;
   void SetPreviousCachedNetworkParams(
       CachedNetworkParameters cached_network_params) override;
 
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index ff7111c..30f954d 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -45,14 +45,6 @@
 namespace quic {
 namespace test {
 
-class QuicCryptoServerStreamPeer {
- public:
-  static bool DoesPeerSupportStatelessRejects(
-      const CryptoHandshakeMessage& message) {
-    return QuicCryptoServerStream::DoesPeerSupportStatelessRejects(message);
-  }
-};
-
 namespace {
 
 const char kServerHostname[] = "test.example.com";
@@ -74,9 +66,7 @@
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
         server_id_(kServerHostname, kServerPort, false),
         client_crypto_config_(crypto_test_utils::ProofVerifierForTesting(),
-                              TlsClientHandshaker::CreateSslCtx()) {
-    SetQuicReloadableFlag(enable_quic_stateless_reject_support, false);
-  }
+                              TlsClientHandshaker::CreateSslCtx()) {}
 
   void Initialize() { InitializeServer(); }
 
@@ -197,12 +187,6 @@
   EXPECT_FALSE(server_stream()->handshake_confirmed());
 }
 
-TEST_P(QuicCryptoServerStreamTest, NotInitiallySendingStatelessRejects) {
-  Initialize();
-  EXPECT_FALSE(server_stream()->UseStatelessRejectsIfPeerSupported());
-  EXPECT_FALSE(server_stream()->PeerSupportsStatelessRejects());
-}
-
 TEST_P(QuicCryptoServerStreamTest, ConnectedAfterCHLO) {
   // CompleteCryptoHandshake returns the number of client hellos sent. This
   // test should send:
@@ -251,109 +235,6 @@
             server_session_->connection()->encryption_level());
 }
 
-TEST_P(QuicCryptoServerStreamTest, StatelessRejectAfterCHLO) {
-  SetQuicReloadableFlag(enable_quic_stateless_reject_support, true);
-  Initialize();
-
-  InitializeFakeClient(/* supports_stateless_rejects= */ true);
-  EXPECT_CALL(*server_connection_,
-              CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-  EXPECT_CALL(*client_connection_,
-              CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-  AdvanceHandshakeWithFakeClient();
-
-  // Check the server to make the sure the handshake did not succeed.
-  EXPECT_FALSE(server_stream()->encryption_established());
-  EXPECT_FALSE(server_stream()->handshake_confirmed());
-
-  // Check the client state to make sure that it received a server-designated
-  // connection id.
-  QuicCryptoClientConfig::CachedState* client_state =
-      client_crypto_config_.LookupOrCreate(server_id_);
-
-  ASSERT_TRUE(client_state->has_server_nonce());
-  ASSERT_FALSE(client_state->GetNextServerNonce().empty());
-  ASSERT_FALSE(client_state->has_server_nonce());
-
-  ASSERT_TRUE(client_state->has_server_designated_connection_id());
-  const QuicConnectionId server_designated_connection_id =
-      client_state->GetNextServerDesignatedConnectionId();
-  const QuicConnectionId expected_id = QuicUtils::CreateRandomConnectionId(
-      server_connection_->random_generator());
-  EXPECT_EQ(expected_id, server_designated_connection_id);
-  EXPECT_FALSE(client_state->has_server_designated_connection_id());
-  ASSERT_TRUE(client_state->IsComplete(QuicWallTime::FromUNIXSeconds(0)));
-}
-
-TEST_P(QuicCryptoServerStreamTest, ConnectedAfterStatelessHandshake) {
-  SetQuicReloadableFlag(enable_quic_stateless_reject_support, true);
-  Initialize();
-
-  InitializeFakeClient(/* supports_stateless_rejects= */ true);
-  EXPECT_CALL(*server_connection_,
-              CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-  EXPECT_CALL(*client_connection_,
-              CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-  AdvanceHandshakeWithFakeClient();
-
-  // On the first round, encryption will not be established.
-  EXPECT_FALSE(server_stream()->encryption_established());
-  EXPECT_FALSE(server_stream()->handshake_confirmed());
-  EXPECT_EQ(1, server_stream()->NumHandshakeMessages());
-  EXPECT_EQ(0, server_stream()->NumHandshakeMessagesWithServerNonces());
-
-  // Now check the client state.
-  QuicCryptoClientConfig::CachedState* client_state =
-      client_crypto_config_.LookupOrCreate(server_id_);
-
-  ASSERT_TRUE(client_state->has_server_designated_connection_id());
-  const QuicConnectionId server_designated_connection_id =
-      client_state->GetNextServerDesignatedConnectionId();
-  const QuicConnectionId expected_id = QuicUtils::CreateRandomConnectionId(
-      server_connection_->random_generator());
-  EXPECT_EQ(expected_id, server_designated_connection_id);
-  EXPECT_FALSE(client_state->has_server_designated_connection_id());
-  ASSERT_TRUE(client_state->IsComplete(QuicWallTime::FromUNIXSeconds(0)));
-
-  // Now create new client and server streams with the existing config
-  // and try the handshake again (0-RTT handshake).
-  InitializeServer();
-
-  InitializeFakeClient(/* supports_stateless_rejects= */ true);
-  // In the stateless case, the second handshake contains a server-nonce, so the
-  // AsyncStrikeRegisterVerification() case will still succeed (unlike a 0-RTT
-  // handshake).
-  AdvanceHandshakeWithFakeClient();
-
-  // On the second round, encryption will be established.
-  EXPECT_TRUE(server_stream()->encryption_established());
-  EXPECT_TRUE(server_stream()->handshake_confirmed());
-  EXPECT_EQ(1, server_stream()->NumHandshakeMessages());
-  EXPECT_EQ(1, server_stream()->NumHandshakeMessagesWithServerNonces());
-}
-
-TEST_P(QuicCryptoServerStreamTest, NoStatelessRejectIfNoClientSupport) {
-  SetQuicReloadableFlag(enable_quic_stateless_reject_support, true);
-  Initialize();
-
-  // The server is configured to use stateless rejects, but the client does not
-  // support it.
-  InitializeFakeClient(/* supports_stateless_rejects= */ false);
-  AdvanceHandshakeWithFakeClient();
-
-  // Check the server to make the sure the handshake did not succeed.
-  EXPECT_FALSE(server_stream()->encryption_established());
-  EXPECT_FALSE(server_stream()->handshake_confirmed());
-
-  // Check the client state to make sure that it did not receive a
-  // server-designated connection id.
-  QuicCryptoClientConfig::CachedState* client_state =
-      client_crypto_config_.LookupOrCreate(server_id_);
-
-  ASSERT_FALSE(client_state->has_server_designated_connection_id());
-  ASSERT_TRUE(client_state->IsComplete(QuicWallTime::FromUNIXSeconds(0)));
-}
-
 TEST_P(QuicCryptoServerStreamTest, ZeroRTT) {
   Initialize();
   InitializeFakeClient(/* supports_stateless_rejects= */ false);
@@ -450,21 +331,6 @@
   EXPECT_EQ(1, client_stream()->num_scup_messages_received());
 }
 
-TEST_P(QuicCryptoServerStreamTest, DoesPeerSupportStatelessRejects) {
-  Initialize();
-
-  QuicConfig stateless_reject_config = DefaultQuicConfigStatelessRejects();
-  stateless_reject_config.ToHandshakeMessage(&message_);
-  EXPECT_TRUE(
-      QuicCryptoServerStreamPeer::DoesPeerSupportStatelessRejects(message_));
-
-  message_.Clear();
-  QuicConfig stateful_reject_config = DefaultQuicConfig();
-  stateful_reject_config.ToHandshakeMessage(&message_);
-  EXPECT_FALSE(
-      QuicCryptoServerStreamPeer::DoesPeerSupportStatelessRejects(message_));
-}
-
 class QuicCryptoServerStreamTestWithFailingProofSource
     : public QuicCryptoServerStreamTest {
  public:
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 16d2584..9c7cd1e 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -1071,262 +1071,6 @@
   bool handshake_confirmed_;
 };
 
-struct StatelessRejectTestParams {
-  StatelessRejectTestParams(bool enable_stateless_rejects_via_flag,
-                            bool client_supports_statelesss_rejects,
-                            bool crypto_handshake_successful)
-      : enable_stateless_rejects_via_flag(enable_stateless_rejects_via_flag),
-        client_supports_statelesss_rejects(client_supports_statelesss_rejects),
-        crypto_handshake_successful(crypto_handshake_successful) {}
-
-  friend std::ostream& operator<<(std::ostream& os,
-                                  const StatelessRejectTestParams& p) {
-    os << "{  enable_stateless_rejects_via_flag: "
-       << p.enable_stateless_rejects_via_flag << std::endl;
-    os << " client_supports_statelesss_rejects: "
-       << p.client_supports_statelesss_rejects << std::endl;
-    os << " crypto_handshake_successful: " << p.crypto_handshake_successful
-       << " }";
-    return os;
-  }
-
-  // This only enables the stateless reject feature via the feature-flag.
-  // This should be a no-op if the peer does not support them.
-  bool enable_stateless_rejects_via_flag;
-  // Whether or not the client supports stateless rejects.
-  bool client_supports_statelesss_rejects;
-  // Should the initial crypto handshake succeed or not.
-  bool crypto_handshake_successful;
-};
-
-// Constructs various test permutations for stateless rejects.
-std::vector<StatelessRejectTestParams> GetStatelessRejectTestParams() {
-  std::vector<StatelessRejectTestParams> params;
-  for (bool enable_stateless_rejects_via_flag : {true, false}) {
-    for (bool client_supports_statelesss_rejects : {true, false}) {
-      for (bool crypto_handshake_successful : {true, false}) {
-        params.push_back(StatelessRejectTestParams(
-            enable_stateless_rejects_via_flag,
-            client_supports_statelesss_rejects, crypto_handshake_successful));
-      }
-    }
-  }
-  return params;
-}
-
-class QuicDispatcherStatelessRejectTest
-    : public QuicDispatcherTest,
-      public testing::WithParamInterface<StatelessRejectTestParams> {
- public:
-  QuicDispatcherStatelessRejectTest()
-      : QuicDispatcherTest(), crypto_stream1_(nullptr) {}
-
-  ~QuicDispatcherStatelessRejectTest() override {
-    if (crypto_stream1_) {
-      delete crypto_stream1_;
-    }
-  }
-
-  // This test setup assumes that all testing will be done using
-  // crypto_stream1_.
-  void SetUp() override {
-    QuicDispatcherTest::SetUp();
-    SetQuicReloadableFlag(enable_quic_stateless_reject_support,
-                          GetParam().enable_stateless_rejects_via_flag);
-  }
-
-  // Returns true or false, depending on whether the server will emit
-  // a stateless reject, depending upon the parameters of the test.
-  bool ExpectStatelessReject() {
-    return GetParam().enable_stateless_rejects_via_flag &&
-           !GetParam().crypto_handshake_successful &&
-           GetParam().client_supports_statelesss_rejects;
-  }
-
-  // Sets up dispatcher_, session1_, and crypto_stream1_ based on
-  // the test parameters.
-  QuicServerSessionBase* CreateSessionBasedOnTestParams(
-      QuicConnectionId connection_id,
-      const QuicSocketAddress& client_address) {
-    CreateSession(dispatcher_.get(), config_, connection_id, client_address,
-                  &mock_helper_, &mock_alarm_factory_, &crypto_config_,
-                  QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_);
-
-    crypto_stream1_ = new MockQuicCryptoServerStream(
-        crypto_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
-        session1_, session1_->stream_helper());
-    session1_->SetCryptoStream(crypto_stream1_);
-    crypto_stream1_->set_handshake_confirmed_for_testing(
-        GetParam().crypto_handshake_successful);
-    crypto_stream1_->SetPeerSupportsStatelessRejects(
-        GetParam().client_supports_statelesss_rejects);
-    return session1_;
-  }
-
-  MockQuicCryptoServerStream* crypto_stream1_;
-};
-
-// Parameterized test for stateless rejects.  Should test all
-// combinations of enabling/disabling, reject/no-reject for stateless
-// rejects.
-INSTANTIATE_TEST_SUITE_P(QuicDispatcherStatelessRejectTests,
-                         QuicDispatcherStatelessRejectTest,
-                         ::testing::ValuesIn(GetStatelessRejectTestParams()));
-
-TEST_P(QuicDispatcherStatelessRejectTest, ParameterizedBasicTest) {
-  CreateTimeWaitListManager();
-
-  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
-  QuicConnectionId connection_id = TestConnectionId(1);
-  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
-                                              QuicStringPiece("hq"), _))
-      .WillOnce(testing::Return(
-          CreateSessionBasedOnTestParams(connection_id, client_address)));
-  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-              ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(
-          Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
-            ValidatePacket(connection_id, packet);
-          })));
-  EXPECT_CALL(*dispatcher_,
-              ShouldCreateOrBufferPacketForConnection(connection_id, _))
-      .Times(1);
-
-  // Process the first packet for the connection.
-  ProcessPacket(client_address, connection_id, true, SerializeCHLO());
-  if (ExpectStatelessReject()) {
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-                CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, _, _));
-    // If this is a stateless reject, the crypto stream will close the
-    // connection.
-    session1_->connection()->CloseConnection(
-        QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, "stateless reject",
-        ConnectionCloseBehavior::SILENT_CLOSE);
-  }
-
-  // Send a second packet and check the results.  If this is a stateless reject,
-  // the existing connection_id will go on the time-wait list.
-  EXPECT_EQ(ExpectStatelessReject(),
-            time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
-  if (ExpectStatelessReject()) {
-    // The second packet will be processed on the time-wait list.
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, _, connection_id, _, _))
-        .Times(1);
-  } else {
-    // The second packet will trigger a packet-validation
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-                ProcessUdpPacket(_, _, _))
-        .Times(1)
-        .WillOnce(WithArg<2>(
-            Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
-              ValidatePacket(connection_id, packet);
-            })));
-  }
-  ProcessPacket(client_address, connection_id, true, "data");
-}
-
-TEST_P(QuicDispatcherStatelessRejectTest, CheapRejects) {
-  SetQuicReloadableFlag(quic_use_cheap_stateless_rejects, true);
-  CreateTimeWaitListManager();
-
-  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
-  QuicConnectionId connection_id = TestConnectionId(1);
-  if (GetParam().enable_stateless_rejects_via_flag) {
-    EXPECT_CALL(*dispatcher_,
-                CreateQuicSession(connection_id, client_address, _, _))
-        .Times(0);
-  } else {
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
-                                                QuicStringPiece("h2"), _))
-        .WillOnce(testing::Return(
-            CreateSessionBasedOnTestParams(connection_id, client_address)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
-              ValidatePacket(connection_id, packet);
-            })));
-  }
-
-  QUIC_LOG(INFO) << "ExpectStatelessReject: " << ExpectStatelessReject();
-  QUIC_LOG(INFO) << "Params: " << GetParam();
-  // Process the first packet for the connection.
-  CryptoHandshakeMessage client_hello =
-      crypto_test_utils::CreateCHLO({{"AEAD", "AESG"},
-                                     {"KEXS", "C255"},
-                                     {"COPT", "SREJ"},
-                                     {"NONC", "1234567890123456789012"},
-                                     {"ALPN", "h2"},
-                                     {"VER\0", "Q025"}},
-                                    kClientHelloMinimumSize);
-
-  if (GetParam().enable_stateless_rejects_via_flag) {
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, _, connection_id, _, _))
-        .Times(1);
-  } else {
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(connection_id, _))
-        .Times(1);
-  }
-  ProcessPacket(client_address, connection_id, true,
-                std::string(client_hello.GetSerialized().AsStringPiece()));
-
-  if (GetParam().enable_stateless_rejects_via_flag) {
-    EXPECT_EQ(true,
-              time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
-  }
-}
-
-TEST_P(QuicDispatcherStatelessRejectTest, BufferNonChlo) {
-  SetQuicReloadableFlag(quic_use_cheap_stateless_rejects, true);
-  CreateTimeWaitListManager();
-
-  const QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
-  const QuicConnectionId connection_id = TestConnectionId(1);
-
-  EXPECT_CALL(*dispatcher_,
-              ShouldCreateOrBufferPacketForConnection(connection_id, _))
-      .Times(1);
-  ProcessPacket(client_address, connection_id, true, "NOT DATA FOR A CHLO");
-
-  // Process the first packet for the connection.
-  CryptoHandshakeMessage client_hello =
-      crypto_test_utils::CreateCHLO({{"AEAD", "AESG"},
-                                     {"KEXS", "C255"},
-                                     {"NONC", "1234567890123456789012"},
-                                     {"ALPN", "h3"},
-                                     {"VER\0", "Q025"}},
-                                    kClientHelloMinimumSize);
-
-  // If stateless rejects are enabled then a connection will be created now
-  // and the buffered packet will be processed
-  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
-                                              QuicStringPiece("h3"), _))
-      .WillOnce(testing::Return(
-          CreateSessionBasedOnTestParams(connection_id, client_address)));
-  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-              ProcessUdpPacket(_, client_address, _))
-      .WillOnce(WithArg<2>(
-          Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
-            ValidatePacket(connection_id, packet);
-          })));
-  // Expect both packets to be passed to ProcessUdpPacket(). And one of them
-  // is already expected in CreateSessionBasedOnTestParams().
-  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-              ProcessUdpPacket(_, client_address, _))
-      .WillOnce(WithArg<2>(
-          Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
-            ValidatePacket(connection_id, packet);
-          })))
-      .RetiresOnSaturation();
-  ProcessPacket(client_address, connection_id, true,
-                std::string(client_hello.GetSerialized().AsStringPiece()));
-  EXPECT_FALSE(
-      time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
-}
-
 // Verify the stopgap test: Packets with truncated connection IDs should be
 // dropped.
 class QuicDispatcherTestStrayPacketConnectionId : public QuicDispatcherTest {};
@@ -2190,666 +1934,6 @@
   dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
 }
 
-// Test which exercises the async GetProof codepaths, especially in the context
-// of stateless rejection.
-class AsyncGetProofTest : public QuicDispatcherTest {
- public:
-  AsyncGetProofTest()
-      : QuicDispatcherTest(
-            std::unique_ptr<FakeProofSource>(new FakeProofSource())),
-        client_addr_(QuicIpAddress::Loopback4(), 1234),
-        client_addr_2_(QuicIpAddress::Loopback4(), 1357),
-        crypto_config_peer_(&crypto_config_),
-        server_addr_(QuicIpAddress::Any4(), 5),
-        signed_config_(new QuicSignedServerConfig) {
-    SetQuicReloadableFlag(enable_quic_stateless_reject_support, true);
-    SetQuicReloadableFlag(quic_use_cheap_stateless_rejects, true);
-  }
-
-  void SetUp() override {
-    QuicDispatcherTest::SetUp();
-
-    clock_ = QuicDispatcherPeer::GetHelper(dispatcher_.get())->GetClock();
-    QuicTransportVersion version = AllSupportedTransportVersions().front();
-    chlo_ = crypto_test_utils::GenerateDefaultInchoateCHLO(clock_, version,
-                                                           &crypto_config_);
-    chlo_.SetVector(kCOPT, QuicTagVector{kSREJ});
-    chlo_.SetStringPiece(kALPN, "HTTP/1");
-    // Pass an inchoate CHLO.
-    crypto_test_utils::GenerateFullCHLO(
-        chlo_, &crypto_config_, server_addr_, client_addr_, version, clock_,
-        signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
-        &full_chlo_);
-
-    crypto_test_utils::GenerateFullCHLO(
-        chlo_, &crypto_config_, server_addr_, client_addr_2_, version, clock_,
-        signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
-        &full_chlo_2_);
-
-    GetFakeProofSource()->Activate();
-  }
-
-  FakeProofSource* GetFakeProofSource() const {
-    return static_cast<FakeProofSource*>(crypto_config_peer_.GetProofSource());
-  }
-
-  std::string SerializeFullCHLO() {
-    return std::string(full_chlo_.GetSerialized().AsStringPiece());
-  }
-
-  std::string SerializeFullCHLOForClient2() {
-    return std::string(full_chlo_2_.GetSerialized().AsStringPiece());
-  }
-
-  std::string SerializeCHLO() {
-    return std::string(chlo_.GetSerialized().AsStringPiece());
-  }
-
-  // Sets up a session, and crypto stream based on the test parameters.
-  QuicServerSessionBase* GetSession(QuicConnectionId connection_id,
-                                    QuicSocketAddress client_address) {
-    auto it = sessions_.find(connection_id);
-    if (it != sessions_.end()) {
-      return it->second.session;
-    }
-
-    TestQuicSpdyServerSession* session;
-    CreateSession(dispatcher_.get(), config_, connection_id, client_address,
-                  &mock_helper_, &mock_alarm_factory_, &crypto_config_,
-                  QuicDispatcherPeer::GetCache(dispatcher_.get()), &session);
-
-    std::unique_ptr<MockQuicCryptoServerStream> crypto_stream(
-        new MockQuicCryptoServerStream(
-            crypto_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
-            session, session->stream_helper()));
-    session->SetCryptoStream(crypto_stream.get());
-    crypto_stream->SetPeerSupportsStatelessRejects(true);
-    const bool ok =
-        sessions_
-            .insert(std::make_pair(
-                connection_id, SessionInfo{session, std::move(crypto_stream)}))
-            .second;
-    CHECK(ok);
-    return session;
-  }
-
- protected:
-  const QuicSocketAddress client_addr_;
-  const QuicSocketAddress client_addr_2_;
-  CryptoHandshakeMessage chlo_;
-
- private:
-  QuicCryptoServerConfigPeer crypto_config_peer_;
-  QuicSocketAddress server_addr_;
-  QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
-  const QuicClock* clock_;
-  CryptoHandshakeMessage full_chlo_;    // CHLO for client_addr_
-  CryptoHandshakeMessage full_chlo_2_;  // CHLO for client_addr_2_
-
-  struct SessionInfo {
-    TestQuicSpdyServerSession* session;
-    std::unique_ptr<MockQuicCryptoServerStream> crypto_stream;
-  };
-  std::map<QuicConnectionId, SessionInfo> sessions_;
-};
-
-// Test a simple situation of connections which the StatelessRejector will
-// accept.
-TEST_F(AsyncGetProofTest, BasicAccept) {
-  QuicConnectionId conn_id = TestConnectionId(1);
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id, _));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_addr_,
-                                                QuicStringPiece("HTTP/1"), _))
-        .WillOnce(testing::Return(GetSession(conn_id, client_addr_)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id, packet);
-            })));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id, packet);
-            })));
-  }
-
-  // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  check.Call(1);
-  // Complete the ProofSource::GetProof call and verify that a session is
-  // created.
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-
-  check.Call(2);
-  // Verify that a data packet gets processed immediately.
-  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
-}
-
-TEST_F(AsyncGetProofTest, RestorePacketContext) {
-  QuicConnectionId conn_id_1 = TestConnectionId(1);
-  QuicConnectionId conn_id_2 = TestConnectionId(2);
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id_1, _));
-
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_1, client_addr_,
-                                                QuicStringPiece("HTTP/1"), _))
-        .WillOnce(testing::Return(GetSession(conn_id_1, client_addr_)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id_1, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillRepeatedly(WithArg<2>(
-            Invoke([this, conn_id_1](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id_1, packet);
-            })));
-
-    EXPECT_CALL(check, Call(2));
-
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id_2, _));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_2, client_addr_2_,
-                                                QuicStringPiece("HTTP/1"), _))
-        .WillOnce(testing::Return(GetSession(conn_id_2, client_addr_2_)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id_2, client_addr_2_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id_2](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id_2, packet);
-            })));
-  }
-
-  // Send a CHLO that the StatelessRejector will accept.
-  dispatcher_->custom_packet_context_ = "connection 1";
-  ProcessPacket(client_addr_, conn_id_1, true, SerializeFullCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Send another CHLO that the StatelessRejector will accept.
-  dispatcher_->custom_packet_context_ = "connection 2";
-  ProcessPacket(client_addr_2_, conn_id_2, true, SerializeFullCHLOForClient2());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
-
-  // Complete the first ProofSource::GetProof call and verify that a session is
-  // created.
-  check.Call(1);
-
-  EXPECT_EQ(client_addr_2_, dispatcher_->current_client_address());
-  EXPECT_EQ(client_addr_2_, dispatcher_->current_peer_address());
-  EXPECT_EQ("connection 2", dispatcher_->custom_packet_context_);
-
-  // Runs the async proof callback for conn_id_1 from client_addr_.
-  GetFakeProofSource()->InvokePendingCallback(0);
-
-  EXPECT_EQ(client_addr_, dispatcher_->current_client_address());
-  EXPECT_EQ(client_addr_, dispatcher_->current_peer_address());
-  EXPECT_EQ("connection 1", dispatcher_->custom_packet_context_);
-
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Complete the second ProofSource::GetProof call and verify that a session is
-  // created.
-  check.Call(2);
-
-  EXPECT_EQ(client_addr_, dispatcher_->current_client_address());
-  EXPECT_EQ(client_addr_, dispatcher_->current_peer_address());
-  EXPECT_EQ("connection 1", dispatcher_->custom_packet_context_);
-
-  // Runs the async proof callback for conn_id_2 from client_addr_2_.
-  GetFakeProofSource()->InvokePendingCallback(0);
-
-  EXPECT_EQ(client_addr_2_, dispatcher_->current_client_address());
-  EXPECT_EQ(client_addr_2_, dispatcher_->current_peer_address());
-  EXPECT_EQ("connection 2", dispatcher_->custom_packet_context_);
-
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-}
-
-// Test a simple situation of connections which the StatelessRejector will
-// reject.
-TEST_F(AsyncGetProofTest, BasicReject) {
-  CreateTimeWaitListManager();
-
-  QuicConnectionId conn_id = TestConnectionId(1);
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*time_wait_list_manager_,
-                AddConnectionIdToTimeWait(conn_id, _, _, _, _));
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id, _, _));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_addr_,
-                                                QuicStringPiece("hq"), _))
-        .Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id, _, _));
-  }
-
-  // Send a CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id, true, SerializeCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Complete the ProofSource::GetProof call and verify that the connection and
-  // packet are processed by the time wait list manager.
-  check.Call(1);
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-
-  // Verify that a data packet is passed to the time wait list manager.
-  check.Call(2);
-  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
-}
-
-// Test a situation with multiple interleaved connections which the
-// StatelessRejector will accept.
-TEST_F(AsyncGetProofTest, MultipleAccept) {
-  QuicConnectionId conn_id_1 = TestConnectionId(1);
-  QuicConnectionId conn_id_2 = TestConnectionId(2);
-  QuicBufferedPacketStore* store =
-      QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id_2, _));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_2, client_addr_,
-                                                QuicStringPiece("HTTP/1"), _))
-        .WillOnce(testing::Return(GetSession(conn_id_2, client_addr_)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id_2, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id_2](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id_2, packet);
-            })));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id_2, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id_2](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id_2, packet);
-            })));
-
-    EXPECT_CALL(check, Call(3));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id_1, _));
-
-    EXPECT_CALL(check, Call(4));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_1, client_addr_,
-                                                QuicStringPiece("HTTP/1"), _))
-        .WillOnce(testing::Return(GetSession(conn_id_1, client_addr_)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id_1, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillRepeatedly(WithArg<2>(
-            Invoke([this, conn_id_1](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id_1, packet);
-            })));
-  }
-
-  // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id_1, true, SerializeFullCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Send another CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id_2, true, SerializeFullCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
-
-  // Complete the second ProofSource::GetProof call and verify that a session is
-  // created.
-  check.Call(1);
-  GetFakeProofSource()->InvokePendingCallback(1);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Verify that a data packet on that connection gets processed immediately.
-  check.Call(2);
-  ProcessPacket(client_addr_, conn_id_2, true, "My name is Data");
-
-  // Verify that a data packet on the other connection does not get processed
-  // yet.
-  check.Call(3);
-  ProcessPacket(client_addr_, conn_id_1, true, "My name is Data");
-  EXPECT_TRUE(store->HasBufferedPackets(conn_id_1));
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id_2));
-
-  // Complete the first ProofSource::GetProof call and verify that a session is
-  // created and the buffered packet is processed.
-  check.Call(4);
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-}
-
-// Test a situation with multiple interleaved connections which the
-// StatelessRejector will reject.
-TEST_F(AsyncGetProofTest, MultipleReject) {
-  CreateTimeWaitListManager();
-
-  QuicConnectionId conn_id_1 = TestConnectionId(1);
-  QuicConnectionId conn_id_2 = TestConnectionId(2);
-  QuicBufferedPacketStore* store =
-      QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_2, client_addr_, _, _))
-        .Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                AddConnectionIdToTimeWait(conn_id_2, _, _, _, _));
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id_2, _, _));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id_2, _, _));
-
-    EXPECT_CALL(check, Call(3));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id_1, _));
-
-    EXPECT_CALL(check, Call(4));
-    EXPECT_CALL(*time_wait_list_manager_,
-                AddConnectionIdToTimeWait(conn_id_1, _, _, _, _));
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id_1, _, _));
-  }
-
-  // Send a CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id_1, true, SerializeCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Send another CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id_2, true, SerializeCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
-
-  // Complete the second ProofSource::GetProof call and verify that the
-  // connection and packet are processed by the time wait manager.
-  check.Call(1);
-  GetFakeProofSource()->InvokePendingCallback(1);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Verify that a data packet on that connection gets processed immediately by
-  // the time wait manager.
-  check.Call(2);
-  ProcessPacket(client_addr_, conn_id_2, true, "My name is Data");
-
-  // Verify that a data packet on the first connection gets buffered.
-  check.Call(3);
-  ProcessPacket(client_addr_, conn_id_1, true, "My name is Data");
-  EXPECT_TRUE(store->HasBufferedPackets(conn_id_1));
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id_2));
-
-  // Complete the first ProofSource::GetProof call and verify that the CHLO is
-  // processed by the time wait manager and the remaining packets are discarded.
-  check.Call(4);
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id_1));
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id_2));
-}
-
-// Test a situation with multiple identical CHLOs which the StatelessRejector
-// will reject.
-TEST_F(AsyncGetProofTest, MultipleIdenticalReject) {
-  CreateTimeWaitListManager();
-
-  QuicConnectionId conn_id_1 = TestConnectionId(1);
-  QuicBufferedPacketStore* store =
-      QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id_1, _));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id_1, client_addr_,
-                                                QuicStringPiece(), _))
-        .Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                AddConnectionIdToTimeWait(conn_id_1, _, _, _, _));
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id_1, _, _));
-  }
-
-  // Send a CHLO that the StatelessRejector will reject.
-  ProcessPacket(client_addr_, conn_id_1, true, SerializeCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id_1));
-
-  // Send an identical CHLO which should get buffered.
-  check.Call(1);
-  ProcessPacket(client_addr_, conn_id_1, true, SerializeCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-  EXPECT_TRUE(store->HasBufferedPackets(conn_id_1));
-
-  // Complete the ProofSource::GetProof call and verify that the CHLO is
-  // rejected and the copy is discarded.
-  check.Call(2);
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id_1));
-}
-
-// Test dispatcher behavior when packets time out of the buffer while CHLO
-// validation is still pending.
-TEST_F(AsyncGetProofTest, BufferTimeout) {
-  CreateTimeWaitListManager();
-
-  QuicConnectionId conn_id = TestConnectionId(1);
-  QuicBufferedPacketStore* store =
-      QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
-  QuicBufferedPacketStorePeer::set_clock(store, mock_helper_.GetClock());
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id, _));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*time_wait_list_manager_,
-                ProcessPacket(_, client_addr_, conn_id, _, _));
-    EXPECT_CALL(*dispatcher_,
-                CreateQuicSession(conn_id, client_addr_, QuicStringPiece(), _))
-        .Times(0);
-  }
-
-  // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id));
-
-  // Send a data packet that will get buffered
-  check.Call(1);
-  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
-  EXPECT_TRUE(store->HasBufferedPackets(conn_id));
-
-  // Pretend that enough time has gone by for the packets to get expired out of
-  // the buffer
-  mock_helper_.AdvanceTime(
-      QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs));
-  QuicBufferedPacketStorePeer::expiration_alarm(store)->Cancel();
-  store->OnExpirationTimeout();
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id));
-  EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
-
-  // Now allow the CHLO validation to complete, and verify that no connection
-  // gets created.
-  check.Call(2);
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id));
-  EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
-}
-
-// Test behavior when packets time out of the buffer *and* the connection times
-// out of the time wait manager while CHLO validation is still pending.  This
-// *should* be impossible, but anything can happen with timing conditions.
-TEST_F(AsyncGetProofTest, TimeWaitTimeout) {
-  QuicConnectionId conn_id = TestConnectionId(1);
-  QuicBufferedPacketStore* store =
-      QuicDispatcherPeer::GetBufferedPackets(dispatcher_.get());
-  QuicBufferedPacketStorePeer::set_clock(store, mock_helper_.GetClock());
-  CreateTimeWaitListManager();
-  QuicTimeWaitListManagerPeer::set_clock(time_wait_list_manager_,
-                                         mock_helper_.GetClock());
-
-  testing::MockFunction<void(int check_point)> check;
-  {
-    InSequence s;
-    EXPECT_CALL(check, Call(1));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id, _));
-
-    EXPECT_CALL(check, Call(2));
-    EXPECT_CALL(*dispatcher_,
-                ShouldCreateOrBufferPacketForConnection(conn_id, _));
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(conn_id, client_addr_,
-                                                QuicStringPiece("HTTP/1"), _))
-        .WillOnce(testing::Return(GetSession(conn_id, client_addr_)));
-    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(
-                    GetSession(conn_id, client_addr_)->connection()),
-                ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
-              ValidatePacket(conn_id, packet);
-            })));
-  }
-
-  // Send a CHLO that the StatelessRejector will accept.
-  ProcessPacket(client_addr_, conn_id, true, SerializeFullCHLO());
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id));
-
-  // Send a data packet that will get buffered
-  check.Call(1);
-  ProcessPacket(client_addr_, conn_id, true, "My name is Data");
-  EXPECT_TRUE(store->HasBufferedPackets(conn_id));
-
-  // Pretend that enough time has gone by for the packets to get expired out of
-  // the buffer
-  mock_helper_.AdvanceTime(
-      QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs));
-  QuicBufferedPacketStorePeer::expiration_alarm(store)->Cancel();
-  store->OnExpirationTimeout();
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id));
-  EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
-
-  // Pretend that enough time has gone by for the connection ID to be removed
-  // from the time wait manager
-  mock_helper_.AdvanceTime(
-      QuicTimeWaitListManagerPeer::time_wait_period(time_wait_list_manager_));
-  QuicTimeWaitListManagerPeer::expiration_alarm(time_wait_list_manager_)
-      ->Cancel();
-  time_wait_list_manager_->CleanUpOldConnectionIds();
-  EXPECT_FALSE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
-
-  // Now allow the CHLO validation to complete.  Expect that a connection is
-  // indeed created, since QUIC has forgotten that this connection ever existed.
-  // This is a miniscule corner case which should never happen in the wild, so
-  // really we are just verifying that the dispatcher does not explode in this
-  // situation.
-  check.Call(2);
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-  EXPECT_FALSE(store->HasBufferedPackets(conn_id));
-  EXPECT_FALSE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
-}
-
-// Regression test for
-// https://bugs.chromium.org/p/chromium/issues/detail?id=748289
-TEST_F(AsyncGetProofTest, DispatcherFailedToPickUpVersionForAsyncProof) {
-  // This test mimics the scenario that dispatcher's framer can have different
-  // version when async proof returns.
-  // When dispatcher sends SREJ, the SREJ frame can be serialized in
-  // different endianness which causes the client to close the connection
-  // because of QUIC_INVALID_STREAM_DATA.
-
-  SetQuicReloadableFlag(quic_disable_version_39, false);
-  ParsedQuicVersion chlo_version(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43);
-  chlo_.SetVersion(kVER, chlo_version);
-  // Send a CHLO with v43. Dispatcher framer's version is set to v43.
-  ProcessPacket(client_addr_, TestConnectionId(1), true, chlo_version,
-                SerializeCHLO(), CONNECTION_ID_PRESENT,
-                PACKET_4BYTE_PACKET_NUMBER, 1);
-
-  // Send another CHLO with v39. Dispatcher framer's version is set to v39.
-  chlo_version.transport_version = QUIC_VERSION_39;
-  chlo_.SetVersion(kVER, chlo_version);
-  // Invalidate the cached serialized form.
-  chlo_.MarkDirty();
-  ProcessPacket(client_addr_, TestConnectionId(2), true, chlo_version,
-                SerializeCHLO(), CONNECTION_ID_PRESENT,
-                PACKET_4BYTE_PACKET_NUMBER, 1);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
-
-  // Complete the ProofSource::GetProof call for v43. This would cause the
-  // version mismatch between the CHLO packet and the dispatcher.
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-}
-
-// Regression test for b/116200989.
-TEST_F(AsyncGetProofTest, DispatcherHasWrongLastPacketIsIetfQuic) {
-  // Process a packet of v44.
-  ParsedQuicVersion chlo_version(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44);
-  chlo_.SetVersion(kVER, chlo_version);
-  ProcessPacket(client_addr_, TestConnectionId(1), true, chlo_version,
-                SerializeCHLO(), CONNECTION_ID_PRESENT,
-                PACKET_4BYTE_PACKET_NUMBER, 1);
-
-  // Process another packet of v43.
-  chlo_version.transport_version = QUIC_VERSION_43;
-  chlo_.SetVersion(kVER, chlo_version);
-  // Invalidate the cached serialized form.
-  chlo_.MarkDirty();
-  ProcessPacket(client_addr_, TestConnectionId(2), true, chlo_version,
-                SerializeCHLO(), CONNECTION_ID_PRESENT,
-                PACKET_4BYTE_PACKET_NUMBER, 1);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 2);
-
-  // Complete the ProofSource::GetProof call for v44.
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 1);
-
-  // Complete the ProofSource::GetProof call for v43.
-  GetFakeProofSource()->InvokePendingCallback(0);
-  ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
-}
-
 }  // namespace
 }  // namespace test
 }  // namespace quic