BASELINE: Update Chromium to 96.0.4664.181

Change-Id: I762cd1da89d73aa6313b4a753fe126c34833f046
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

31 files changed, 666 insertions, 740 deletions

diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/crypto_test_utils.cc b/chromium/net/third_party/quiche/src/quic/test_tools/crypto_test_utils.cc
index d28b4faff85..febd8d30b32 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/crypto_test_utils.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/crypto_test_utils.cc
@@ -634,22 +634,6 @@ void CompareClientAndServerKeys(QuicCryptoClientStream* client,
       "subkey secret", client_subkey_secret.data(),
       client_subkey_secret.length(), server_subkey_secret.data(),
       server_subkey_secret.length());
-
-  const char kSampleLabel[] = "label";
-  const char kSampleContext[] = "context";
-  const size_t kSampleOutputLength = 32;
-  std::string client_key_extraction;
-  std::string server_key_extraction;
-  EXPECT_TRUE(client->ExportKeyingMaterial(kSampleLabel, kSampleContext,
-                                           kSampleOutputLength,
-                                           &client_key_extraction));
-  EXPECT_TRUE(server->ExportKeyingMaterial(kSampleLabel, kSampleContext,
-                                           kSampleOutputLength,
-                                           &server_key_extraction));
-  quiche::test::CompareCharArraysWithHexError(
-      "sample key extraction", client_key_extraction.data(),
-      client_key_extraction.length(), server_key_extraction.data(),
-      server_key_extraction.length());
 }
 
 QuicTag ParseTag(const char* tagstr) {
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.cc b/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.cc
index fad128d9a39..1f17c8a1f35 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.cc
@@ -22,7 +22,9 @@ void FailingProofSource::GetProof(const QuicSocketAddress& /*server_address*/,
 QuicReferenceCountedPointer<ProofSource::Chain>
 FailingProofSource::GetCertChain(const QuicSocketAddress& /*server_address*/,
                                  const QuicSocketAddress& /*client_address*/,
-                                 const std::string& /*hostname*/) {
+                                 const std::string& /*hostname*/,
+                                 bool* cert_matched_sni) {
+  *cert_matched_sni = false;
   return QuicReferenceCountedPointer<Chain>();
 }
 
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.h b/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.h
index 447b77066bd..db5a19714cb 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/failing_proof_source.h
@@ -23,8 +23,8 @@ class FailingProofSource : public ProofSource {
 
   QuicReferenceCountedPointer<Chain> GetCertChain(
       const QuicSocketAddress& server_address,
-      const QuicSocketAddress& client_address,
-      const std::string& hostname) override;
+      const QuicSocketAddress& client_address, const std::string& hostname,
+      bool* cert_matched_sni) override;
 
   void ComputeTlsSignature(
       const QuicSocketAddress& server_address,
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.cc b/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.cc
index 1109d659fac..0f7cb194df6 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.cc
@@ -96,9 +96,10 @@ void FakeProofSource::GetProof(
 
 QuicReferenceCountedPointer<ProofSource::Chain> FakeProofSource::GetCertChain(
     const QuicSocketAddress& server_address,
-    const QuicSocketAddress& client_address,
-    const std::string& hostname) {
-  return delegate_->GetCertChain(server_address, client_address, hostname);
+    const QuicSocketAddress& client_address, const std::string& hostname,
+    bool* cert_matched_sni) {
+  return delegate_->GetCertChain(server_address, client_address, hostname,
+                                 cert_matched_sni);
 }
 
 void FakeProofSource::ComputeTlsSignature(
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.h b/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.h
index c088d43a9bb..b135129c08c 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source.h
@@ -43,8 +43,8 @@ class FakeProofSource : public ProofSource {
                 std::unique_ptr<ProofSource::Callback> callback) override;
   QuicReferenceCountedPointer<Chain> GetCertChain(
       const QuicSocketAddress& server_address,
-      const QuicSocketAddress& client_address,
-      const std::string& hostname) override;
+      const QuicSocketAddress& client_address, const std::string& hostname,
+      bool* cert_matched_sni) override;
   void ComputeTlsSignature(
       const QuicSocketAddress& server_address,
       const QuicSocketAddress& client_address,
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source_handle.cc b/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source_handle.cc
index f34247e9bae..8c1e7f870f1 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source_handle.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/fake_proof_source_handle.cc
@@ -94,19 +94,23 @@ QuicAsyncStatus FakeProofSourceHandle::SelectCertificate(
     callback()->OnSelectCertificateDone(
         /*ok=*/false,
         /*is_sync=*/true, nullptr, /*handshake_hints=*/absl::string_view(),
-        /*ticket_encryption_key=*/absl::string_view());
+        /*ticket_encryption_key=*/absl::string_view(),
+        /*cert_matched_sni=*/false);
     return QUIC_FAILURE;
   }
 
   QUICHE_DCHECK(select_cert_action_ == Action::DELEGATE_SYNC);
+  bool cert_matched_sni;
   QuicReferenceCountedPointer<ProofSource::Chain> chain =
-      delegate_->GetCertChain(server_address, client_address, hostname);
+      delegate_->GetCertChain(server_address, client_address, hostname,
+                              &cert_matched_sni);
 
   bool ok = chain && !chain->certs.empty();
   callback_->OnSelectCertificateDone(
       ok, /*is_sync=*/true, chain.get(),
       /*handshake_hints=*/absl::string_view(),
-      /*ticket_encryption_key=*/absl::string_view());
+      /*ticket_encryption_key=*/absl::string_view(),
+      /*cert_matched_sni=*/cert_matched_sni);
   return ok ? QUIC_SUCCESS : QUIC_FAILURE;
 }
 
@@ -182,16 +186,19 @@ void FakeProofSourceHandle::SelectCertOperation::Run() {
         /*ok=*/false,
         /*is_sync=*/false, nullptr,
         /*handshake_hints=*/absl::string_view(),
-        /*ticket_encryption_key=*/absl::string_view());
+        /*ticket_encryption_key=*/absl::string_view(),
+        /*cert_matched_sni=*/false);
   } else if (action_ == Action::DELEGATE_ASYNC) {
+    bool cert_matched_sni;
     QuicReferenceCountedPointer<ProofSource::Chain> chain =
         delegate_->GetCertChain(args_.server_address, args_.client_address,
-                                args_.hostname);
+                                args_.hostname, &cert_matched_sni);
     bool ok = chain && !chain->certs.empty();
     callback_->OnSelectCertificateDone(
         ok, /*is_sync=*/false, chain.get(),
         /*handshake_hints=*/absl::string_view(),
-        /*ticket_encryption_key=*/absl::string_view());
+        /*ticket_encryption_key=*/absl::string_view(),
+        /*cert_matched_sni=*/cert_matched_sni);
   } else {
     QUIC_BUG(quic_bug_10139_1)
         << "Unexpected action: " << static_cast<int>(action_);
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.cc b/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.cc
index 6274f201d86..63858c94a1a 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.cc
@@ -18,9 +18,9 @@ MockTimeWaitListManager::MockTimeWaitListManager(
     : QuicTimeWaitListManager(writer, visitor, clock, alarm_factory) {
   // Though AddConnectionIdToTimeWait is mocked, we want to retain its
   // functionality.
-  EXPECT_CALL(*this, AddConnectionIdToTimeWait(_, _, _))
+  EXPECT_CALL(*this, AddConnectionIdToTimeWait(_, _))
       .Times(testing::AnyNumber());
-  ON_CALL(*this, AddConnectionIdToTimeWait(_, _, _))
+  ON_CALL(*this, AddConnectionIdToTimeWait(_, _))
       .WillByDefault(
           Invoke(this, &MockTimeWaitListManager::
                            QuicTimeWaitListManager_AddConnectionIdToTimeWait));
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.h b/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.h
index 12bf0801082..1d3cfd51a70 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/mock_quic_time_wait_list_manager.h
@@ -19,19 +19,15 @@ class MockTimeWaitListManager : public QuicTimeWaitListManager {
                           QuicAlarmFactory* alarm_factory);
   ~MockTimeWaitListManager() override;
 
-  MOCK_METHOD(void,
-              AddConnectionIdToTimeWait,
-              (QuicConnectionId connection_id,
-               QuicTimeWaitListManager::TimeWaitAction action,
+  MOCK_METHOD(void, AddConnectionIdToTimeWait,
+              (QuicTimeWaitListManager::TimeWaitAction action,
                quic::TimeWaitConnectionInfo info),
               (override));
 
   void QuicTimeWaitListManager_AddConnectionIdToTimeWait(
-      QuicConnectionId connection_id,
       QuicTimeWaitListManager::TimeWaitAction action,
       quic::TimeWaitConnectionInfo info) {
-    QuicTimeWaitListManager::AddConnectionIdToTimeWait(connection_id, action,
-                                                       std::move(info));
+    QuicTimeWaitListManager::AddConnectionIdToTimeWait(action, std::move(info));
   }
 
   MOCK_METHOD(void,
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/packet_dropping_test_writer.cc b/chromium/net/third_party/quiche/src/quic/test_tools/packet_dropping_test_writer.cc
index 76dd778734c..079b2286d40 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/packet_dropping_test_writer.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/packet_dropping_test_writer.cc
@@ -18,7 +18,7 @@ const int32_t kMinSuccesfulWritesAfterPacketLoss = 2;
 
 // An alarm that is scheduled if a blocked socket is simulated to indicate
 // it's writable again.
-class WriteUnblockedAlarm : public QuicAlarm::Delegate {
+class WriteUnblockedAlarm : public QuicAlarm::DelegateWithoutContext {
  public:
   explicit WriteUnblockedAlarm(PacketDroppingTestWriter* writer)
       : writer_(writer) {}
@@ -34,7 +34,7 @@ class WriteUnblockedAlarm : public QuicAlarm::Delegate {
 
 // An alarm that is scheduled every time a new packet is to be written at a
 // later point.
-class DelayAlarm : public QuicAlarm::Delegate {
+class DelayAlarm : public QuicAlarm::DelegateWithoutContext {
  public:
   explicit DelayAlarm(PacketDroppingTestWriter* writer) : writer_(writer) {}
 
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.cc b/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.cc
index ab76c445d02..37f182a767e 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.cc
@@ -37,7 +37,7 @@ void TestHeadersHandler::OnDecodingCompleted() {
 }
 
 void TestHeadersHandler::OnDecodingErrorDetected(
-    absl::string_view error_message) {
+    QuicErrorCode /*error_code*/, absl::string_view error_message) {
   ASSERT_FALSE(decoding_completed_);
   ASSERT_FALSE(decoding_error_detected_);
 
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h b/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h
index 2220bd4e37a..b6bff7802c8 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h
@@ -10,6 +10,7 @@
 #include "absl/strings/string_view.h"
 #include "quic/core/qpack/qpack_decoder.h"
 #include "quic/core/qpack/qpack_progressive_decoder.h"
+#include "quic/core/quic_error_codes.h"
 #include "quic/platform/api/quic_test.h"
 #include "quic/test_tools/qpack/qpack_test_utils.h"
 #include "spdy/core/spdy_header_block.h"
@@ -51,7 +52,8 @@ class TestHeadersHandler
   void OnHeaderDecoded(absl::string_view name,
                        absl::string_view value) override;
   void OnDecodingCompleted() override;
-  void OnDecodingErrorDetected(absl::string_view error_message) override;
+  void OnDecodingErrorDetected(QuicErrorCode error_code,
+                               absl::string_view error_message) override;
 
   // Release decoded header list.  Must only be called if decoding is complete
   // and no errors have been detected.
@@ -81,9 +83,8 @@ class MockHeadersHandler
               (absl::string_view name, absl::string_view value),
               (override));
   MOCK_METHOD(void, OnDecodingCompleted, (), (override));
-  MOCK_METHOD(void,
-              OnDecodingErrorDetected,
-              (absl::string_view error_message),
+  MOCK_METHOD(void, OnDecodingErrorDetected,
+              (QuicErrorCode error_code, absl::string_view error_message),
               (override));
 };
 
@@ -95,7 +96,8 @@ class NoOpHeadersHandler
   void OnHeaderDecoded(absl::string_view /*name*/,
                        absl::string_view /*value*/) override {}
   void OnDecodingCompleted() override {}
-  void OnDecodingErrorDetected(absl::string_view /*error_message*/) override {}
+  void OnDecodingErrorDetected(QuicErrorCode /*error_code*/,
+                               absl::string_view /*error_message*/) override {}
 };
 
 void QpackDecode(
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.cc
index 43c345094ef..6125f67adce 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.cc
@@ -528,5 +528,12 @@ QuicConnectionPeer::GetSelfIssuedConnectionIdManager(
   return connection->self_issued_cid_manager_.get();
 }
 
+// static
+std::unique_ptr<QuicSelfIssuedConnectionIdManager>
+QuicConnectionPeer::MakeSelfIssuedConnectionIdManager(
+    QuicConnection* connection) {
+  return connection->MakeSelfIssuedConnectionIdManager();
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h b/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h
index 99b8b94fd74..849ede6cf93 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h
@@ -216,6 +216,9 @@ class QuicConnectionPeer {
 
   static QuicSelfIssuedConnectionIdManager* GetSelfIssuedConnectionIdManager(
       QuicConnection* connection);
+
+  static std::unique_ptr<QuicSelfIssuedConnectionIdManager>
+  MakeSelfIssuedConnectionIdManager(QuicConnection* connection);
 };
 
 }  // namespace test
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.cc
index 8002170ad90..341d5acfc84 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.cc
@@ -133,5 +133,11 @@ const QuicSession* QuicDispatcherPeer::FindSession(
              : it->second.get();
 }
 
+// static
+QuicAlarm* QuicDispatcherPeer::GetClearResetAddressesAlarm(
+    QuicDispatcher* dispatcher) {
+  return dispatcher->clear_stateless_reset_addresses_alarm_.get();
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.h b/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.h
index fc8ab2014ae..ec83be4f9f2 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_dispatcher_peer.h
@@ -76,6 +76,8 @@ class QuicDispatcherPeer {
   // Find the corresponding session if exsits.
   static const QuicSession* FindSession(const QuicDispatcher* dispatcher,
                                         QuicConnectionId id);
+
+  static QuicAlarm* GetClearResetAddressesAlarm(QuicDispatcher* dispatcher);
 };
 
 }  // namespace test
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.cc
index a27f073e993..f0f99ee989e 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.cc
@@ -40,18 +40,14 @@ spdy::SpdyFramer* QuicSpdySessionPeer::GetSpdyFramer(QuicSpdySession* session) {
 }
 
 void QuicSpdySessionPeer::SetMaxInboundHeaderListSize(
-    QuicSpdySession* session,
-    size_t max_inbound_header_size) {
+    QuicSpdySession* session, size_t max_inbound_header_size) {
   session->set_max_inbound_header_list_size(max_inbound_header_size);
 }
 
 // static
 size_t QuicSpdySessionPeer::WriteHeadersOnHeadersStream(
-    QuicSpdySession* session,
-    QuicStreamId id,
-    spdy::SpdyHeaderBlock headers,
-    bool fin,
-    const spdy::SpdyStreamPrecedence& precedence,
+    QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
+    bool fin, const spdy::SpdyStreamPrecedence& precedence,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   return session->WriteHeadersOnHeadersStream(
       id, std::move(headers), fin, precedence, std::move(ack_listener));
@@ -100,22 +96,22 @@ QpackReceiveStream* QuicSpdySessionPeer::GetQpackEncoderReceiveStream(
 }
 
 // static
-void QuicSpdySessionPeer::SetH3DatagramSupported(QuicSpdySession* session,
-                                                 bool h3_datagram_supported) {
-  session->h3_datagram_supported_ = h3_datagram_supported;
+void QuicSpdySessionPeer::SetHttpDatagramSupport(
+    QuicSpdySession* session, HttpDatagramSupport http_datagram_support) {
+  session->http_datagram_support_ = http_datagram_support;
 }
 
 // static
-bool QuicSpdySessionPeer::ShouldNegotiateHttp3Datagram(
+HttpDatagramSupport QuicSpdySessionPeer::LocalHttpDatagramSupport(
     QuicSpdySession* session) {
-  return session->ShouldNegotiateHttp3Datagram();
+  return session->LocalHttpDatagramSupport();
 }
 
 // static
-void QuicSpdySessionPeer::EnableWebTransport(QuicSpdySession& session) {
-  QUICHE_DCHECK(session.WillNegotiateWebTransport());
-  session.h3_datagram_supported_ = true;
-  session.peer_supports_webtransport_ = true;
+void QuicSpdySessionPeer::EnableWebTransport(QuicSpdySession* session) {
+  QUICHE_DCHECK(session->WillNegotiateWebTransport());
+  SetHttpDatagramSupport(session, HttpDatagramSupport::kDraft04);
+  session->peer_supports_webtransport_ = true;
 }
 
 }  // namespace test
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h b/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h
index 0d06c4ddfad..ba28e67c0ee 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h
@@ -7,6 +7,7 @@
 
 #include "quic/core/http/quic_receive_control_stream.h"
 #include "quic/core/http/quic_send_control_stream.h"
+#include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/qpack/qpack_receive_stream.h"
 #include "quic/core/qpack/qpack_send_stream.h"
 #include "quic/core/quic_packets.h"
@@ -16,7 +17,6 @@
 namespace quic {
 
 class QuicHeadersStream;
-class QuicSpdySession;
 
 namespace test {
 
@@ -32,11 +32,8 @@ class QuicSpdySessionPeer {
   static void SetMaxInboundHeaderListSize(QuicSpdySession* session,
                                           size_t max_inbound_header_size);
   static size_t WriteHeadersOnHeadersStream(
-      QuicSpdySession* session,
-      QuicStreamId id,
-      spdy::SpdyHeaderBlock headers,
-      bool fin,
-      const spdy::SpdyStreamPrecedence& precedence,
+      QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
+      bool fin, const spdy::SpdyStreamPrecedence& precedence,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
   // |session| can't be nullptr.
   static QuicStreamId GetNextOutgoingUnidirectionalStreamId(
@@ -50,10 +47,10 @@ class QuicSpdySessionPeer {
       QuicSpdySession* session);
   static QpackReceiveStream* GetQpackEncoderReceiveStream(
       QuicSpdySession* session);
-  static void SetH3DatagramSupported(QuicSpdySession* session,
-                                     bool h3_datagram_supported);
-  static bool ShouldNegotiateHttp3Datagram(QuicSpdySession* session);
-  static void EnableWebTransport(QuicSpdySession& session);
+  static void SetHttpDatagramSupport(QuicSpdySession* session,
+                                     HttpDatagramSupport http_datagram_support);
+  static HttpDatagramSupport LocalHttpDatagramSupport(QuicSpdySession* session);
+  static void EnableWebTransport(QuicSpdySession* session);
 };
 
 }  // namespace test
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_buffer_peer.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
index 01ada82a741..a950f0ba323 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
@@ -46,8 +46,7 @@ bool QuicStreamSequencerBufferPeer::IsBlockArrayEmpty() {
     return true;
   }
 
-  size_t count = buffer_->allocate_blocks_on_demand_ ? current_blocks_count()
-                                                     : max_blocks_count();
+  size_t count = current_blocks_count();
   for (size_t i = 0; i < count; i++) {
     if (buffer_->blocks_[i] != nullptr) {
       return false;
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_backend.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_backend.cc
index eb419b607f5..3cfe9279a3a 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_backend.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_backend.cc
@@ -7,16 +7,64 @@
 #include <cstring>
 #include <memory>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_buffer_allocator.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/core/web_transport_interface.h"
 #include "quic/platform/api/quic_mem_slice.h"
+#include "quic/test_tools/web_transport_resets_backend.h"
 #include "quic/tools/web_transport_test_visitors.h"
 
 namespace quic {
 namespace test {
 
+namespace {
+
+// SessionCloseVisitor implements the "/session-close" endpoint.  If the client
+// sends a unidirectional stream of format "code message" to this endpoint, it
+// will close the session with the corresponding error code and error message.
+// For instance, sending "42 test error" will cause it to be closed with code 42
+// and message "test error".
+class SessionCloseVisitor : public WebTransportVisitor {
+ public:
+  SessionCloseVisitor(WebTransportSession* session) : session_(session) {}
+
+  void OnSessionReady(const spdy::SpdyHeaderBlock& /*headers*/) override {}
+  void OnSessionClosed(WebTransportSessionError /*error_code*/,
+                       const std::string& /*error_message*/) override {}
+
+  void OnIncomingBidirectionalStreamAvailable() override {}
+  void OnIncomingUnidirectionalStreamAvailable() override {
+    WebTransportStream* stream = session_->AcceptIncomingUnidirectionalStream();
+    if (stream == nullptr) {
+      return;
+    }
+    stream->SetVisitor(
+        std::make_unique<WebTransportUnidirectionalEchoReadVisitor>(
+            stream, [this](const std::string& data) {
+              std::pair<absl::string_view, absl::string_view> parsed =
+                  absl::StrSplit(data, absl::MaxSplits(' ', 1));
+              WebTransportSessionError error_code = 0;
+              bool success = absl::SimpleAtoi(parsed.first, &error_code);
+              QUICHE_DCHECK(success) << data;
+              session_->CloseSession(error_code, parsed.second);
+            }));
+    stream->visitor()->OnCanRead();
+  }
+
+  void OnDatagramReceived(absl::string_view /*datagram*/) override {}
+
+  void OnCanCreateNewOutgoingBidirectionalStream() override {}
+  void OnCanCreateNewOutgoingUnidirectionalStream() override {}
+
+ private:
+  WebTransportSession* session_;  // Not owned.
+};
+
+}  // namespace
+
 QuicSimpleServerBackend::WebTransportResponse
 QuicTestBackend::ProcessWebTransportRequest(
     const spdy::Http2HeaderBlock& request_headers,
@@ -33,13 +81,38 @@ QuicTestBackend::ProcessWebTransportRequest(
     return response;
   }
   absl::string_view path = path_it->second;
-  if (path == "/echo") {
+  // Match any "/echo.*" pass, e.g. "/echo_foobar"
+  if (absl::StartsWith(path, "/echo")) {
     WebTransportResponse response;
     response.response_headers[":status"] = "200";
+    // Add response headers if the paramer has "set-header=XXX:YYY" query.
+    GURL url = GURL(absl::StrCat("https://localhost", path));
+    const std::vector<std::string>& params = absl::StrSplit(url.query(), '&');
+    for (const auto& param : params) {
+      absl::string_view param_view = param;
+      if (absl::ConsumePrefix(&param_view, "set-header=")) {
+        const std::vector<absl::string_view> header_value =
+            absl::StrSplit(param_view, ':');
+        if (header_value.size() == 2 &&
+            !absl::StartsWith(header_value[0], ":")) {
+          response.response_headers[header_value[0]] = header_value[1];
+        }
+      }
+    }
+
     response.visitor =
         std::make_unique<EchoWebTransportSessionVisitor>(session);
     return response;
   }
+  if (path == "/resets") {
+    return WebTransportResetsBackend(request_headers, session);
+  }
+  if (path == "/session-close") {
+    WebTransportResponse response;
+    response.response_headers[":status"] = "200";
+    response.visitor = std::make_unique<SessionCloseVisitor>(session);
+    return response;
+  }
 
   WebTransportResponse response;
   response.response_headers[":status"] = "404";
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.cc
index 126b87e039c..9a7fd85b280 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.cc
@@ -1312,20 +1312,6 @@ StreamType DetermineStreamType(QuicStreamId id,
              : default_type;
 }
 
-QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
-                          absl::string_view message_data,
-                          QuicMemSliceStorage* storage) {
-  if (message_data.length() == 0) {
-    *storage =
-        QuicMemSliceStorage(nullptr, 0, allocator, kMaxOutgoingPacketSize);
-    return storage->ToSpan();
-  }
-  struct iovec iov = {const_cast<char*>(message_data.data()),
-                      message_data.length()};
-  *storage = QuicMemSliceStorage(&iov, 1, allocator, kMaxOutgoingPacketSize);
-  return storage->ToSpan();
-}
-
 QuicMemSlice MemSliceFromString(absl::string_view data) {
   if (data.empty()) {
     return QuicMemSlice();
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.h b/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.h
index 06f3eeca7c2..e746ddb33e1 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_test_utils.h
@@ -24,6 +24,7 @@
 #include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/quic_connection.h"
 #include "quic/core/quic_connection_id.h"
+#include "quic/core/quic_error_codes.h"
 #include "quic/core/quic_framer.h"
 #include "quic/core/quic_packet_writer.h"
 #include "quic/core/quic_path_validator.h"
@@ -103,26 +104,17 @@ void DisableQuicVersionsWithTls();
 // constructed packet, the framer must be set to use NullDecrypter.
 QuicEncryptedPacket* ConstructEncryptedPacket(
     QuicConnectionId destination_connection_id,
-    QuicConnectionId source_connection_id,
-    bool version_flag,
-    bool reset_flag,
-    uint64_t packet_number,
-    const std::string& data,
-    bool full_padding,
+    QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+    uint64_t packet_number, const std::string& data, bool full_padding,
     QuicConnectionIdIncluded destination_connection_id_included,
     QuicConnectionIdIncluded source_connection_id_included,
     QuicPacketNumberLength packet_number_length,
-    ParsedQuicVersionVector* versions,
-    Perspective perspective);
+    ParsedQuicVersionVector* versions, Perspective perspective);
 
 QuicEncryptedPacket* ConstructEncryptedPacket(
     QuicConnectionId destination_connection_id,
-    QuicConnectionId source_connection_id,
-    bool version_flag,
-    bool reset_flag,
-    uint64_t packet_number,
-    const std::string& data,
-    bool full_padding,
+    QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+    uint64_t packet_number, const std::string& data, bool full_padding,
     QuicConnectionIdIncluded destination_connection_id_included,
     QuicConnectionIdIncluded source_connection_id_included,
     QuicPacketNumberLength packet_number_length,
@@ -134,11 +126,8 @@ QuicEncryptedPacket* ConstructEncryptedPacket(
 // constructed packet, the framer must be set to use NullDecrypter.
 QuicEncryptedPacket* ConstructEncryptedPacket(
     QuicConnectionId destination_connection_id,
-    QuicConnectionId source_connection_id,
-    bool version_flag,
-    bool reset_flag,
-    uint64_t packet_number,
-    const std::string& data,
+    QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+    uint64_t packet_number, const std::string& data,
     QuicConnectionIdIncluded destination_connection_id_included,
     QuicConnectionIdIncluded source_connection_id_included,
     QuicPacketNumberLength packet_number_length,
@@ -147,11 +136,8 @@ QuicEncryptedPacket* ConstructEncryptedPacket(
 // This form assumes |versions| == nullptr.
 QuicEncryptedPacket* ConstructEncryptedPacket(
     QuicConnectionId destination_connection_id,
-    QuicConnectionId source_connection_id,
-    bool version_flag,
-    bool reset_flag,
-    uint64_t packet_number,
-    const std::string& data,
+    QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+    uint64_t packet_number, const std::string& data,
     QuicConnectionIdIncluded destination_connection_id_included,
     QuicConnectionIdIncluded source_connection_id_included,
     QuicPacketNumberLength packet_number_length);
@@ -161,11 +147,8 @@ QuicEncryptedPacket* ConstructEncryptedPacket(
 // |versions| == nullptr.
 QuicEncryptedPacket* ConstructEncryptedPacket(
     QuicConnectionId destination_connection_id,
-    QuicConnectionId source_connection_id,
-    bool version_flag,
-    bool reset_flag,
-    uint64_t packet_number,
-    const std::string& data);
+    QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+    uint64_t packet_number, const std::string& data);
 
 // Creates a client-to-server ZERO-RTT packet that will fail to decrypt.
 std::unique_ptr<QuicEncryptedPacket> GetUndecryptableEarlyPacket(
@@ -175,8 +158,7 @@ std::unique_ptr<QuicEncryptedPacket> GetUndecryptableEarlyPacket(
 // Constructs a received packet for testing. The caller must take ownership
 // of the returned pointer.
 QuicReceivedPacket* ConstructReceivedPacket(
-    const QuicEncryptedPacket& encrypted_packet,
-    QuicTime receipt_time);
+    const QuicEncryptedPacket& encrypted_packet, QuicTime receipt_time);
 
 // Create an encrypted packet for testing whose data portion erroneous.
 // The specific way the data portion is erroneous is not specified, but
@@ -185,15 +167,11 @@ QuicReceivedPacket* ConstructReceivedPacket(
 // constructed packet, the framer must be set to use NullDecrypter.
 QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
     QuicConnectionId destination_connection_id,
-    QuicConnectionId source_connection_id,
-    bool version_flag,
-    bool reset_flag,
-    uint64_t packet_number,
-    const std::string& data,
+    QuicConnectionId source_connection_id, bool version_flag, bool reset_flag,
+    uint64_t packet_number, const std::string& data,
     QuicConnectionIdIncluded destination_connection_id_included,
     QuicConnectionIdIncluded source_connection_id_included,
-    QuicPacketNumberLength packet_number_length,
-    ParsedQuicVersion version,
+    QuicPacketNumberLength packet_number_length, ParsedQuicVersion version,
     Perspective perspective);
 
 // Returns QuicConfig set to default values.
@@ -228,8 +206,7 @@ QuicAckFrame MakeAckFrameWithAckBlocks(size_t num_ack_blocks,
 
 // Testing convenice method to construct a QuicAckFrame with |largest_acked|,
 // ack blocks of width 1 packet and |gap_size|.
-QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size,
-                                  size_t max_num_gaps,
+QuicAckFrame MakeAckFrameWithGaps(uint64_t gap_size, size_t max_num_gaps,
                                   uint64_t largest_acked);
 
 // Returns the encryption level that corresponds to the header type in
@@ -241,15 +218,12 @@ EncryptionLevel HeaderToEncryptionLevel(const QuicPacketHeader& header);
 // is populated with the fields in |header| and |frames|, or is nullptr if the
 // packet could not be created.
 std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
-    QuicFramer* framer,
-    const QuicPacketHeader& header,
+    QuicFramer* framer, const QuicPacketHeader& header,
     const QuicFrames& frames);
 // Returns a QuicPacket that is owned by the caller, and of size |packet_size|.
 std::unique_ptr<QuicPacket> BuildUnsizedDataPacket(
-    QuicFramer* framer,
-    const QuicPacketHeader& header,
-    const QuicFrames& frames,
-    size_t packet_size);
+    QuicFramer* framer, const QuicPacketHeader& header,
+    const QuicFrames& frames, size_t packet_size);
 
 // Compute SHA-1 hash of the supplied std::string.
 std::string Sha1Hash(absl::string_view data);
@@ -297,21 +271,14 @@ class MockFramerVisitor : public QuicFramerVisitorInterface {
 
   MOCK_METHOD(void, OnError, (QuicFramer*), (override));
   // The constructor sets this up to return false by default.
-  MOCK_METHOD(bool,
-              OnProtocolVersionMismatch,
-              (ParsedQuicVersion version),
+  MOCK_METHOD(bool, OnProtocolVersionMismatch, (ParsedQuicVersion version),
               (override));
   MOCK_METHOD(void, OnPacket, (), (override));
-  MOCK_METHOD(void,
-              OnPublicResetPacket,
-              (const QuicPublicResetPacket& header),
-              (override));
-  MOCK_METHOD(void,
-              OnVersionNegotiationPacket,
-              (const QuicVersionNegotiationPacket& packet),
+  MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket& header),
               (override));
-  MOCK_METHOD(void,
-              OnRetryPacket,
+  MOCK_METHOD(void, OnVersionNegotiationPacket,
+              (const QuicVersionNegotiationPacket& packet), (override));
+  MOCK_METHOD(void, OnRetryPacket,
               (QuicConnectionId original_connection_id,
                QuicConnectionId new_connection_id,
                absl::string_view retry_token,
@@ -319,133 +286,75 @@ class MockFramerVisitor : public QuicFramerVisitorInterface {
                absl::string_view retry_without_tag),
               (override));
   // The constructor sets this up to return true by default.
-  MOCK_METHOD(bool,
-              OnUnauthenticatedHeader,
-              (const QuicPacketHeader& header),
+  MOCK_METHOD(bool, OnUnauthenticatedHeader, (const QuicPacketHeader& header),
               (override));
   // The constructor sets this up to return true by default.
-  MOCK_METHOD(bool,
-              OnUnauthenticatedPublicHeader,
-              (const QuicPacketHeader& header),
+  MOCK_METHOD(bool, OnUnauthenticatedPublicHeader,
+              (const QuicPacketHeader& header), (override));
+  MOCK_METHOD(void, OnDecryptedPacket, (size_t length, EncryptionLevel level),
               (override));
-  MOCK_METHOD(void,
-              OnDecryptedPacket,
-              (size_t length, EncryptionLevel level),
+  MOCK_METHOD(bool, OnPacketHeader, (const QuicPacketHeader& header),
               (override));
-  MOCK_METHOD(bool,
-              OnPacketHeader,
-              (const QuicPacketHeader& header),
+  MOCK_METHOD(void, OnCoalescedPacket, (const QuicEncryptedPacket& packet),
               (override));
-  MOCK_METHOD(void,
-              OnCoalescedPacket,
-              (const QuicEncryptedPacket& packet),
-              (override));
-  MOCK_METHOD(void,
-              OnUndecryptablePacket,
+  MOCK_METHOD(void, OnUndecryptablePacket,
               (const QuicEncryptedPacket& packet,
-               EncryptionLevel decryption_level,
-               bool has_decryption_key),
+               EncryptionLevel decryption_level, bool has_decryption_key),
               (override));
   MOCK_METHOD(bool, OnStreamFrame, (const QuicStreamFrame& frame), (override));
   MOCK_METHOD(bool, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
-  MOCK_METHOD(bool,
-              OnAckFrameStart,
-              (QuicPacketNumber, QuicTime::Delta),
+  MOCK_METHOD(bool, OnAckFrameStart, (QuicPacketNumber, QuicTime::Delta),
               (override));
-  MOCK_METHOD(bool,
-              OnAckRange,
-              (QuicPacketNumber, QuicPacketNumber),
+  MOCK_METHOD(bool, OnAckRange, (QuicPacketNumber, QuicPacketNumber),
               (override));
   MOCK_METHOD(bool, OnAckTimestamp, (QuicPacketNumber, QuicTime), (override));
   MOCK_METHOD(bool, OnAckFrameEnd, (QuicPacketNumber), (override));
-  MOCK_METHOD(bool,
-              OnStopWaitingFrame,
-              (const QuicStopWaitingFrame& frame),
+  MOCK_METHOD(bool, OnStopWaitingFrame, (const QuicStopWaitingFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnPaddingFrame,
-              (const QuicPaddingFrame& frame),
+  MOCK_METHOD(bool, OnPaddingFrame, (const QuicPaddingFrame& frame),
               (override));
   MOCK_METHOD(bool, OnPingFrame, (const QuicPingFrame& frame), (override));
-  MOCK_METHOD(bool,
-              OnRstStreamFrame,
-              (const QuicRstStreamFrame& frame),
-              (override));
-  MOCK_METHOD(bool,
-              OnConnectionCloseFrame,
-              (const QuicConnectionCloseFrame& frame),
+  MOCK_METHOD(bool, OnRstStreamFrame, (const QuicRstStreamFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnNewConnectionIdFrame,
-              (const QuicNewConnectionIdFrame& frame),
+  MOCK_METHOD(bool, OnConnectionCloseFrame,
+              (const QuicConnectionCloseFrame& frame), (override));
+  MOCK_METHOD(bool, OnNewConnectionIdFrame,
+              (const QuicNewConnectionIdFrame& frame), (override));
+  MOCK_METHOD(bool, OnRetireConnectionIdFrame,
+              (const QuicRetireConnectionIdFrame& frame), (override));
+  MOCK_METHOD(bool, OnNewTokenFrame, (const QuicNewTokenFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnRetireConnectionIdFrame,
-              (const QuicRetireConnectionIdFrame& frame),
+  MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnNewTokenFrame,
-              (const QuicNewTokenFrame& frame),
+  MOCK_METHOD(bool, OnPathChallengeFrame, (const QuicPathChallengeFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnStopSendingFrame,
-              (const QuicStopSendingFrame& frame),
-              (override));
-  MOCK_METHOD(bool,
-              OnPathChallengeFrame,
-              (const QuicPathChallengeFrame& frame),
-              (override));
-  MOCK_METHOD(bool,
-              OnPathResponseFrame,
-              (const QuicPathResponseFrame& frame),
+  MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame& frame),
               (override));
   MOCK_METHOD(bool, OnGoAwayFrame, (const QuicGoAwayFrame& frame), (override));
-  MOCK_METHOD(bool,
-              OnMaxStreamsFrame,
-              (const QuicMaxStreamsFrame& frame),
-              (override));
-  MOCK_METHOD(bool,
-              OnStreamsBlockedFrame,
-              (const QuicStreamsBlockedFrame& frame),
+  MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnWindowUpdateFrame,
-              (const QuicWindowUpdateFrame& frame),
+  MOCK_METHOD(bool, OnStreamsBlockedFrame,
+              (const QuicStreamsBlockedFrame& frame), (override));
+  MOCK_METHOD(bool, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnBlockedFrame,
-              (const QuicBlockedFrame& frame),
+  MOCK_METHOD(bool, OnBlockedFrame, (const QuicBlockedFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnMessageFrame,
-              (const QuicMessageFrame& frame),
+  MOCK_METHOD(bool, OnMessageFrame, (const QuicMessageFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnHandshakeDoneFrame,
-              (const QuicHandshakeDoneFrame& frame),
+  MOCK_METHOD(bool, OnHandshakeDoneFrame, (const QuicHandshakeDoneFrame& frame),
               (override));
-  MOCK_METHOD(bool,
-              OnAckFrequencyFrame,
-              (const QuicAckFrequencyFrame& frame),
+  MOCK_METHOD(bool, OnAckFrequencyFrame, (const QuicAckFrequencyFrame& frame),
               (override));
   MOCK_METHOD(void, OnPacketComplete, (), (override));
-  MOCK_METHOD(bool,
-              IsValidStatelessResetToken,
-              (const StatelessResetToken&),
+  MOCK_METHOD(bool, IsValidStatelessResetToken, (const StatelessResetToken&),
               (const, override));
-  MOCK_METHOD(void,
-              OnAuthenticatedIetfStatelessResetPacket,
-              (const QuicIetfStatelessResetPacket&),
-              (override));
+  MOCK_METHOD(void, OnAuthenticatedIetfStatelessResetPacket,
+              (const QuicIetfStatelessResetPacket&), (override));
   MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
   MOCK_METHOD(void, OnDecryptedFirstPacketInKeyPhase, (), (override));
   MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
-              AdvanceKeysAndCreateCurrentOneRttDecrypter,
-              (),
-              (override));
-  MOCK_METHOD(std::unique_ptr<QuicEncrypter>,
-              CreateCurrentOneRttEncrypter,
-              (),
+              AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
+  MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
               (override));
 };
 
@@ -529,97 +438,66 @@ class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
 
   MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
   MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
-  MOCK_METHOD(void,
-              OnWindowUpdateFrame,
-              (const QuicWindowUpdateFrame& frame),
+  MOCK_METHOD(void, OnWindowUpdateFrame, (const QuicWindowUpdateFrame& frame),
               (override));
-  MOCK_METHOD(void,
-              OnBlockedFrame,
-              (const QuicBlockedFrame& frame),
+  MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame& frame),
               (override));
   MOCK_METHOD(void, OnRstStream, (const QuicRstStreamFrame& frame), (override));
   MOCK_METHOD(void, OnGoAway, (const QuicGoAwayFrame& frame), (override));
   MOCK_METHOD(void, OnMessageReceived, (absl::string_view message), (override));
   MOCK_METHOD(void, OnHandshakeDoneReceived, (), (override));
   MOCK_METHOD(void, OnNewTokenReceived, (absl::string_view token), (override));
-  MOCK_METHOD(void,
-              OnConnectionClosed,
+  MOCK_METHOD(void, OnConnectionClosed,
               (const QuicConnectionCloseFrame& frame,
                ConnectionCloseSource source),
               (override));
   MOCK_METHOD(void, OnWriteBlocked, (), (override));
   MOCK_METHOD(void, OnCanWrite, (), (override));
   MOCK_METHOD(bool, SendProbingData, (), (override));
-  MOCK_METHOD(bool,
-              ValidateStatelessReset,
+  MOCK_METHOD(bool, ValidateStatelessReset,
               (const quic::QuicSocketAddress&, const quic::QuicSocketAddress&),
               (override));
   MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
-  MOCK_METHOD(void,
-              OnConnectionMigration,
-              (AddressChangeType type),
+  MOCK_METHOD(void, OnConnectionMigration, (AddressChangeType type),
               (override));
   MOCK_METHOD(void, OnPathDegrading, (), (override));
   MOCK_METHOD(void, OnForwardProgressMadeAfterPathDegrading, (), (override));
   MOCK_METHOD(bool, WillingAndAbleToWrite, (), (const, override));
   MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
   MOCK_METHOD(std::string, GetStreamsInfoForLogging, (), (const, override));
-  MOCK_METHOD(void,
-              OnSuccessfulVersionNegotiation,
-              (const ParsedQuicVersion& version),
-              (override));
-  MOCK_METHOD(void,
-              OnPacketReceived,
+  MOCK_METHOD(void, OnSuccessfulVersionNegotiation,
+              (const ParsedQuicVersion& version), (override));
+  MOCK_METHOD(void, OnPacketReceived,
               (const QuicSocketAddress& self_address,
                const QuicSocketAddress& peer_address,
                bool is_connectivity_probe),
               (override));
   MOCK_METHOD(void, OnAckNeedsRetransmittableFrame, (), (override));
-  MOCK_METHOD(void,
-              SendAckFrequency,
-              (const QuicAckFrequencyFrame& frame),
-              (override));
-  MOCK_METHOD(void,
-              SendNewConnectionId,
-              (const QuicNewConnectionIdFrame& frame),
-              (override));
-  MOCK_METHOD(void,
-              SendRetireConnectionId,
-              (uint64_t sequence_number),
+  MOCK_METHOD(void, SendAckFrequency, (const QuicAckFrequencyFrame& frame),
               (override));
-  MOCK_METHOD(void,
-              OnServerConnectionIdIssued,
-              (const QuicConnectionId& server_connection_id),
-              (override));
-  MOCK_METHOD(void,
-              OnServerConnectionIdRetired,
-              (const QuicConnectionId& server_connection_id),
+  MOCK_METHOD(void, SendNewConnectionId,
+              (const QuicNewConnectionIdFrame& frame), (override));
+  MOCK_METHOD(void, SendRetireConnectionId, (uint64_t sequence_number),
               (override));
+  MOCK_METHOD(void, OnServerConnectionIdIssued,
+              (const QuicConnectionId& server_connection_id), (override));
+  MOCK_METHOD(void, OnServerConnectionIdRetired,
+              (const QuicConnectionId& server_connection_id), (override));
   MOCK_METHOD(bool, AllowSelfAddressChange, (), (const, override));
   MOCK_METHOD(HandshakeState, GetHandshakeState, (), (const, override));
-  MOCK_METHOD(bool,
-              OnMaxStreamsFrame,
-              (const QuicMaxStreamsFrame& frame),
-              (override));
-  MOCK_METHOD(bool,
-              OnStreamsBlockedFrame,
-              (const QuicStreamsBlockedFrame& frame),
+  MOCK_METHOD(bool, OnMaxStreamsFrame, (const QuicMaxStreamsFrame& frame),
               (override));
-  MOCK_METHOD(void,
-              OnStopSendingFrame,
-              (const QuicStopSendingFrame& frame),
+  MOCK_METHOD(bool, OnStreamsBlockedFrame,
+              (const QuicStreamsBlockedFrame& frame), (override));
+  MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
               (override));
   MOCK_METHOD(void, OnPacketDecrypted, (EncryptionLevel), (override));
   MOCK_METHOD(void, OnOneRttPacketAcknowledged, (), (override));
   MOCK_METHOD(void, OnHandshakePacketSent, (), (override));
   MOCK_METHOD(void, OnKeyUpdate, (KeyUpdateReason), (override));
   MOCK_METHOD(std::unique_ptr<QuicDecrypter>,
-              AdvanceKeysAndCreateCurrentOneRttDecrypter,
-              (),
-              (override));
-  MOCK_METHOD(std::unique_ptr<QuicEncrypter>,
-              CreateCurrentOneRttEncrypter,
-              (),
+              AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override));
+  MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (),
               (override));
   MOCK_METHOD(void, BeforeConnectionCloseSent, (), (override));
   MOCK_METHOD(bool, ValidateToken, (absl::string_view), (const, override));
@@ -672,36 +550,57 @@ class MockAlarmFactory : public QuicAlarmFactory {
   }
 };
 
+class TestAlarmFactory : public QuicAlarmFactory {
+ public:
+  class TestAlarm : public QuicAlarm {
+   public:
+    explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+        : QuicAlarm(std::move(delegate)) {}
+
+    void SetImpl() override {}
+    void CancelImpl() override {}
+    using QuicAlarm::Fire;
+  };
+
+  TestAlarmFactory() {}
+  TestAlarmFactory(const TestAlarmFactory&) = delete;
+  TestAlarmFactory& operator=(const TestAlarmFactory&) = delete;
+
+  QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
+    return new TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+  }
+
+  QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
+      QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+      QuicConnectionArena* arena) override {
+    return arena->New<TestAlarm>(std::move(delegate));
+  }
+};
+
 class MockQuicConnection : public QuicConnection {
  public:
   // Uses a ConnectionId of 42 and 127.0.0.1:123.
   MockQuicConnection(MockQuicConnectionHelper* helper,
-                     MockAlarmFactory* alarm_factory,
-                     Perspective perspective);
+                     MockAlarmFactory* alarm_factory, Perspective perspective);
 
   // Uses a ConnectionId of 42.
   MockQuicConnection(QuicSocketAddress address,
                      MockQuicConnectionHelper* helper,
-                     MockAlarmFactory* alarm_factory,
-                     Perspective perspective);
+                     MockAlarmFactory* alarm_factory, Perspective perspective);
 
   // Uses 127.0.0.1:123.
   MockQuicConnection(QuicConnectionId connection_id,
                      MockQuicConnectionHelper* helper,
-                     MockAlarmFactory* alarm_factory,
-                     Perspective perspective);
+                     MockAlarmFactory* alarm_factory, Perspective perspective);
 
   // Uses a ConnectionId of 42, and 127.0.0.1:123.
   MockQuicConnection(MockQuicConnectionHelper* helper,
-                     MockAlarmFactory* alarm_factory,
-                     Perspective perspective,
+                     MockAlarmFactory* alarm_factory, Perspective perspective,
                      const ParsedQuicVersionVector& supported_versions);
 
-  MockQuicConnection(QuicConnectionId connection_id,
-                     QuicSocketAddress address,
+  MockQuicConnection(QuicConnectionId connection_id, QuicSocketAddress address,
                      MockQuicConnectionHelper* helper,
-                     MockAlarmFactory* alarm_factory,
-                     Perspective perspective,
+                     MockAlarmFactory* alarm_factory, Perspective perspective,
                      const ParsedQuicVersionVector& supported_versions);
   MockQuicConnection(const MockQuicConnection&) = delete;
   MockQuicConnection& operator=(const MockQuicConnection&) = delete;
@@ -713,64 +612,45 @@ class MockQuicConnection : public QuicConnection {
   // will advance the time of the MockClock.
   void AdvanceTime(QuicTime::Delta delta);
 
-  MOCK_METHOD(void,
-              ProcessUdpPacket,
+  MOCK_METHOD(void, ProcessUdpPacket,
               (const QuicSocketAddress& self_address,
                const QuicSocketAddress& peer_address,
                const QuicReceivedPacket& packet),
               (override));
-  MOCK_METHOD(void,
-              CloseConnection,
-              (QuicErrorCode error,
-               const std::string& details,
+  MOCK_METHOD(void, CloseConnection,
+              (QuicErrorCode error, const std::string& details,
                ConnectionCloseBehavior connection_close_behavior),
               (override));
-  MOCK_METHOD(void,
-              CloseConnection,
-              (QuicErrorCode error,
-               QuicIetfTransportErrorCodes ietf_error,
+  MOCK_METHOD(void, CloseConnection,
+              (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
                const std::string& details,
                ConnectionCloseBehavior connection_close_behavior),
               (override));
-  MOCK_METHOD(void,
-              SendConnectionClosePacket,
-              (QuicErrorCode error,
-               QuicIetfTransportErrorCodes ietf_error,
+  MOCK_METHOD(void, SendConnectionClosePacket,
+              (QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
                const std::string& details),
               (override));
   MOCK_METHOD(void, OnCanWrite, (), (override));
-  MOCK_METHOD(void,
-              SendConnectivityProbingResponsePacket,
-              (const QuicSocketAddress& peer_address),
-              (override));
-  MOCK_METHOD(bool,
-              SendConnectivityProbingPacket,
+  MOCK_METHOD(void, SendConnectivityProbingResponsePacket,
+              (const QuicSocketAddress& peer_address), (override));
+  MOCK_METHOD(bool, SendConnectivityProbingPacket,
               (QuicPacketWriter*, const QuicSocketAddress& peer_address),
               (override));
 
-  MOCK_METHOD(void,
-              OnSendConnectionState,
-              (const CachedNetworkParameters&),
-              (override));
-  MOCK_METHOD(void,
-              ResumeConnectionState,
-              (const CachedNetworkParameters&, bool),
+  MOCK_METHOD(void, OnSendConnectionState, (const CachedNetworkParameters&),
               (override));
+  MOCK_METHOD(void, ResumeConnectionState,
+              (const CachedNetworkParameters&, bool), (override));
   MOCK_METHOD(void, SetMaxPacingRate, (QuicBandwidth), (override));
 
-  MOCK_METHOD(void,
-              OnStreamReset,
-              (QuicStreamId, QuicRstStreamErrorCode),
+  MOCK_METHOD(void, OnStreamReset, (QuicStreamId, QuicRstStreamErrorCode),
               (override));
   MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
   MOCK_METHOD(MessageStatus, SendMessage,
               (QuicMessageId, absl::Span<QuicMemSlice>, bool), (override));
-  MOCK_METHOD(bool,
-              SendPathChallenge,
-              (const QuicPathFrameBuffer&,
-               const QuicSocketAddress&,
-               const QuicSocketAddress&,
-               const QuicSocketAddress&,
+  MOCK_METHOD(bool, SendPathChallenge,
+              (const QuicPathFrameBuffer&, const QuicSocketAddress&,
+               const QuicSocketAddress&, const QuicSocketAddress&,
                QuicPacketWriter*),
               (override));
 
@@ -782,8 +662,7 @@ class MockQuicConnection : public QuicConnection {
   void ReallyOnCanWrite() { QuicConnection::OnCanWrite(); }
 
   void ReallyCloseConnection(
-      QuicErrorCode error,
-      const std::string& details,
+      QuicErrorCode error, const std::string& details,
       ConnectionCloseBehavior connection_close_behavior) {
     // Call the 4-param method directly instead of the 3-param method, so that
     // it doesn't invoke the virtual 4-param method causing the mock 4-param
@@ -793,8 +672,7 @@ class MockQuicConnection : public QuicConnection {
   }
 
   void ReallyCloseConnection4(
-      QuicErrorCode error,
-      QuicIetfTransportErrorCodes ietf_error,
+      QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
       const std::string& details,
       ConnectionCloseBehavior connection_close_behavior) {
     QuicConnection::CloseConnection(error, ietf_error, details,
@@ -820,8 +698,7 @@ class MockQuicConnection : public QuicConnection {
   }
 
   bool ReallySendConnectivityProbingPacket(
-      QuicPacketWriter* probing_writer,
-      const QuicSocketAddress& peer_address) {
+      QuicPacketWriter* probing_writer, const QuicSocketAddress& peer_address) {
     return QuicConnection::SendConnectivityProbingPacket(probing_writer,
                                                          peer_address);
   }
@@ -835,18 +712,12 @@ class MockQuicConnection : public QuicConnection {
     return QuicConnection::OnPathResponseFrame(frame);
   }
 
-  MOCK_METHOD(bool,
-              OnPathResponseFrame,
-              (const QuicPathResponseFrame&),
+  MOCK_METHOD(bool, OnPathResponseFrame, (const QuicPathResponseFrame&),
               (override));
-  MOCK_METHOD(bool,
-              OnStopSendingFrame,
-              (const QuicStopSendingFrame& frame),
-              (override));
-  MOCK_METHOD(size_t,
-              SendCryptoData,
-              (EncryptionLevel, size_t, QuicStreamOffset),
+  MOCK_METHOD(bool, OnStopSendingFrame, (const QuicStopSendingFrame& frame),
               (override));
+  MOCK_METHOD(size_t, SendCryptoData,
+              (EncryptionLevel, size_t, QuicStreamOffset), (override));
   size_t QuicConnection_SendCryptoData(EncryptionLevel level,
                                        size_t write_length,
                                        QuicStreamOffset offset) {
@@ -892,59 +763,47 @@ class MockQuicSession : public QuicSession {
   const QuicCryptoStream* GetCryptoStream() const override;
   void SetCryptoStream(QuicCryptoStream* crypto_stream);
 
-  MOCK_METHOD(void,
-              OnConnectionClosed,
+  MOCK_METHOD(void, OnConnectionClosed,
               (const QuicConnectionCloseFrame& frame,
                ConnectionCloseSource source),
               (override));
   MOCK_METHOD(QuicStream*, CreateIncomingStream, (QuicStreamId id), (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (PendingStream*),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
               (override));
   MOCK_METHOD(QuicConsumedData, WritevData,
               (QuicStreamId id, size_t write_length, QuicStreamOffset offset,
                StreamSendingState state, TransmissionType type,
                EncryptionLevel level),
               (override));
-  MOCK_METHOD(bool,
-              WriteControlFrame,
-              (const QuicFrame& frame, TransmissionType type),
-              (override));
-  MOCK_METHOD(void,
-              MaybeSendRstStreamFrame,
-              (QuicStreamId stream_id,
-               QuicRstStreamErrorCode error,
+  MOCK_METHOD(bool, WriteControlFrame,
+              (const QuicFrame& frame, TransmissionType type), (override));
+  MOCK_METHOD(void, MaybeSendRstStreamFrame,
+              (QuicStreamId stream_id, QuicResetStreamError error,
                QuicStreamOffset bytes_written),
               (override));
-  MOCK_METHOD(void,
-              MaybeSendStopSendingFrame,
-              (QuicStreamId stream_id, QuicRstStreamErrorCode error),
-              (override));
+  MOCK_METHOD(void, MaybeSendStopSendingFrame,
+              (QuicStreamId stream_id, QuicResetStreamError error), (override));
 
   MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
   MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
-  MOCK_METHOD(std::vector<absl::string_view>::const_iterator,
-              SelectAlpn,
-              (const std::vector<absl::string_view>&),
-              (const, override));
+  MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
+              (const std::vector<absl::string_view>&), (const, override));
   MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
 
   using QuicSession::ActivateStream;
 
   // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
   // if set) has been consumed.
-  QuicConsumedData ConsumeData(QuicStreamId id,
-                               size_t write_length,
+  QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
                                QuicStreamOffset offset,
-                               StreamSendingState state,
-                               TransmissionType type,
+                               StreamSendingState state, TransmissionType type,
                                absl::optional<EncryptionLevel> level);
 
   void ReallyMaybeSendRstStreamFrame(QuicStreamId id,
                                      QuicRstStreamErrorCode error,
                                      QuicStreamOffset bytes_written) {
-    QuicSession::MaybeSendRstStreamFrame(id, error, bytes_written);
+    QuicSession::MaybeSendRstStreamFrame(
+        id, QuicResetStreamError::FromInternal(error), bytes_written);
   }
 
  private:
@@ -985,6 +844,13 @@ class MockQuicCryptoStream : public QuicCryptoStream {
   std::unique_ptr<QuicEncrypter> CreateCurrentOneRttEncrypter() override {
     return nullptr;
   }
+  bool ExportKeyingMaterial(absl::string_view /*label*/,
+                            absl::string_view /*context*/,
+                            size_t /*result_len*/,
+                            std::string* /*result*/) override {
+    return false;
+  }
+  SSL* GetSsl() const override { return nullptr; }
 
  private:
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
@@ -1012,26 +878,17 @@ class MockQuicSpdySession : public QuicSpdySession {
   }
 
   // From QuicSession.
-  MOCK_METHOD(void,
-              OnConnectionClosed,
+  MOCK_METHOD(void, OnConnectionClosed,
               (const QuicConnectionCloseFrame& frame,
                ConnectionCloseSource source),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (QuicStreamId id),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (PendingStream*),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateOutgoingBidirectionalStream,
-              (),
+  MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateOutgoingUnidirectionalStream,
-              (),
+  MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
               (override));
   MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
   MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
@@ -1041,53 +898,37 @@ class MockQuicSpdySession : public QuicSpdySession {
                StreamSendingState state, TransmissionType type,
                EncryptionLevel level),
               (override));
-  MOCK_METHOD(void,
-              MaybeSendRstStreamFrame,
-              (QuicStreamId stream_id,
-               QuicRstStreamErrorCode error,
+  MOCK_METHOD(void, MaybeSendRstStreamFrame,
+              (QuicStreamId stream_id, QuicResetStreamError error,
                QuicStreamOffset bytes_written),
               (override));
-  MOCK_METHOD(void,
-              MaybeSendStopSendingFrame,
-              (QuicStreamId stream_id, QuicRstStreamErrorCode error),
-              (override));
-  MOCK_METHOD(void,
-              SendWindowUpdate,
-              (QuicStreamId id, QuicStreamOffset byte_offset),
-              (override));
+  MOCK_METHOD(void, MaybeSendStopSendingFrame,
+              (QuicStreamId stream_id, QuicResetStreamError error), (override));
+  MOCK_METHOD(void, SendWindowUpdate,
+              (QuicStreamId id, QuicStreamOffset byte_offset), (override));
   MOCK_METHOD(void, SendBlocked, (QuicStreamId id), (override));
-  MOCK_METHOD(void,
-              OnStreamHeadersPriority,
+  MOCK_METHOD(void, OnStreamHeadersPriority,
               (QuicStreamId stream_id,
                const spdy::SpdyStreamPrecedence& precedence),
               (override));
-  MOCK_METHOD(void,
-              OnStreamHeaderList,
-              (QuicStreamId stream_id,
-               bool fin,
-               size_t frame_len,
+  MOCK_METHOD(void, OnStreamHeaderList,
+              (QuicStreamId stream_id, bool fin, size_t frame_len,
                const QuicHeaderList& header_list),
               (override));
-  MOCK_METHOD(void,
-              OnPromiseHeaderList,
-              (QuicStreamId stream_id,
-               QuicStreamId promised_stream_id,
-               size_t frame_len,
-               const QuicHeaderList& header_list),
+  MOCK_METHOD(void, OnPromiseHeaderList,
+              (QuicStreamId stream_id, QuicStreamId promised_stream_id,
+               size_t frame_len, const QuicHeaderList& header_list),
               (override));
-  MOCK_METHOD(void,
-              OnPriorityFrame,
+  MOCK_METHOD(void, OnPriorityFrame,
               (QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence),
               (override));
   MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
 
   // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
   // if set) has been consumed.
-  QuicConsumedData ConsumeData(QuicStreamId id,
-                               size_t write_length,
+  QuicConsumedData ConsumeData(QuicStreamId id, size_t write_length,
                                QuicStreamOffset offset,
-                               StreamSendingState state,
-                               TransmissionType type,
+                               StreamSendingState state, TransmissionType type,
                                absl::optional<EncryptionLevel> level);
 
   using QuicSession::ActivateStream;
@@ -1102,73 +943,45 @@ class MockHttp3DebugVisitor : public Http3DebugVisitor {
   MOCK_METHOD(void, OnQpackEncoderStreamCreated, (QuicStreamId), (override));
   MOCK_METHOD(void, OnQpackDecoderStreamCreated, (QuicStreamId), (override));
   MOCK_METHOD(void, OnPeerControlStreamCreated, (QuicStreamId), (override));
-  MOCK_METHOD(void,
-              OnPeerQpackEncoderStreamCreated,
-              (QuicStreamId),
+  MOCK_METHOD(void, OnPeerQpackEncoderStreamCreated, (QuicStreamId),
               (override));
-  MOCK_METHOD(void,
-              OnPeerQpackDecoderStreamCreated,
-              (QuicStreamId),
+  MOCK_METHOD(void, OnPeerQpackDecoderStreamCreated, (QuicStreamId),
               (override));
 
-  MOCK_METHOD(void,
-              OnSettingsFrameReceivedViaAlps,
-              (const SettingsFrame&),
+  MOCK_METHOD(void, OnSettingsFrameReceivedViaAlps, (const SettingsFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnAcceptChFrameReceivedViaAlps,
-              (const AcceptChFrame&),
+  MOCK_METHOD(void, OnAcceptChFrameReceivedViaAlps, (const AcceptChFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnSettingsFrameReceived,
-              (const SettingsFrame&),
+  MOCK_METHOD(void, OnSettingsFrameReceived, (const SettingsFrame&),
               (override));
   MOCK_METHOD(void, OnGoAwayFrameReceived, (const GoAwayFrame&), (override));
-  MOCK_METHOD(void,
-              OnMaxPushIdFrameReceived,
-              (const MaxPushIdFrame&),
+  MOCK_METHOD(void, OnMaxPushIdFrameReceived, (const MaxPushIdFrame&),
               (override));
-  MOCK_METHOD(void,
-              OnPriorityUpdateFrameReceived,
-              (const PriorityUpdateFrame&),
+  MOCK_METHOD(void, OnPriorityUpdateFrameReceived, (const PriorityUpdateFrame&),
               (override));
-  MOCK_METHOD(void,
-              OnAcceptChFrameReceived,
-              (const AcceptChFrame&),
+  MOCK_METHOD(void, OnAcceptChFrameReceived, (const AcceptChFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnDataFrameReceived,
-              (QuicStreamId, QuicByteCount),
-              (override));
-  MOCK_METHOD(void,
-              OnHeadersFrameReceived,
-              (QuicStreamId, QuicByteCount),
+  MOCK_METHOD(void, OnDataFrameReceived, (QuicStreamId, QuicByteCount),
               (override));
-  MOCK_METHOD(void,
-              OnHeadersDecoded,
-              (QuicStreamId, QuicHeaderList),
+  MOCK_METHOD(void, OnHeadersFrameReceived, (QuicStreamId, QuicByteCount),
               (override));
-  MOCK_METHOD(void,
-              OnUnknownFrameReceived,
-              (QuicStreamId, uint64_t, QuicByteCount),
+  MOCK_METHOD(void, OnHeadersDecoded, (QuicStreamId, QuicHeaderList),
               (override));
+  MOCK_METHOD(void, OnUnknownFrameReceived,
+              (QuicStreamId, uint64_t, QuicByteCount), (override));
 
   MOCK_METHOD(void, OnSettingsFrameSent, (const SettingsFrame&), (override));
   MOCK_METHOD(void, OnGoAwayFrameSent, (QuicStreamId), (override));
   MOCK_METHOD(void, OnMaxPushIdFrameSent, (const MaxPushIdFrame&), (override));
-  MOCK_METHOD(void,
-              OnPriorityUpdateFrameSent,
-              (const PriorityUpdateFrame&),
+  MOCK_METHOD(void, OnPriorityUpdateFrameSent, (const PriorityUpdateFrame&),
               (override));
 
   MOCK_METHOD(void, OnDataFrameSent, (QuicStreamId, QuicByteCount), (override));
-  MOCK_METHOD(void,
-              OnHeadersFrameSent,
-              (QuicStreamId, const spdy::SpdyHeaderBlock&),
-              (override));
+  MOCK_METHOD(void, OnHeadersFrameSent,
+              (QuicStreamId, const spdy::SpdyHeaderBlock&), (override));
 };
 
 class TestQuicSpdyServerSession : public QuicServerSessionBase {
@@ -1184,26 +997,16 @@ class TestQuicSpdyServerSession : public QuicServerSessionBase {
       delete;
   ~TestQuicSpdyServerSession() override;
 
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (QuicStreamId id),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (PendingStream*),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateOutgoingBidirectionalStream,
-              (),
+  MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateOutgoingUnidirectionalStream,
-              (),
+  MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
               (override));
-  MOCK_METHOD(std::vector<absl::string_view>::const_iterator,
-              SelectAlpn,
-              (const std::vector<absl::string_view>&),
-              (const, override));
+  MOCK_METHOD(std::vector<absl::string_view>::const_iterator, SelectAlpn,
+              (const std::vector<absl::string_view>&), (const, override));
   MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
   std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
@@ -1215,14 +1018,22 @@ class TestQuicSpdyServerSession : public QuicServerSessionBase {
 
   MockQuicCryptoServerStreamHelper* helper() { return &helper_; }
 
-  QuicSSLConfig GetSSLConfig() const override { return ssl_config_; }
+  QuicSSLConfig GetSSLConfig() const override {
+    QuicSSLConfig ssl_config = QuicServerSessionBase::GetSSLConfig();
+    if (early_data_enabled_.has_value()) {
+      ssl_config.early_data_enabled = *early_data_enabled_;
+    }
+    return ssl_config;
+  }
 
-  QuicSSLConfig* ssl_config() { return &ssl_config_; }
+  void set_early_data_enabled(bool enabled) { early_data_enabled_ = enabled; }
 
  private:
   MockQuicSessionVisitor visitor_;
   MockQuicCryptoServerStreamHelper helper_;
-  QuicSSLConfig ssl_config_;
+  // If not nullopt, override the early_data_enabled value from base class'
+  // ssl_config.
+  absl::optional<bool> early_data_enabled_;
 };
 
 // A test implementation of QuicClientPushPromiseIndex::Delegate.
@@ -1262,31 +1073,19 @@ class TestQuicSpdyClientSession : public QuicSpdyClientSessionBase {
   bool IsAuthorized(const std::string& authority) override;
 
   // QuicSpdyClientSessionBase
-  MOCK_METHOD(void,
-              OnProofValid,
-              (const QuicCryptoClientConfig::CachedState& cached),
-              (override));
-  MOCK_METHOD(void,
-              OnProofVerifyDetailsAvailable,
-              (const ProofVerifyDetails& verify_details),
-              (override));
+  MOCK_METHOD(void, OnProofValid,
+              (const QuicCryptoClientConfig::CachedState& cached), (override));
+  MOCK_METHOD(void, OnProofVerifyDetailsAvailable,
+              (const ProofVerifyDetails& verify_details), (override));
 
   // TestQuicSpdyClientSession
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (QuicStreamId id),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (QuicStreamId id),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateIncomingStream,
-              (PendingStream*),
+  MOCK_METHOD(QuicSpdyStream*, CreateIncomingStream, (PendingStream*),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateOutgoingBidirectionalStream,
-              (),
+  MOCK_METHOD(QuicSpdyStream*, CreateOutgoingBidirectionalStream, (),
               (override));
-  MOCK_METHOD(QuicSpdyStream*,
-              CreateOutgoingUnidirectionalStream,
-              (),
+  MOCK_METHOD(QuicSpdyStream*, CreateOutgoingUnidirectionalStream, (),
               (override));
   MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
   MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
@@ -1326,24 +1125,17 @@ class MockPacketWriter : public QuicPacketWriter {
   MockPacketWriter& operator=(const MockPacketWriter&) = delete;
   ~MockPacketWriter() override;
 
-  MOCK_METHOD(WriteResult,
-              WritePacket,
-              (const char*,
-               size_t buf_len,
-               const QuicIpAddress& self_address,
-               const QuicSocketAddress& peer_address,
-               PerPacketOptions*),
+  MOCK_METHOD(WriteResult, WritePacket,
+              (const char*, size_t buf_len, const QuicIpAddress& self_address,
+               const QuicSocketAddress& peer_address, PerPacketOptions*),
               (override));
   MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
   MOCK_METHOD(void, SetWritable, (), (override));
-  MOCK_METHOD(QuicByteCount,
-              GetMaxPacketSize,
-              (const QuicSocketAddress& peer_address),
-              (const, override));
+  MOCK_METHOD(QuicByteCount, GetMaxPacketSize,
+              (const QuicSocketAddress& peer_address), (const, override));
   MOCK_METHOD(bool, SupportsReleaseTime, (), (const, override));
   MOCK_METHOD(bool, IsBatchMode, (), (const, override));
-  MOCK_METHOD(QuicPacketBuffer,
-              GetNextWriteLocation,
+  MOCK_METHOD(QuicPacketBuffer, GetNextWriteLocation,
               (const QuicIpAddress& self_address,
                const QuicSocketAddress& peer_address),
               (override));
@@ -1357,32 +1149,19 @@ class MockSendAlgorithm : public SendAlgorithmInterface {
   MockSendAlgorithm& operator=(const MockSendAlgorithm&) = delete;
   ~MockSendAlgorithm() override;
 
-  MOCK_METHOD(void,
-              SetFromConfig,
-              (const QuicConfig& config, Perspective perspective),
-              (override));
-  MOCK_METHOD(void,
-              ApplyConnectionOptions,
-              (const QuicTagVector& connection_options),
-              (override));
-  MOCK_METHOD(void,
-              SetInitialCongestionWindowInPackets,
-              (QuicPacketCount packets),
-              (override));
-  MOCK_METHOD(void,
-              OnCongestionEvent,
-              (bool rtt_updated,
-               QuicByteCount bytes_in_flight,
-               QuicTime event_time,
-               const AckedPacketVector& acked_packets,
+  MOCK_METHOD(void, SetFromConfig,
+              (const QuicConfig& config, Perspective perspective), (override));
+  MOCK_METHOD(void, ApplyConnectionOptions,
+              (const QuicTagVector& connection_options), (override));
+  MOCK_METHOD(void, SetInitialCongestionWindowInPackets,
+              (QuicPacketCount packets), (override));
+  MOCK_METHOD(void, OnCongestionEvent,
+              (bool rtt_updated, QuicByteCount bytes_in_flight,
+               QuicTime event_time, const AckedPacketVector& acked_packets,
                const LostPacketVector& lost_packets),
               (override));
-  MOCK_METHOD(void,
-              OnPacketSent,
-              (QuicTime,
-               QuicByteCount,
-               QuicPacketNumber,
-               QuicByteCount,
+  MOCK_METHOD(void, OnPacketSent,
+              (QuicTime, QuicByteCount, QuicPacketNumber, QuicByteCount,
                HasRetransmittableData),
               (override));
   MOCK_METHOD(void, OnPacketNeutered, (QuicPacketNumber), (override));
@@ -1397,18 +1176,12 @@ class MockSendAlgorithm : public SendAlgorithmInterface {
   MOCK_METHOD(bool, InRecovery, (), (const, override));
   MOCK_METHOD(bool, ShouldSendProbingPacket, (), (const, override));
   MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
-  MOCK_METHOD(CongestionControlType,
-              GetCongestionControlType,
-              (),
+  MOCK_METHOD(CongestionControlType, GetCongestionControlType, (),
               (const, override));
-  MOCK_METHOD(void,
-              AdjustNetworkParameters,
-              (const NetworkParams&),
+  MOCK_METHOD(void, AdjustNetworkParameters, (const NetworkParams&),
               (override));
   MOCK_METHOD(void, OnApplicationLimited, (QuicByteCount), (override));
-  MOCK_METHOD(void,
-              PopulateConnectionStats,
-              (QuicConnectionStats*),
+  MOCK_METHOD(void, PopulateConnectionStats, (QuicConnectionStats*),
               (const, override));
 };
 
@@ -1419,28 +1192,19 @@ class MockLossAlgorithm : public LossDetectionInterface {
   MockLossAlgorithm& operator=(const MockLossAlgorithm&) = delete;
   ~MockLossAlgorithm() override;
 
-  MOCK_METHOD(void,
-              SetFromConfig,
-              (const QuicConfig& config, Perspective perspective),
-              (override));
+  MOCK_METHOD(void, SetFromConfig,
+              (const QuicConfig& config, Perspective perspective), (override));
 
-  MOCK_METHOD(DetectionStats,
-              DetectLosses,
-              (const QuicUnackedPacketMap& unacked_packets,
-               QuicTime time,
+  MOCK_METHOD(DetectionStats, DetectLosses,
+              (const QuicUnackedPacketMap& unacked_packets, QuicTime time,
                const RttStats& rtt_stats,
                QuicPacketNumber largest_recently_acked,
-               const AckedPacketVector& packets_acked,
-               LostPacketVector*),
+               const AckedPacketVector& packets_acked, LostPacketVector*),
               (override));
   MOCK_METHOD(QuicTime, GetLossTimeout, (), (const, override));
-  MOCK_METHOD(void,
-              SpuriousLossDetected,
-              (const QuicUnackedPacketMap&,
-               const RttStats&,
-               QuicTime,
-               QuicPacketNumber,
-               QuicPacketNumber),
+  MOCK_METHOD(void, SpuriousLossDetected,
+              (const QuicUnackedPacketMap&, const RttStats&, QuicTime,
+               QuicPacketNumber, QuicPacketNumber),
               (override));
 
   MOCK_METHOD(void, OnConfigNegotiated, (), (override));
@@ -1456,14 +1220,10 @@ class MockAckListener : public QuicAckListenerInterface {
   MockAckListener(const MockAckListener&) = delete;
   MockAckListener& operator=(const MockAckListener&) = delete;
 
-  MOCK_METHOD(void,
-              OnPacketAcked,
-              (int acked_bytes, QuicTime::Delta ack_delay_time),
-              (override));
+  MOCK_METHOD(void, OnPacketAcked,
+              (int acked_bytes, QuicTime::Delta ack_delay_time), (override));
 
-  MOCK_METHOD(void,
-              OnPacketRetransmitted,
-              (int retransmitted_bytes),
+  MOCK_METHOD(void, OnPacketRetransmitted, (int retransmitted_bytes),
               (override));
 
  protected:
@@ -1488,29 +1248,18 @@ class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
   MockQuicConnectionDebugVisitor();
   ~MockQuicConnectionDebugVisitor() override;
 
-  MOCK_METHOD(void,
-              OnPacketSent,
-              (QuicPacketNumber,
-               QuicPacketLength,
-               bool,
-               TransmissionType,
-               EncryptionLevel,
-               const QuicFrames&,
-               const QuicFrames&,
-               QuicTime),
+  MOCK_METHOD(void, OnPacketSent,
+              (QuicPacketNumber, QuicPacketLength, bool, TransmissionType,
+               EncryptionLevel, const QuicFrames&, const QuicFrames&, QuicTime),
               (override));
 
-  MOCK_METHOD(void,
-              OnCoalescedPacketSent,
-              (const QuicCoalescedPacket&, size_t),
+  MOCK_METHOD(void, OnCoalescedPacketSent, (const QuicCoalescedPacket&, size_t),
               (override));
 
   MOCK_METHOD(void, OnPingSent, (), (override));
 
-  MOCK_METHOD(void,
-              OnPacketReceived,
-              (const QuicSocketAddress&,
-               const QuicSocketAddress&,
+  MOCK_METHOD(void, OnPacketReceived,
+              (const QuicSocketAddress&, const QuicSocketAddress&,
                const QuicEncryptedPacket&),
               (override));
 
@@ -1518,83 +1267,57 @@ class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
 
   MOCK_METHOD(void, OnProtocolVersionMismatch, (ParsedQuicVersion), (override));
 
-  MOCK_METHOD(void,
-              OnPacketHeader,
-              (const QuicPacketHeader& header,
-               QuicTime receive_time,
+  MOCK_METHOD(void, OnPacketHeader,
+              (const QuicPacketHeader& header, QuicTime receive_time,
                EncryptionLevel level),
               (override));
 
-  MOCK_METHOD(void,
-              OnSuccessfulVersionNegotiation,
-              (const ParsedQuicVersion&),
+  MOCK_METHOD(void, OnSuccessfulVersionNegotiation, (const ParsedQuicVersion&),
               (override));
 
   MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame&), (override));
 
   MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
 
-  MOCK_METHOD(void,
-              OnStopWaitingFrame,
-              (const QuicStopWaitingFrame&),
+  MOCK_METHOD(void, OnStopWaitingFrame, (const QuicStopWaitingFrame&),
               (override));
 
   MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
 
-  MOCK_METHOD(void,
-              OnConnectionCloseFrame,
-              (const QuicConnectionCloseFrame&),
+  MOCK_METHOD(void, OnConnectionCloseFrame, (const QuicConnectionCloseFrame&),
               (override));
 
   MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame&), (override));
 
-  MOCK_METHOD(void,
-              OnNewConnectionIdFrame,
-              (const QuicNewConnectionIdFrame&),
+  MOCK_METHOD(void, OnNewConnectionIdFrame, (const QuicNewConnectionIdFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnRetireConnectionIdFrame,
-              (const QuicRetireConnectionIdFrame&),
-              (override));
+  MOCK_METHOD(void, OnRetireConnectionIdFrame,
+              (const QuicRetireConnectionIdFrame&), (override));
 
   MOCK_METHOD(void, OnNewTokenFrame, (const QuicNewTokenFrame&), (override));
 
   MOCK_METHOD(void, OnMessageFrame, (const QuicMessageFrame&), (override));
 
-  MOCK_METHOD(void,
-              OnStopSendingFrame,
-              (const QuicStopSendingFrame&),
+  MOCK_METHOD(void, OnStopSendingFrame, (const QuicStopSendingFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnPathChallengeFrame,
-              (const QuicPathChallengeFrame&),
+  MOCK_METHOD(void, OnPathChallengeFrame, (const QuicPathChallengeFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnPathResponseFrame,
-              (const QuicPathResponseFrame&),
+  MOCK_METHOD(void, OnPathResponseFrame, (const QuicPathResponseFrame&),
               (override));
 
-  MOCK_METHOD(void,
-              OnPublicResetPacket,
-              (const QuicPublicResetPacket&),
+  MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket&),
               (override));
 
-  MOCK_METHOD(void,
-              OnVersionNegotiationPacket,
-              (const QuicVersionNegotiationPacket&),
-              (override));
+  MOCK_METHOD(void, OnVersionNegotiationPacket,
+              (const QuicVersionNegotiationPacket&), (override));
 
-  MOCK_METHOD(void,
-              OnTransportParametersSent,
-              (const TransportParameters&),
+  MOCK_METHOD(void, OnTransportParametersSent, (const TransportParameters&),
               (override));
 
-  MOCK_METHOD(void,
-              OnTransportParametersReceived,
-              (const TransportParameters&),
+  MOCK_METHOD(void, OnTransportParametersReceived, (const TransportParameters&),
               (override));
 
   MOCK_METHOD(void, OnZeroRttRejected, (int), (override));
@@ -1606,14 +1329,11 @@ class MockReceivedPacketManager : public QuicReceivedPacketManager {
   explicit MockReceivedPacketManager(QuicConnectionStats* stats);
   ~MockReceivedPacketManager() override;
 
-  MOCK_METHOD(void,
-              RecordPacketReceived,
+  MOCK_METHOD(void, RecordPacketReceived,
               (const QuicPacketHeader& header, QuicTime receipt_time),
               (override));
   MOCK_METHOD(bool, IsMissing, (QuicPacketNumber packet_number), (override));
-  MOCK_METHOD(bool,
-              IsAwaitingPacket,
-              (QuicPacketNumber packet_number),
+  MOCK_METHOD(bool, IsAwaitingPacket, (QuicPacketNumber packet_number),
               (const, override));
   MOCK_METHOD(bool, HasNewMissingPackets, (), (const, override));
   MOCK_METHOD(bool, ack_frame_updated, (), (const, override));
@@ -1629,22 +1349,15 @@ class MockPacketCreatorDelegate : public QuicPacketCreator::DelegateInterface {
 
   MOCK_METHOD(QuicPacketBuffer, GetPacketBuffer, (), (override));
   MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket), (override));
-  MOCK_METHOD(void,
-              OnUnrecoverableError,
-              (QuicErrorCode, const std::string&),
+  MOCK_METHOD(void, OnUnrecoverableError, (QuicErrorCode, const std::string&),
               (override));
-  MOCK_METHOD(bool,
-              ShouldGeneratePacket,
+  MOCK_METHOD(bool, ShouldGeneratePacket,
               (HasRetransmittableData retransmittable, IsHandshake handshake),
               (override));
-  MOCK_METHOD(const QuicFrames,
-              MaybeBundleAckOpportunistically,
-              (),
-              (override));
-  MOCK_METHOD(SerializedPacketFate,
-              GetSerializedPacketFate,
-              (bool, EncryptionLevel),
+  MOCK_METHOD(const QuicFrames, MaybeBundleAckOpportunistically, (),
               (override));
+  MOCK_METHOD(SerializedPacketFate, GetSerializedPacketFate,
+              (bool, EncryptionLevel), (override));
 };
 
 class MockSessionNotifier : public SessionNotifierInterface {
@@ -1652,19 +1365,13 @@ class MockSessionNotifier : public SessionNotifierInterface {
   MockSessionNotifier();
   ~MockSessionNotifier() override;
 
-  MOCK_METHOD(bool,
-              OnFrameAcked,
-              (const QuicFrame&, QuicTime::Delta, QuicTime),
+  MOCK_METHOD(bool, OnFrameAcked, (const QuicFrame&, QuicTime::Delta, QuicTime),
               (override));
-  MOCK_METHOD(void,
-              OnStreamFrameRetransmitted,
-              (const QuicStreamFrame&),
+  MOCK_METHOD(void, OnStreamFrameRetransmitted, (const QuicStreamFrame&),
               (override));
   MOCK_METHOD(void, OnFrameLost, (const QuicFrame&), (override));
-  MOCK_METHOD(void,
-              RetransmitFrames,
-              (const QuicFrames&, TransmissionType type),
-              (override));
+  MOCK_METHOD(void, RetransmitFrames,
+              (const QuicFrames&, TransmissionType type), (override));
   MOCK_METHOD(bool, IsFrameOutstanding, (const QuicFrame&), (const, override));
   MOCK_METHOD(bool, HasUnackedCryptoData, (), (const, override));
   MOCK_METHOD(bool, HasUnackedStreamData, (), (const, override));
@@ -1676,8 +1383,7 @@ class MockQuicPathValidationContext : public QuicPathValidationContext {
                                 const QuicSocketAddress& peer_address,
                                 const QuicSocketAddress& effective_peer_address,
                                 QuicPacketWriter* writer)
-      : QuicPathValidationContext(self_address,
-                                  peer_address,
+      : QuicPathValidationContext(self_address, peer_address,
                                   effective_peer_address),
         writer_(writer) {}
   QuicPacketWriter* WriterToUse() override { return writer_; }
@@ -1689,15 +1395,11 @@ class MockQuicPathValidationContext : public QuicPathValidationContext {
 class MockQuicPathValidationResultDelegate
     : public QuicPathValidator::ResultDelegate {
  public:
-  MOCK_METHOD(void,
-              OnPathValidationSuccess,
-              (std::unique_ptr<QuicPathValidationContext>),
-              (override));
+  MOCK_METHOD(void, OnPathValidationSuccess,
+              (std::unique_ptr<QuicPathValidationContext>), (override));
 
-  MOCK_METHOD(void,
-              OnPathValidationFailure,
-              (std::unique_ptr<QuicPathValidationContext>),
-              (override));
+  MOCK_METHOD(void, OnPathValidationFailure,
+              (std::unique_ptr<QuicPathValidationContext>), (override));
 };
 
 class QuicCryptoClientStreamPeer {
@@ -1724,11 +1426,9 @@ class QuicCryptoClientStreamPeer {
 // client_session: Pointer reference for the newly created client
 //   session.  The new object will be owned by the caller.
 void CreateClientSessionForTest(
-    QuicServerId server_id,
-    QuicTime::Delta connection_start_time,
+    QuicServerId server_id, QuicTime::Delta connection_start_time,
     const ParsedQuicVersionVector& supported_versions,
-    MockQuicConnectionHelper* helper,
-    MockAlarmFactory* alarm_factory,
+    MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
     QuicCryptoClientConfig* crypto_client_config,
     PacketSavingConnection** client_connection,
     TestQuicSpdyClientSession** client_session);
@@ -1749,11 +1449,9 @@ void CreateClientSessionForTest(
 // server_session: Pointer reference for the newly created server
 //   session.  The new object will be owned by the caller.
 void CreateServerSessionForTest(
-    QuicServerId server_id,
-    QuicTime::Delta connection_start_time,
+    QuicServerId server_id, QuicTime::Delta connection_start_time,
     ParsedQuicVersionVector supported_versions,
-    MockQuicConnectionHelper* helper,
-    MockAlarmFactory* alarm_factory,
+    MockQuicConnectionHelper* helper, MockAlarmFactory* alarm_factory,
     QuicCryptoServerConfig* crypto_server_config,
     QuicCompressedCertsCache* compressed_certs_cache,
     PacketSavingConnection** server_connection,
@@ -1805,30 +1503,18 @@ inline void MakeIOVector(absl::string_view str, struct iovec* iov) {
 // HTTP stream numbering scheme (i.e. whether one or two QUIC streams are used
 // per HTTP transaction).
 QuicStreamId GetNthClientInitiatedBidirectionalStreamId(
-    QuicTransportVersion version,
-    int n);
+    QuicTransportVersion version, int n);
 QuicStreamId GetNthServerInitiatedBidirectionalStreamId(
-    QuicTransportVersion version,
-    int n);
+    QuicTransportVersion version, int n);
 QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(
-    QuicTransportVersion version,
-    int n);
+    QuicTransportVersion version, int n);
 QuicStreamId GetNthClientInitiatedUnidirectionalStreamId(
-    QuicTransportVersion version,
-    int n);
+    QuicTransportVersion version, int n);
 
-StreamType DetermineStreamType(QuicStreamId id,
-                               ParsedQuicVersion version,
-                               Perspective perspective,
-                               bool is_incoming,
+StreamType DetermineStreamType(QuicStreamId id, ParsedQuicVersion version,
+                               Perspective perspective, bool is_incoming,
                                StreamType default_type);
 
-// Utility function that stores message_data in |storage| and returns a
-// QuicMemSliceSpan.
-QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
-                          absl::string_view message_data,
-                          QuicMemSliceStorage* storage);
-
 // Creates a MemSlice using a singleton trivial buffer allocator.  Performs a
 // copy.
 QuicMemSlice MemSliceFromString(absl::string_view data);
@@ -1842,15 +1528,12 @@ MATCHER_P(ReceivedPacketInfoConnectionIdEquals, destination_connection_id, "") {
   return arg.destination_connection_id == destination_connection_id;
 }
 
-MATCHER_P2(InRange, min, max, "") {
-  return arg >= min && arg <= max;
-}
+MATCHER_P2(InRange, min, max, "") { return arg >= min && arg <= max; }
 
 // A GMock matcher that prints expected and actual QuicErrorCode strings
 // upon failure.  Example usage:
 // EXPECT_THAT(stream_->connection_error(), IsError(QUIC_INTERNAL_ERROR));
-MATCHER_P(IsError,
-          expected,
+MATCHER_P(IsError, expected,
           absl::StrCat(negation ? "isn't equal to " : "is equal to ",
                        QuicErrorCodeToString(expected))) {
   *result_listener << QuicErrorCodeToString(static_cast<QuicErrorCode>(arg));
@@ -1869,8 +1552,7 @@ MATCHER(IsQuicNoError,
 // A GMock matcher that prints expected and actual QuicRstStreamErrorCode
 // strings upon failure.  Example usage:
 // EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR));
-MATCHER_P(IsStreamError,
-          expected,
+MATCHER_P(IsStreamError, expected,
           absl::StrCat(negation ? "isn't equal to " : "is equal to ",
                        QuicRstStreamErrorCodeToString(expected))) {
   *result_listener << QuicRstStreamErrorCodeToString(arg);
@@ -1908,12 +1590,9 @@ class TaggingEncrypter : public QuicEncrypter {
     return true;
   }
 
-  bool EncryptPacket(uint64_t packet_number,
-                     absl::string_view associated_data,
-                     absl::string_view plaintext,
-                     char* output,
-                     size_t* output_length,
-                     size_t max_output_length) override;
+  bool EncryptPacket(uint64_t packet_number, absl::string_view associated_data,
+                     absl::string_view plaintext, char* output,
+                     size_t* output_length, size_t max_output_length) override;
 
   std::string GenerateHeaderProtectionMask(
       absl::string_view /*sample*/) override {
@@ -1978,12 +1657,9 @@ class TaggingDecrypter : public QuicDecrypter {
     return true;
   }
 
-  bool DecryptPacket(uint64_t packet_number,
-                     absl::string_view associated_data,
-                     absl::string_view ciphertext,
-                     char* output,
-                     size_t* output_length,
-                     size_t max_output_length) override;
+  bool DecryptPacket(uint64_t packet_number, absl::string_view associated_data,
+                     absl::string_view ciphertext, char* output,
+                     size_t* output_length, size_t max_output_length) override;
 
   std::string GenerateHeaderProtectionMask(
       QuicDataReader* /*sample_reader*/) override {
@@ -2040,8 +1716,7 @@ class TestPacketWriter : public QuicPacketWriter {
   };
 
  public:
-  TestPacketWriter(ParsedQuicVersion version,
-                   MockClock* clock,
+  TestPacketWriter(ParsedQuicVersion version, MockClock* clock,
                    Perspective perspective);
 
   TestPacketWriter(const TestPacketWriter&) = delete;
@@ -2050,8 +1725,7 @@ class TestPacketWriter : public QuicPacketWriter {
   ~TestPacketWriter() override;
 
   // QuicPacketWriter interface
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
+  WriteResult WritePacket(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           PerPacketOptions* options) override;
@@ -2277,8 +1951,7 @@ class TestPacketWriter : public QuicPacketWriter {
 // contents of the destination connection ID passed in to
 // WriteClientVersionNegotiationProbePacket.
 bool ParseClientVersionNegotiationProbePacket(
-    const char* packet_bytes,
-    size_t packet_length,
+    const char* packet_bytes, size_t packet_length,
     char* destination_connection_id_bytes,
     uint8_t* destination_connection_id_length_out);
 
@@ -2291,8 +1964,7 @@ bool ParseClientVersionNegotiationProbePacket(
 // the source connection ID, and must point to |source_connection_id_length|
 // bytes of memory.
 bool WriteServerVersionNegotiationProbeResponse(
-    char* packet_bytes,
-    size_t* packet_length_out,
+    char* packet_bytes, size_t* packet_length_out,
     const char* source_connection_id_bytes,
     uint8_t source_connection_id_length);
 
@@ -2330,13 +2002,14 @@ class MockHttp3DatagramRegistrationVisitor
   MOCK_METHOD(void, OnContextReceived,
               (QuicStreamId stream_id,
                absl::optional<QuicDatagramContextId> context_id,
-               const Http3DatagramContextExtensions& extensions),
+               DatagramFormatType format_type,
+               absl::string_view format_additional_data),
               (override));
 
   MOCK_METHOD(void, OnContextClosed,
               (QuicStreamId stream_id,
                absl::optional<QuicDatagramContextId> context_id,
-               const Http3DatagramContextExtensions& extensions),
+               ContextCloseCode close_code, absl::string_view close_details),
               (override));
 };
 
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.cc b/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.cc
index 8f614e8d89d..cbcd36e1550 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.cc
@@ -36,5 +36,11 @@ bool QuicTimeWaitListManagerPeer::SendOrQueuePacket(
   return manager->SendOrQueuePacket(std::move(packet), packet_context);
 }
 
+// static
+size_t QuicTimeWaitListManagerPeer::PendingPacketsQueueSize(
+    QuicTimeWaitListManager* manager) {
+  return manager->pending_packets_queue_.size();
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.h b/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.h
index 4e0a4a707ad..a314e039591 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.h
@@ -26,6 +26,8 @@ class QuicTimeWaitListManagerPeer {
       QuicTimeWaitListManager* manager,
       std::unique_ptr<QuicTimeWaitListManager::QueuedPacket> packet,
       const QuicPerPacketContext* packet_context);
+
+  static size_t PendingPacketsQueueSize(QuicTimeWaitListManager* manager);
 };
 
 }  // namespace test
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/quic_transport_test_tools.h b/chromium/net/third_party/quiche/src/quic/test_tools/quic_transport_test_tools.h
index df52093e05a..5babfd280cb 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/quic_transport_test_tools.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/quic_transport_test_tools.h
@@ -14,7 +14,9 @@ namespace test {
 
 class MockClientVisitor : public WebTransportVisitor {
  public:
-  MOCK_METHOD(void, OnSessionReady, (), (override));
+  MOCK_METHOD(void, OnSessionReady, (const spdy::SpdyHeaderBlock&), (override));
+  MOCK_METHOD(void, OnSessionClosed,
+              (WebTransportSessionError, const std::string&), (override));
   MOCK_METHOD(void, OnIncomingBidirectionalStreamAvailable, (), (override));
   MOCK_METHOD(void, OnIncomingUnidirectionalStreamAvailable, (), (override));
   MOCK_METHOD(void, OnDatagramReceived, (absl::string_view), (override));
@@ -32,6 +34,12 @@ class MockStreamVisitor : public WebTransportStreamVisitor {
  public:
   MOCK_METHOD(void, OnCanRead, (), (override));
   MOCK_METHOD(void, OnCanWrite, (), (override));
+
+  MOCK_METHOD(void, OnResetStreamReceived, (WebTransportStreamError error),
+              (override));
+  MOCK_METHOD(void, OnStopSendingReceived, (WebTransportStreamError error),
+              (override));
+  MOCK_METHOD(void, OnWriteSideInDataRecvdState, (), (override));
 };
 
 }  // namespace test
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.cc b/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.cc
index a1383b0e41d..ce498ca2d95 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.cc
@@ -111,6 +111,21 @@ void SimpleSessionNotifier::WriteOrBufferRstStream(
   WriteBufferedControlFrames();
 }
 
+void SimpleSessionNotifier::WriteOrBufferWindowUpate(
+    QuicStreamId id, QuicStreamOffset byte_offset) {
+  QUIC_DVLOG(1) << "Writing WINDOW_UPDATE";
+  const bool had_buffered_data =
+      HasBufferedStreamData() || HasBufferedControlFrames();
+  QuicControlFrameId control_frame_id = ++last_control_frame_id_;
+  control_frames_.emplace_back((
+      QuicFrame(new QuicWindowUpdateFrame(control_frame_id, id, byte_offset))));
+  if (had_buffered_data) {
+    QUIC_DLOG(WARNING) << "Connection is write blocked";
+    return;
+  }
+  WriteBufferedControlFrames();
+}
+
 void SimpleSessionNotifier::WriteOrBufferPing() {
   QUIC_DVLOG(1) << "Writing PING_FRAME";
   const bool had_buffered_data =
@@ -175,8 +190,7 @@ void SimpleSessionNotifier::OnCanWrite() {
       !RetransmitLostStreamData()) {
     return;
   }
-  // Write buffered control frames.
-  if (!WriteBufferedControlFrames()) {
+  if (!WriteBufferedCryptoData() || !WriteBufferedControlFrames()) {
     return;
   }
   // Write new data.
@@ -666,6 +680,26 @@ bool SimpleSessionNotifier::RetransmitLostStreamData() {
   return !HasLostStreamData();
 }
 
+bool SimpleSessionNotifier::WriteBufferedCryptoData() {
+  for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
+    const StreamState& state = crypto_state_[i];
+    QuicIntervalSet<QuicStreamOffset> buffered_crypto_data(0,
+                                                           state.bytes_total);
+    buffered_crypto_data.Difference(crypto_bytes_transferred_[i]);
+    for (const auto& interval : buffered_crypto_data) {
+      size_t bytes_written = connection_->SendCryptoData(
+          static_cast<EncryptionLevel>(i), interval.Length(), interval.min());
+      crypto_state_[i].bytes_sent += bytes_written;
+      crypto_bytes_transferred_[i].Add(interval.min(),
+                                       interval.min() + bytes_written);
+      if (bytes_written < interval.Length()) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 bool SimpleSessionNotifier::WriteBufferedControlFrames() {
   while (HasBufferedControlFrames()) {
     QuicFrame frame_to_send =
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h b/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h
index 8bdadb2f45d..5712884fcd2 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h
@@ -34,6 +34,10 @@ class SimpleSessionNotifier : public SessionNotifierInterface {
   void WriteOrBufferRstStream(QuicStreamId id,
                               QuicRstStreamErrorCode error,
                               QuicStreamOffset bytes_written);
+
+  // Tries to write WINDOW_UPDATE.
+  void WriteOrBufferWindowUpate(QuicStreamId id, QuicStreamOffset byte_offset);
+
   // Tries to write PING.
   void WriteOrBufferPing();
 
@@ -127,6 +131,8 @@ class SimpleSessionNotifier : public SessionNotifierInterface {
 
   bool WriteBufferedControlFrames();
 
+  bool WriteBufferedCryptoData();
+
   bool IsControlFrameOutstanding(const QuicFrame& frame) const;
 
   bool HasBufferedControlFrames() const;
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/simulator/queue.h b/chromium/net/third_party/quiche/src/quic/test_tools/simulator/queue.h
index 7e4be833690..dd810e7e2f5 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/simulator/queue.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/simulator/queue.h
@@ -73,7 +73,7 @@ class Queue : public Actor, public UnconstrainedPortInterface {
   };
 
   // Alarm handler for aggregation timeout.
-  class AggregationAlarmDelegate : public QuicAlarm::Delegate {
+  class AggregationAlarmDelegate : public QuicAlarm::DelegateWithoutContext {
    public:
     explicit AggregationAlarmDelegate(Queue* queue);
 
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator.h b/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator.h
index 8f31717e712..b4298f53e50 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator.h
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator.h
@@ -88,7 +88,7 @@ class Simulator : public QuicConnectionHelperInterface {
   };
 
   // The delegate used for RunFor().
-  class RunForDelegate : public QuicAlarm::Delegate {
+  class RunForDelegate : public QuicAlarm::DelegateWithoutContext {
    public:
     explicit RunForDelegate(bool* run_for_should_stop);
     void OnAlarm() override;
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator_test.cc b/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator_test.cc
index a71649eb4b5..fe841703cf4 100644
--- a/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator_test.cc
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/simulator/simulator_test.cc
@@ -475,7 +475,7 @@ class AlarmToggler : public Actor {
 };
 
 // Counts the number of times an alarm has fired.
-class CounterDelegate : public QuicAlarm::Delegate {
+class CounterDelegate : public QuicAlarm::DelegateWithoutContext {
  public:
   explicit CounterDelegate(size_t* counter) : counter_(counter) {}
 
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/web_transport_resets_backend.cc b/chromium/net/third_party/quiche/src/quic/test_tools/web_transport_resets_backend.cc
new file mode 100644
index 00000000000..512619fee0a
--- /dev/null
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/web_transport_resets_backend.cc
@@ -0,0 +1,113 @@
+// Copyright (c) 2021 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 "quic/test_tools/web_transport_resets_backend.h"
+
+#include <memory>
+
+#include "quic/core/web_transport_interface.h"
+#include "quic/tools/web_transport_test_visitors.h"
+#include "common/quiche_circular_deque.h"
+
+namespace quic {
+namespace test {
+
+namespace {
+
+class ResetsVisitor;
+
+class BidirectionalEchoVisitorWithLogging
+    : public WebTransportBidirectionalEchoVisitor {
+ public:
+  BidirectionalEchoVisitorWithLogging(WebTransportStream* stream,
+                                      ResetsVisitor* session_visitor)
+      : WebTransportBidirectionalEchoVisitor(stream),
+        session_visitor_(session_visitor) {}
+
+  void OnResetStreamReceived(WebTransportStreamError error) override;
+  void OnStopSendingReceived(WebTransportStreamError error) override;
+
+ private:
+  ResetsVisitor* session_visitor_;  // Not owned.
+};
+
+class ResetsVisitor : public WebTransportVisitor {
+ public:
+  ResetsVisitor(WebTransportSession* session) : session_(session) {}
+
+  void OnSessionReady(const spdy::SpdyHeaderBlock& /*headers*/) override {}
+  void OnSessionClosed(WebTransportSessionError /*error_code*/,
+                       const std::string& /*error_message*/) override {}
+
+  void OnIncomingBidirectionalStreamAvailable() override {
+    while (true) {
+      WebTransportStream* stream =
+          session_->AcceptIncomingBidirectionalStream();
+      if (stream == nullptr) {
+        return;
+      }
+      stream->SetVisitor(
+          std::make_unique<BidirectionalEchoVisitorWithLogging>(stream, this));
+      stream->visitor()->OnCanRead();
+    }
+  }
+  void OnIncomingUnidirectionalStreamAvailable() override {}
+
+  void OnDatagramReceived(absl::string_view /*datagram*/) override {}
+
+  void OnCanCreateNewOutgoingBidirectionalStream() override {}
+  void OnCanCreateNewOutgoingUnidirectionalStream() override {
+    MaybeSendLogsBack();
+  }
+
+  void Log(std::string line) {
+    log_.push_back(std::move(line));
+    MaybeSendLogsBack();
+  }
+
+ private:
+  void MaybeSendLogsBack() {
+    while (!log_.empty() &&
+           session_->CanOpenNextOutgoingUnidirectionalStream()) {
+      WebTransportStream* stream = session_->OpenOutgoingUnidirectionalStream();
+      stream->SetVisitor(
+          std::make_unique<WebTransportUnidirectionalEchoWriteVisitor>(
+              stream, log_.front()));
+      log_.pop_front();
+      stream->visitor()->OnCanWrite();
+    }
+  }
+
+  WebTransportSession* session_;  // Not owned.
+  quiche::QuicheCircularDeque<std::string> log_;
+};
+
+void BidirectionalEchoVisitorWithLogging::OnResetStreamReceived(
+    WebTransportStreamError error) {
+  session_visitor_->Log(absl::StrCat("Received reset for stream ",
+                                     stream()->GetStreamId(),
+                                     " with error code ", error));
+  WebTransportBidirectionalEchoVisitor::OnResetStreamReceived(error);
+}
+void BidirectionalEchoVisitorWithLogging::OnStopSendingReceived(
+    WebTransportStreamError error) {
+  session_visitor_->Log(absl::StrCat("Received stop sending for stream ",
+                                     stream()->GetStreamId(),
+                                     " with error code ", error));
+  WebTransportBidirectionalEchoVisitor::OnStopSendingReceived(error);
+}
+
+}  // namespace
+
+QuicSimpleServerBackend::WebTransportResponse WebTransportResetsBackend(
+    const spdy::Http2HeaderBlock& /*request_headers*/,
+    WebTransportSession* session) {
+  QuicSimpleServerBackend::WebTransportResponse response;
+  response.response_headers[":status"] = "200";
+  response.visitor = std::make_unique<ResetsVisitor>(session);
+  return response;
+}
+
+}  // namespace test
+}  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/test_tools/web_transport_resets_backend.h b/chromium/net/third_party/quiche/src/quic/test_tools/web_transport_resets_backend.h
new file mode 100644
index 00000000000..dda06be521f
--- /dev/null
+++ b/chromium/net/third_party/quiche/src/quic/test_tools/web_transport_resets_backend.h
@@ -0,0 +1,23 @@
+// Copyright (c) 2021 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.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_
+#define QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_
+
+#include "quic/test_tools/quic_test_backend.h"
+
+namespace quic {
+namespace test {
+
+// A backend for testing RESET_STREAM/STOP_SENDING behavior.  Provides
+// bidirectional echo streams; whenever one of those receives RESET_STREAM or
+// STOP_SENDING, a log message is sent as a unidirectional stream.
+QuicSimpleServerBackend::WebTransportResponse WebTransportResetsBackend(
+    const spdy::Http2HeaderBlock& request_headers,
+    WebTransportSession* session);
+
+}  // namespace test
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_