diff --git a/quiche/quic/core/http/http_decoder.cc b/quiche/quic/core/http/http_decoder.cc
index 23bc5df..0008d14 100644
--- a/quiche/quic/core/http/http_decoder.cc
+++ b/quiche/quic/core/http/http_decoder.cc
@@ -51,8 +51,7 @@
 HttpDecoder::~HttpDecoder() {}
 
 // static
-bool HttpDecoder::DecodeSettings(const char* data,
-                                 QuicByteCount len,
+bool HttpDecoder::DecodeSettings(const char* data, QuicByteCount len,
                                  SettingsFrame* frame) {
   QuicDataReader reader(data, len);
   uint64_t frame_type;
@@ -616,7 +615,7 @@
 }
 
 bool HttpDecoder::ParsePriorityUpdateFrame(QuicDataReader* reader,
-                                              PriorityUpdateFrame* frame) {
+                                           PriorityUpdateFrame* frame) {
   frame->prioritized_element_type = REQUEST_STREAM;
 
   if (!reader->ReadVarInt62(&frame->prioritized_element_id)) {
diff --git a/quiche/quic/core/http/http_decoder.h b/quiche/quic/core/http/http_decoder.h
index 59553a3..137755e 100644
--- a/quiche/quic/core/http/http_decoder.h
+++ b/quiche/quic/core/http/http_decoder.h
@@ -100,8 +100,7 @@
     // return bool, because WEBTRANSPORT_STREAM always causes the parsing
     // process to cease.
     virtual void OnWebTransportStreamFrameType(
-        QuicByteCount header_length,
-        WebTransportSessionId session_id) = 0;
+        QuicByteCount header_length, WebTransportSessionId session_id) = 0;
 
     // Called when a frame of unknown type |frame_type| has been received.
     // Frame type might be reserved, Visitor must make sure to ignore.
@@ -135,8 +134,7 @@
   // Decode settings frame from |data|.
   // Upon successful decoding, |frame| will be populated, and returns true.
   // This method is not used for regular processing of incoming data.
-  static bool DecodeSettings(const char* data,
-                             QuicByteCount len,
+  static bool DecodeSettings(const char* data, QuicByteCount len,
                              SettingsFrame* frame);
 
   // Returns an error code other than QUIC_NO_ERROR if and only if
diff --git a/quiche/quic/core/http/http_decoder_test.cc b/quiche/quic/core/http/http_decoder_test.cc
index 962f53c..f385410 100644
--- a/quiche/quic/core/http/http_decoder_test.cc
+++ b/quiche/quic/core/http/http_decoder_test.cc
@@ -45,65 +45,44 @@
   // Called if an error is detected.
   MOCK_METHOD(void, OnError, (HttpDecoder*), (override));
 
-  MOCK_METHOD(bool,
-              OnMaxPushIdFrame,
-              (const MaxPushIdFrame& frame),
+  MOCK_METHOD(bool, OnMaxPushIdFrame, (const MaxPushIdFrame& frame),
               (override));
   MOCK_METHOD(bool, OnGoAwayFrame, (const GoAwayFrame& frame), (override));
-  MOCK_METHOD(bool,
-              OnSettingsFrameStart,
-              (QuicByteCount header_length),
+  MOCK_METHOD(bool, OnSettingsFrameStart, (QuicByteCount header_length),
               (override));
   MOCK_METHOD(bool, OnSettingsFrame, (const SettingsFrame& frame), (override));
 
-  MOCK_METHOD(bool,
-              OnDataFrameStart,
+  MOCK_METHOD(bool, OnDataFrameStart,
               (QuicByteCount header_length, QuicByteCount payload_length),
               (override));
-  MOCK_METHOD(bool,
-              OnDataFramePayload,
-              (absl::string_view payload),
+  MOCK_METHOD(bool, OnDataFramePayload, (absl::string_view payload),
               (override));
   MOCK_METHOD(bool, OnDataFrameEnd, (), (override));
 
-  MOCK_METHOD(bool,
-              OnHeadersFrameStart,
+  MOCK_METHOD(bool, OnHeadersFrameStart,
               (QuicByteCount header_length, QuicByteCount payload_length),
               (override));
-  MOCK_METHOD(bool,
-              OnHeadersFramePayload,
-              (absl::string_view payload),
+  MOCK_METHOD(bool, OnHeadersFramePayload, (absl::string_view payload),
               (override));
   MOCK_METHOD(bool, OnHeadersFrameEnd, (), (override));
 
-  MOCK_METHOD(bool,
-              OnPriorityUpdateFrameStart,
-              (QuicByteCount header_length),
+  MOCK_METHOD(bool, OnPriorityUpdateFrameStart, (QuicByteCount header_length),
               (override));
-  MOCK_METHOD(bool,
-              OnPriorityUpdateFrame,
-              (const PriorityUpdateFrame& frame),
+  MOCK_METHOD(bool, OnPriorityUpdateFrame, (const PriorityUpdateFrame& frame),
               (override));
 
-  MOCK_METHOD(bool,
-              OnAcceptChFrameStart,
-              (QuicByteCount header_length),
+  MOCK_METHOD(bool, OnAcceptChFrameStart, (QuicByteCount header_length),
               (override));
   MOCK_METHOD(bool, OnAcceptChFrame, (const AcceptChFrame& frame), (override));
-  MOCK_METHOD(void,
-              OnWebTransportStreamFrameType,
+  MOCK_METHOD(void, OnWebTransportStreamFrameType,
               (QuicByteCount header_length, WebTransportSessionId session_id),
               (override));
 
-  MOCK_METHOD(bool,
-              OnUnknownFrameStart,
-              (uint64_t frame_type,
-               QuicByteCount header_length,
+  MOCK_METHOD(bool, OnUnknownFrameStart,
+              (uint64_t frame_type, QuicByteCount header_length,
                QuicByteCount payload_length),
               (override));
-  MOCK_METHOD(bool,
-              OnUnknownFramePayload,
-              (absl::string_view payload),
+  MOCK_METHOD(bool, OnUnknownFramePayload, (absl::string_view payload),
               (override));
   MOCK_METHOD(bool, OnUnknownFrameEnd, (), (override));
 };
diff --git a/quiche/quic/core/http/http_encoder.cc b/quiche/quic/core/http/http_encoder.cc
index fa9c154..32c8d91 100644
--- a/quiche/quic/core/http/http_encoder.cc
+++ b/quiche/quic/core/http/http_encoder.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/core/http/http_encoder.h"
+
 #include <cstdint>
 #include <memory>
 
@@ -18,8 +19,7 @@
 
 namespace {
 
-bool WriteFrameHeader(QuicByteCount length,
-                      HttpFrameType type,
+bool WriteFrameHeader(QuicByteCount length, HttpFrameType type,
                       QuicDataWriter* writer) {
   return writer->WriteVarInt62(static_cast<uint64_t>(type)) &&
          writer->WriteVarInt62(length);
@@ -61,8 +61,7 @@
 
 // static
 QuicByteCount HttpEncoder::SerializeHeadersFrameHeader(
-    QuicByteCount payload_length,
-    std::unique_ptr<char[]>* output) {
+    QuicByteCount payload_length, std::unique_ptr<char[]>* output) {
   QUICHE_DCHECK_NE(0u, payload_length);
   QuicByteCount header_length =
       QuicDataWriter::GetVarInt62Len(payload_length) +
@@ -83,8 +82,7 @@
 
 // static
 QuicByteCount HttpEncoder::SerializeSettingsFrame(
-    const SettingsFrame& settings,
-    std::unique_ptr<char[]>* output) {
+    const SettingsFrame& settings, std::unique_ptr<char[]>* output) {
   QuicByteCount payload_length = 0;
   std::vector<std::pair<uint64_t, uint64_t>> ordered_settings{
       settings.values.begin(), settings.values.end()};
@@ -120,8 +118,7 @@
 
 // static
 QuicByteCount HttpEncoder::SerializeGoAwayFrame(
-    const GoAwayFrame& goaway,
-    std::unique_ptr<char[]>* output) {
+    const GoAwayFrame& goaway, std::unique_ptr<char[]>* output) {
   QuicByteCount payload_length = QuicDataWriter::GetVarInt62Len(goaway.id);
   QuicByteCount total_length =
       GetTotalLength(payload_length, HttpFrameType::GOAWAY);
@@ -173,8 +170,7 @@
 
 // static
 QuicByteCount HttpEncoder::SerializeAcceptChFrame(
-    const AcceptChFrame& accept_ch,
-    std::unique_ptr<char[]>* output) {
+    const AcceptChFrame& accept_ch, std::unique_ptr<char[]>* output) {
   QuicByteCount payload_length = 0;
   for (const auto& entry : accept_ch.entries) {
     payload_length += QuicDataWriter::GetVarInt62Len(entry.origin.size());
@@ -255,8 +251,7 @@
 }
 
 QuicByteCount HttpEncoder::SerializeWebTransportStreamFrameHeader(
-    WebTransportSessionId session_id,
-    std::unique_ptr<char[]>* output) {
+    WebTransportSessionId session_id, std::unique_ptr<char[]>* output) {
   uint64_t stream_type =
       static_cast<uint64_t>(HttpFrameType::WEBTRANSPORT_STREAM);
   QuicByteCount header_length = QuicDataWriter::GetVarInt62Len(stream_type) +
diff --git a/quiche/quic/core/http/http_encoder.h b/quiche/quic/core/http/http_encoder.h
index eba0e55..fc5987f 100644
--- a/quiche/quic/core/http/http_encoder.h
+++ b/quiche/quic/core/http/http_encoder.h
@@ -34,8 +34,7 @@
   // Serializes a HEADERS frame header into a new buffer stored in |output|.
   // Returns the length of the buffer on success, or 0 otherwise.
   static QuicByteCount SerializeHeadersFrameHeader(
-      QuicByteCount payload_length,
-      std::unique_ptr<char[]>* output);
+      QuicByteCount payload_length, std::unique_ptr<char[]>* output);
 
   // Serializes a SETTINGS frame into a new buffer stored in |output|.
   // Returns the length of the buffer on success, or 0 otherwise.
@@ -65,8 +64,7 @@
   // Serializes a WEBTRANSPORT_STREAM frame header as specified in
   // https://www.ietf.org/archive/id/draft-ietf-webtrans-http3-00.html#name-client-initiated-bidirectio
   static QuicByteCount SerializeWebTransportStreamFrameHeader(
-      WebTransportSessionId session_id,
-      std::unique_ptr<char[]>* output);
+      WebTransportSessionId session_id, std::unique_ptr<char[]>* output);
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/http/http_frames.h b/quiche/quic/core/http/http_frames.h
index c452a7d..eae52ee 100644
--- a/quiche/quic/core/http/http_frames.h
+++ b/quiche/quic/core/http/http_frames.h
@@ -147,8 +147,7 @@
   }
 
   friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
-      std::ostream& os,
-      const PriorityUpdateFrame& s) {
+      std::ostream& os, const PriorityUpdateFrame& s) {
     os << s.ToString();
     return os;
   }
@@ -172,8 +171,7 @@
   }
 
   friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
-      std::ostream& os,
-      const AcceptChFrame& frame) {
+      std::ostream& os, const AcceptChFrame& frame) {
     os << "ACCEPT_CH frame with " << frame.entries.size() << " entries: ";
     for (auto& entry : frame.entries) {
       os << "origin: " << entry.origin << "; value: " << entry.value;
diff --git a/quiche/quic/core/http/quic_client_promised_info.cc b/quiche/quic/core/http/quic_client_promised_info.cc
index 18bb5dd..2567fde 100644
--- a/quiche/quic/core/http/quic_client_promised_info.cc
+++ b/quiche/quic/core/http/quic_client_promised_info.cc
@@ -16,9 +16,7 @@
 namespace quic {
 
 QuicClientPromisedInfo::QuicClientPromisedInfo(
-    QuicSpdyClientSessionBase* session,
-    QuicStreamId id,
-    std::string url)
+    QuicSpdyClientSessionBase* session, QuicStreamId id, std::string url)
     : session_(session),
       id_(id),
       url_(std::move(url)),
diff --git a/quiche/quic/core/http/quic_client_promised_info.h b/quiche/quic/core/http/quic_client_promised_info.h
index 77d32af..68eaecd 100644
--- a/quiche/quic/core/http/quic_client_promised_info.h
+++ b/quiche/quic/core/http/quic_client_promised_info.h
@@ -30,8 +30,7 @@
     : public QuicClientPushPromiseIndex::TryHandle {
  public:
   // Interface to QuicSpdyClientStream
-  QuicClientPromisedInfo(QuicSpdyClientSessionBase* session,
-                         QuicStreamId id,
+  QuicClientPromisedInfo(QuicSpdyClientSessionBase* session, QuicStreamId id,
                          std::string url);
   QuicClientPromisedInfo(const QuicClientPromisedInfo&) = delete;
   QuicClientPromisedInfo& operator=(const QuicClientPromisedInfo&) = delete;
diff --git a/quiche/quic/core/http/quic_client_promised_info_test.cc b/quiche/quic/core/http/quic_client_promised_info_test.cc
index 287e961..7636579 100644
--- a/quiche/quic/core/http/quic_client_promised_info_test.cc
+++ b/quiche/quic/core/http/quic_client_promised_info_test.cc
@@ -34,12 +34,10 @@
       const ParsedQuicVersionVector& supported_versions,
       QuicConnection* connection,
       QuicClientPushPromiseIndex* push_promise_index)
-      : QuicSpdyClientSession(DefaultQuicConfig(),
-                              supported_versions,
+      : QuicSpdyClientSession(DefaultQuicConfig(), supported_versions,
                               connection,
                               QuicServerId("example.com", 443, false),
-                              &crypto_config_,
-                              push_promise_index),
+                              &crypto_config_, push_promise_index),
         crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
         authorized_(true) {}
   MockQuicSpdyClientSession(const MockQuicSpdyClientSession&) = delete;
@@ -53,10 +51,8 @@
 
   void set_authorized(bool authorized) { authorized_ = authorized; }
 
-  MOCK_METHOD(bool,
-              WriteControlFrame,
-              (const QuicFrame& frame, TransmissionType type),
-              (override));
+  MOCK_METHOD(bool, WriteControlFrame,
+              (const QuicFrame& frame, TransmissionType type), (override));
 
  private:
   QuicCryptoClientConfig crypto_config_;
@@ -69,11 +65,9 @@
   class StreamVisitor;
 
   QuicClientPromisedInfoTest()
-      : connection_(new StrictMock<MockQuicConnection>(&helper_,
-                                                       &alarm_factory_,
-                                                       Perspective::IS_CLIENT)),
-        session_(connection_->supported_versions(),
-                 connection_,
+      : connection_(new StrictMock<MockQuicConnection>(
+            &helper_, &alarm_factory_, Perspective::IS_CLIENT)),
+        session_(connection_->supported_versions(), connection_,
                  &push_promise_index_),
         body_("hello world"),
         promise_id_(
diff --git a/quiche/quic/core/http/quic_client_push_promise_index.cc b/quiche/quic/core/http/quic_client_push_promise_index.cc
index d1e0cf4..60a51c1 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index.cc
+++ b/quiche/quic/core/http/quic_client_push_promise_index.cc
@@ -30,8 +30,7 @@
 
 QuicAsyncStatus QuicClientPushPromiseIndex::Try(
     const spdy::SpdyHeaderBlock& request,
-    QuicClientPushPromiseIndex::Delegate* delegate,
-    TryHandle** handle) {
+    QuicClientPushPromiseIndex::Delegate* delegate, TryHandle** handle) {
   std::string url(SpdyServerPushUtils::GetPromisedUrlFromHeaders(request));
   auto it = promised_by_url_.find(url);
   if (it != promised_by_url_.end()) {
diff --git a/quiche/quic/core/http/quic_client_push_promise_index.h b/quiche/quic/core/http/quic_client_push_promise_index.h
index 66570b9..ba786d8 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index.h
+++ b/quiche/quic/core/http/quic_client_push_promise_index.h
@@ -84,8 +84,7 @@
   // cancel the request if need be.  The caller does not inherit
   // ownership of |*handle|, and it ceases to be valid if the caller
   // invokes |handle->Cancel()| or if |delegate->OnReponse()| fires.
-  QuicAsyncStatus Try(const spdy::SpdyHeaderBlock& request,
-                      Delegate* delegate,
+  QuicAsyncStatus Try(const spdy::SpdyHeaderBlock& request, Delegate* delegate,
                       TryHandle** handle);
 
   QuicPromisedByUrlMap* promised_by_url() { return &promised_by_url_; }
diff --git a/quiche/quic/core/http/quic_client_push_promise_index_test.cc b/quiche/quic/core/http/quic_client_push_promise_index_test.cc
index 6f7c3ac..d491710 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index_test.cc
+++ b/quiche/quic/core/http/quic_client_push_promise_index_test.cc
@@ -28,12 +28,10 @@
       const ParsedQuicVersionVector& supported_versions,
       QuicConnection* connection,
       QuicClientPushPromiseIndex* push_promise_index)
-      : QuicSpdyClientSession(DefaultQuicConfig(),
-                              supported_versions,
+      : QuicSpdyClientSession(DefaultQuicConfig(), supported_versions,
                               connection,
                               QuicServerId("example.com", 443, false),
-                              &crypto_config_,
-                              push_promise_index),
+                              &crypto_config_, push_promise_index),
         crypto_config_(crypto_test_utils::ProofVerifierForTesting()) {}
   MockQuicSpdyClientSession(const MockQuicSpdyClientSession&) = delete;
   MockQuicSpdyClientSession& operator=(const MockQuicSpdyClientSession&) =
@@ -47,14 +45,12 @@
 class QuicClientPushPromiseIndexTest : public QuicTest {
  public:
   QuicClientPushPromiseIndexTest()
-      : connection_(new StrictMock<MockQuicConnection>(&helper_,
-                                                       &alarm_factory_,
-                                                       Perspective::IS_CLIENT)),
+      : connection_(new StrictMock<MockQuicConnection>(
+            &helper_, &alarm_factory_, Perspective::IS_CLIENT)),
         session_(connection_->supported_versions(), connection_, &index_),
         promised_(&session_,
                   GetNthServerInitiatedUnidirectionalStreamId(
-                      connection_->transport_version(),
-                      0),
+                      connection_->transport_version(), 0),
                   url_) {
     request_[":path"] = "/bar";
     request_[":authority"] = "www.google.com";
diff --git a/quiche/quic/core/http/quic_headers_stream.cc b/quiche/quic/core/http/quic_headers_stream.cc
index 81ebaef..9a53e66 100644
--- a/quiche/quic/core/http/quic_headers_stream.cc
+++ b/quiche/quic/core/http/quic_headers_stream.cc
@@ -29,8 +29,7 @@
 QuicHeadersStream::QuicHeadersStream(QuicSpdySession* session)
     : QuicStream(QuicUtils::GetHeadersStreamId(session->transport_version()),
                  session,
-                 /*is_static=*/true,
-                 BIDIRECTIONAL),
+                 /*is_static=*/true, BIDIRECTIONAL),
       spdy_session_(session) {
   // The headers stream is exempt from connection level flow control.
   DisableConnectionFlowControlForThisStream();
diff --git a/quiche/quic/core/http/quic_headers_stream.h b/quiche/quic/core/http/quic_headers_stream.h
index a5dbe38..1fae938 100644
--- a/quiche/quic/core/http/quic_headers_stream.h
+++ b/quiche/quic/core/http/quic_headers_stream.h
@@ -39,10 +39,8 @@
   // Release underlying buffer if allowed.
   void MaybeReleaseSequencerBuffer();
 
-  bool OnStreamFrameAcked(QuicStreamOffset offset,
-                          QuicByteCount data_length,
-                          bool fin_acked,
-                          QuicTime::Delta ack_delay_time,
+  bool OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length,
+                          bool fin_acked, QuicTime::Delta ack_delay_time,
                           QuicTime receive_timestamp,
                           QuicByteCount* newly_acked_length) override;
 
diff --git a/quiche/quic/core/http/quic_headers_stream_test.cc b/quiche/quic/core/http/quic_headers_stream_test.cc
index 30d9147..d72eded 100644
--- a/quiche/quic/core/http/quic_headers_stream_test.cc
+++ b/quiche/quic/core/http/quic_headers_stream_test.cc
@@ -76,89 +76,58 @@
 
 class MockVisitor : public SpdyFramerVisitorInterface {
  public:
-  MOCK_METHOD(void,
-              OnError,
+  MOCK_METHOD(void, OnError,
               (http2::Http2DecoderAdapter::SpdyFramerError error,
                std::string detailed_error),
               (override));
-  MOCK_METHOD(void,
-              OnDataFrameHeader,
-              (SpdyStreamId stream_id, size_t length, bool fin),
-              (override));
-  MOCK_METHOD(void,
-              OnStreamFrameData,
-              (SpdyStreamId stream_id, const char*, size_t len),
-              (override));
+  MOCK_METHOD(void, OnDataFrameHeader,
+              (SpdyStreamId stream_id, size_t length, bool fin), (override));
+  MOCK_METHOD(void, OnStreamFrameData,
+              (SpdyStreamId stream_id, const char*, size_t len), (override));
   MOCK_METHOD(void, OnStreamEnd, (SpdyStreamId stream_id), (override));
-  MOCK_METHOD(void,
-              OnStreamPadding,
-              (SpdyStreamId stream_id, size_t len),
+  MOCK_METHOD(void, OnStreamPadding, (SpdyStreamId stream_id, size_t len),
               (override));
-  MOCK_METHOD(SpdyHeadersHandlerInterface*,
-              OnHeaderFrameStart,
-              (SpdyStreamId stream_id),
-              (override));
+  MOCK_METHOD(SpdyHeadersHandlerInterface*, OnHeaderFrameStart,
+              (SpdyStreamId stream_id), (override));
   MOCK_METHOD(void, OnHeaderFrameEnd, (SpdyStreamId stream_id), (override));
-  MOCK_METHOD(void,
-              OnRstStream,
-              (SpdyStreamId stream_id, SpdyErrorCode error_code),
-              (override));
+  MOCK_METHOD(void, OnRstStream,
+              (SpdyStreamId stream_id, SpdyErrorCode error_code), (override));
   MOCK_METHOD(void, OnSettings, (), (override));
   MOCK_METHOD(void, OnSetting, (SpdySettingsId id, uint32_t value), (override));
   MOCK_METHOD(void, OnSettingsAck, (), (override));
   MOCK_METHOD(void, OnSettingsEnd, (), (override));
   MOCK_METHOD(void, OnPing, (SpdyPingId unique_id, bool is_ack), (override));
-  MOCK_METHOD(void,
-              OnGoAway,
+  MOCK_METHOD(void, OnGoAway,
               (SpdyStreamId last_accepted_stream_id, SpdyErrorCode error_code),
               (override));
-  MOCK_METHOD(void,
-              OnHeaders,
-              (SpdyStreamId stream_id,
-               bool has_priority,
-               int weight,
-               SpdyStreamId parent_stream_id,
-               bool exclusive,
-               bool fin,
+  MOCK_METHOD(void, OnHeaders,
+              (SpdyStreamId stream_id, bool has_priority, int weight,
+               SpdyStreamId parent_stream_id, bool exclusive, bool fin,
                bool end),
               (override));
-  MOCK_METHOD(void,
-              OnWindowUpdate,
-              (SpdyStreamId stream_id, int delta_window_size),
-              (override));
-  MOCK_METHOD(void,
-              OnPushPromise,
-              (SpdyStreamId stream_id,
-               SpdyStreamId promised_stream_id,
+  MOCK_METHOD(void, OnWindowUpdate,
+              (SpdyStreamId stream_id, int delta_window_size), (override));
+  MOCK_METHOD(void, OnPushPromise,
+              (SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                bool end),
               (override));
-  MOCK_METHOD(void,
-              OnContinuation,
-              (SpdyStreamId stream_id, bool end),
+  MOCK_METHOD(void, OnContinuation, (SpdyStreamId stream_id, bool end),
               (override));
   MOCK_METHOD(
-      void,
-      OnAltSvc,
-      (SpdyStreamId stream_id,
-       absl::string_view origin,
+      void, OnAltSvc,
+      (SpdyStreamId stream_id, absl::string_view origin,
        const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector),
       (override));
-  MOCK_METHOD(void,
-              OnPriority,
-              (SpdyStreamId stream_id,
-               SpdyStreamId parent_stream_id,
-               int weight,
-               bool exclusive),
+  MOCK_METHOD(void, OnPriority,
+              (SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+               int weight, bool exclusive),
               (override));
-  MOCK_METHOD(void,
-              OnPriorityUpdate,
+  MOCK_METHOD(void, OnPriorityUpdate,
               (SpdyStreamId prioritized_stream_id,
                absl::string_view priority_field_value),
               (override));
-  MOCK_METHOD(bool,
-              OnUnknownFrame,
-              (SpdyStreamId stream_id, uint8_t frame_type),
-              (override));
+  MOCK_METHOD(bool, OnUnknownFrame,
+              (SpdyStreamId stream_id, uint8_t frame_type), (override));
 };
 
 struct TestParams {
@@ -206,17 +175,14 @@
 class QuicHeadersStreamTest : public QuicTestWithParam<TestParams> {
  public:
   QuicHeadersStreamTest()
-      : connection_(new StrictMock<MockQuicConnection>(&helper_,
-                                                       &alarm_factory_,
-                                                       perspective(),
-                                                       GetVersion())),
+      : connection_(new StrictMock<MockQuicConnection>(
+            &helper_, &alarm_factory_, perspective(), GetVersion())),
         session_(connection_),
         body_("hello world"),
         stream_frame_(
             QuicUtils::GetHeadersStreamId(connection_->transport_version()),
             /*fin=*/false,
-            /*offset=*/0,
-            ""),
+            /*offset=*/0, ""),
         next_promised_stream_id_(2) {
     QuicSpdySessionPeer::SetMaxInboundHeaderListSize(&session_, 256 * 1024);
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
@@ -274,15 +240,12 @@
   }
 
   void SavePromiseHeaderList(QuicStreamId /* stream_id */,
-                             QuicStreamId /* promised_stream_id */,
-                             size_t size,
+                             QuicStreamId /* promised_stream_id */, size_t size,
                              const QuicHeaderList& header_list) {
     SaveToHandler(size, header_list);
   }
 
-  void SaveHeaderList(QuicStreamId /* stream_id */,
-                      bool /* fin */,
-                      size_t size,
+  void SaveHeaderList(QuicStreamId /* stream_id */, bool /* fin */, size_t size,
                       const QuicHeaderList& header_list) {
     SaveToHandler(size, header_list);
   }
@@ -296,8 +259,7 @@
     headers_handler_->OnHeaderBlockEnd(size, size);
   }
 
-  void WriteAndExpectRequestHeaders(QuicStreamId stream_id,
-                                    bool fin,
+  void WriteAndExpectRequestHeaders(QuicStreamId stream_id, bool fin,
                                     SpdyPriority priority) {
     WriteHeadersAndCheckData(stream_id, fin, priority, true /*is_request*/);
   }
@@ -306,10 +268,8 @@
     WriteHeadersAndCheckData(stream_id, fin, 0, false /*is_request*/);
   }
 
-  void WriteHeadersAndCheckData(QuicStreamId stream_id,
-                                bool fin,
-                                SpdyPriority priority,
-                                bool is_request) {
+  void WriteHeadersAndCheckData(QuicStreamId stream_id, bool fin,
+                                SpdyPriority priority, bool is_request) {
     // Write the headers and capture the outgoing data
     EXPECT_CALL(session_, WritevData(QuicUtils::GetHeadersStreamId(
                                          connection_->transport_version()),
@@ -401,8 +361,7 @@
 };
 
 // Run all tests with each version and perspective (client or server).
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicHeadersStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicHeadersStreamTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/core/http/quic_receive_control_stream.cc b/quiche/quic/core/http/quic_receive_control_stream.cc
index 5c624b2..853909a 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.cc
+++ b/quiche/quic/core/http/quic_receive_control_stream.cc
@@ -20,10 +20,8 @@
 namespace quic {
 
 QuicReceiveControlStream::QuicReceiveControlStream(
-    PendingStream* pending,
-    QuicSpdySession* spdy_session)
-    : QuicStream(pending,
-                 spdy_session,
+    PendingStream* pending, QuicSpdySession* spdy_session)
+    : QuicStream(pending, spdy_session,
                  /*is_static=*/true),
       settings_frame_received_(false),
       decoder_(this),
@@ -123,8 +121,7 @@
 }
 
 bool QuicReceiveControlStream::OnHeadersFrameStart(
-    QuicByteCount /*header_length*/,
-    QuicByteCount
+    QuicByteCount /*header_length*/, QuicByteCount
     /*payload_length*/) {
   return ValidateFrameType(HttpFrameType::HEADERS);
 }
@@ -205,15 +202,13 @@
 }
 
 void QuicReceiveControlStream::OnWebTransportStreamFrameType(
-    QuicByteCount /*header_length*/,
-    WebTransportSessionId /*session_id*/) {
+    QuicByteCount /*header_length*/, WebTransportSessionId /*session_id*/) {
   QUIC_BUG(WEBTRANSPORT_STREAM on Control Stream)
       << "Parsed WEBTRANSPORT_STREAM on a control stream.";
 }
 
 bool QuicReceiveControlStream::OnUnknownFrameStart(
-    uint64_t frame_type,
-    QuicByteCount /*header_length*/,
+    uint64_t frame_type, QuicByteCount /*header_length*/,
     QuicByteCount payload_length) {
   if (spdy_session()->debug_visitor()) {
     spdy_session()->debug_visitor()->OnUnknownFrameReceived(id(), frame_type,
diff --git a/quiche/quic/core/http/quic_receive_control_stream.h b/quiche/quic/core/http/quic_receive_control_stream.h
index 70fa63a..0cf34fa 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.h
+++ b/quiche/quic/core/http/quic_receive_control_stream.h
@@ -53,8 +53,7 @@
   bool OnAcceptChFrame(const AcceptChFrame& frame) override;
   void OnWebTransportStreamFrameType(QuicByteCount header_length,
                                      WebTransportSessionId session_id) override;
-  bool OnUnknownFrameStart(uint64_t frame_type,
-                           QuicByteCount header_length,
+  bool OnUnknownFrameStart(uint64_t frame_type, QuicByteCount header_length,
                            QuicByteCount payload_length) override;
   bool OnUnknownFramePayload(absl::string_view payload) override;
   bool OnUnknownFrameEnd() override;
diff --git a/quiche/quic/core/http/quic_receive_control_stream_test.cc b/quiche/quic/core/http/quic_receive_control_stream_test.cc
index 4ef68c4..c2dcfa7 100644
--- a/quiche/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quiche/quic/core/http/quic_receive_control_stream_test.cc
@@ -83,9 +83,7 @@
  public:
   QuicReceiveControlStreamTest()
       : connection_(new StrictMock<MockQuicConnection>(
-            &helper_,
-            &alarm_factory_,
-            perspective(),
+            &helper_, &alarm_factory_, perspective(),
             SupportedVersions(GetParam().version))),
         session_(connection_) {
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
@@ -140,8 +138,7 @@
   TestStream* stream_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicReceiveControlStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicReceiveControlStreamTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/core/http/quic_send_control_stream.cc b/quiche/quic/core/http/quic_send_control_stream.cc
index f021f3d..44f658f 100644
--- a/quiche/quic/core/http/quic_send_control_stream.cc
+++ b/quiche/quic/core/http/quic_send_control_stream.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/core/http/quic_send_control_stream.h"
+
 #include <cstdint>
 #include <memory>
 
diff --git a/quiche/quic/core/http/quic_send_control_stream.h b/quiche/quic/core/http/quic_send_control_stream.h
index 49076bb..c606ff5 100644
--- a/quiche/quic/core/http/quic_send_control_stream.h
+++ b/quiche/quic/core/http/quic_send_control_stream.h
@@ -21,8 +21,7 @@
  public:
   // |session| can't be nullptr, and the ownership is not passed. The stream can
   // only be accessed through the session.
-  QuicSendControlStream(QuicStreamId id,
-                        QuicSpdySession* session,
+  QuicSendControlStream(QuicStreamId id, QuicSpdySession* session,
                         const SettingsFrame& settings);
   QuicSendControlStream(const QuicSendControlStream&) = delete;
   QuicSendControlStream& operator=(const QuicSendControlStream&) = delete;
diff --git a/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc b/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc
index da63760..f3b16ef 100644
--- a/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/core/http/quic_server_initiated_spdy_stream.h"
+
 #include "quiche/quic/core/quic_error_codes.h"
 
 namespace quic {
@@ -28,9 +29,7 @@
 }
 
 void QuicServerInitiatedSpdyStream::OnInitialHeadersComplete(
-    bool /*fin*/,
-    size_t /*frame_len*/,
-    const QuicHeaderList& /*header_list*/) {
+    bool /*fin*/, size_t /*frame_len*/, const QuicHeaderList& /*header_list*/) {
   QUIC_PEER_BUG(Reading headers in QuicServerInitiatedSpdyStream)
       << "Attempting to receive headers in QuicServerInitiatedSpdyStream";
 
diff --git a/quiche/quic/core/http/quic_server_initiated_spdy_stream.h b/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
index d60296c..a93cb40 100644
--- a/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
+++ b/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
@@ -22,8 +22,7 @@
       spdy::SpdyHeaderBlock header_block, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener) override;
-  void OnInitialHeadersComplete(bool fin,
-                                size_t frame_len,
+  void OnInitialHeadersComplete(bool fin, size_t frame_len,
                                 const QuicHeaderList& header_list) override;
 };
 
diff --git a/quiche/quic/core/http/quic_server_session_base.cc b/quiche/quic/core/http/quic_server_session_base.cc
index b636e4c..7ad1e3a 100644
--- a/quiche/quic/core/http/quic_server_session_base.cc
+++ b/quiche/quic/core/http/quic_server_session_base.cc
@@ -20,10 +20,8 @@
 namespace quic {
 
 QuicServerSessionBase::QuicServerSessionBase(
-    const QuicConfig& config,
-    const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection,
-    Visitor* visitor,
+    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
+    QuicConnection* connection, Visitor* visitor,
     QuicCryptoServerStreamBase::Helper* helper,
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache)
@@ -121,8 +119,7 @@
 }
 
 void QuicServerSessionBase::OnConnectionClosed(
-    const QuicConnectionCloseFrame& frame,
-    ConnectionCloseSource source) {
+    const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) {
   QuicSession::OnConnectionClosed(frame, source);
   // In the unlikely event we get a connection close while doing an asynchronous
   // crypto event, make sure we cancel the callback.
diff --git a/quiche/quic/core/http/quic_server_session_base_test.cc b/quiche/quic/core/http/quic_server_session_base_test.cc
index 9b8dbcf..56aa06a 100644
--- a/quiche/quic/core/http/quic_server_session_base_test.cc
+++ b/quiche/quic/core/http/quic_server_session_base_test.cc
@@ -58,28 +58,21 @@
 
 class TestServerSession : public QuicServerSessionBase {
  public:
-  TestServerSession(const QuicConfig& config,
-                    QuicConnection* connection,
+  TestServerSession(const QuicConfig& config, QuicConnection* connection,
                     QuicSession::Visitor* visitor,
                     QuicCryptoServerStreamBase::Helper* helper,
                     const QuicCryptoServerConfig* crypto_config,
                     QuicCompressedCertsCache* compressed_certs_cache,
                     QuicSimpleServerBackend* quic_simple_server_backend)
-      : QuicServerSessionBase(config,
-                              CurrentSupportedVersions(),
-                              connection,
-                              visitor,
-                              helper,
-                              crypto_config,
+      : QuicServerSessionBase(config, CurrentSupportedVersions(), connection,
+                              visitor, helper, crypto_config,
                               compressed_certs_cache),
         quic_simple_server_backend_(quic_simple_server_backend) {}
 
   ~TestServerSession() override { DeleteConnection(); }
 
-  MOCK_METHOD(bool,
-              WriteControlFrame,
-              (const QuicFrame& frame, TransmissionType type),
-              (override));
+  MOCK_METHOD(bool, WriteControlFrame,
+              (const QuicFrame& frame, TransmissionType type), (override));
 
  protected:
   QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override {
@@ -137,8 +130,7 @@
 
   explicit QuicServerSessionBaseTest(std::unique_ptr<ProofSource> proof_source)
       : crypto_config_(QuicCryptoServerConfig::TESTING,
-                       QuicRandom::GetInstance(),
-                       std::move(proof_source),
+                       QuicRandom::GetInstance(), std::move(proof_source),
                        KeyExchangeSource::Default()),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
@@ -242,8 +234,7 @@
               reference.previous_connection_state());
 }
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicServerSessionBaseTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicServerSessionBaseTest,
                          ::testing::ValuesIn(AllSupportedVersions()),
                          ::testing::PrintToStringParamName());
 
@@ -478,18 +469,14 @@
       QuicCompressedCertsCache* compressed_certs_cache,
       QuicServerSessionBase* session,
       QuicCryptoServerStreamBase::Helper* helper)
-      : QuicCryptoServerStream(crypto_config,
-                               compressed_certs_cache,
-                               session,
+      : QuicCryptoServerStream(crypto_config, compressed_certs_cache, session,
                                helper) {}
   MockQuicCryptoServerStream(const MockQuicCryptoServerStream&) = delete;
   MockQuicCryptoServerStream& operator=(const MockQuicCryptoServerStream&) =
       delete;
   ~MockQuicCryptoServerStream() override {}
 
-  MOCK_METHOD(void,
-              SendServerConfigUpdate,
-              (const CachedNetworkParameters*),
+  MOCK_METHOD(void, SendServerConfigUpdate, (const CachedNetworkParameters*),
               (override));
 };
 
@@ -751,8 +738,7 @@
   QuicCryptoServerConfigPeer crypto_config_peer_;
 };
 
-INSTANTIATE_TEST_SUITE_P(StreamMemberLifetimeTests,
-                         StreamMemberLifetimeTest,
+INSTANTIATE_TEST_SUITE_P(StreamMemberLifetimeTests, StreamMemberLifetimeTest,
                          ::testing::ValuesIn(AllSupportedVersions()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/core/http/quic_spdy_client_session.cc b/quiche/quic/core/http/quic_spdy_client_session.cc
index ed02803..171e0c4 100644
--- a/quiche/quic/core/http/quic_spdy_client_session.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session.cc
@@ -22,15 +22,11 @@
 namespace quic {
 
 QuicSpdyClientSession::QuicSpdyClientSession(
-    const QuicConfig& config,
-    const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection,
-    const QuicServerId& server_id,
+    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
+    QuicConnection* connection, const QuicServerId& server_id,
     QuicCryptoClientConfig* crypto_config,
     QuicClientPushPromiseIndex* push_promise_index)
-    : QuicSpdyClientSessionBase(connection,
-                                push_promise_index,
-                                config,
+    : QuicSpdyClientSessionBase(connection, push_promise_index, config,
                                 supported_versions),
       server_id_(server_id),
       crypto_config_(crypto_config),
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.cc b/quiche/quic/core/http/quic_spdy_client_session_base.cc
index 559764c..5a5c72b 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.cc
@@ -17,10 +17,8 @@
 namespace quic {
 
 QuicSpdyClientSessionBase::QuicSpdyClientSessionBase(
-    QuicConnection* connection,
-    QuicClientPushPromiseIndex* push_promise_index,
-    const QuicConfig& config,
-    const ParsedQuicVersionVector& supported_versions)
+    QuicConnection* connection, QuicClientPushPromiseIndex* push_promise_index,
+    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions)
     : QuicSpdySession(connection, nullptr, config, supported_versions),
       push_promise_index_(push_promise_index),
       largest_promised_stream_id_(
@@ -40,24 +38,20 @@
 }
 
 void QuicSpdyClientSessionBase::OnInitialHeadersComplete(
-    QuicStreamId stream_id,
-    const SpdyHeaderBlock& response_headers) {
+    QuicStreamId stream_id, const SpdyHeaderBlock& response_headers) {
   // Note that the strong ordering of the headers stream means that
   // QuicSpdyClientStream::OnPromiseHeadersComplete must have already
   // been called (on the associated stream) if this is a promised
   // stream. However, this stream may not have existed at this time,
   // hence the need to query the session.
   QuicClientPromisedInfo* promised = GetPromisedById(stream_id);
-  if (!promised)
-    return;
+  if (!promised) return;
 
   promised->OnResponseHeaders(response_headers);
 }
 
 void QuicSpdyClientSessionBase::OnPromiseHeaderList(
-    QuicStreamId stream_id,
-    QuicStreamId promised_stream_id,
-    size_t frame_len,
+    QuicStreamId stream_id, QuicStreamId promised_stream_id, size_t frame_len,
     const QuicHeaderList& header_list) {
   if (IsStaticStream(stream_id)) {
     connection()->CloseConnection(
@@ -205,8 +199,7 @@
     QuicStreamId /*stream_id*/) {}
 
 void QuicSpdyClientSessionBase::ResetPromised(
-    QuicStreamId id,
-    QuicRstStreamErrorCode error_code) {
+    QuicStreamId id, QuicRstStreamErrorCode error_code) {
   QUICHE_DCHECK(QuicUtils::IsServerInitiatedStreamId(transport_version(), id));
   ResetStream(id, error_code);
   if (!IsOpenStream(id) && !IsClosedStream(id)) {
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.h b/quiche/quic/core/http/quic_spdy_client_session_base.h
index 426d28d..f75874e 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.h
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.h
@@ -54,8 +54,7 @@
   // Called by |headers_stream_| when push promise headers have been
   // completely received.
   void OnPromiseHeaderList(QuicStreamId stream_id,
-                           QuicStreamId promised_stream_id,
-                           size_t frame_len,
+                           QuicStreamId promised_stream_id, size_t frame_len,
                            const QuicHeaderList& header_list) override;
 
   // Called by |QuicSpdyClientStream| on receipt of response headers,
diff --git a/quiche/quic/core/http/quic_spdy_client_session_test.cc b/quiche/quic/core/http/quic_spdy_client_session_test.cc
index 346341c..6ebacc5 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_test.cc
@@ -61,16 +61,11 @@
   explicit TestQuicSpdyClientSession(
       const QuicConfig& config,
       const ParsedQuicVersionVector& supported_versions,
-      QuicConnection* connection,
-      const QuicServerId& server_id,
+      QuicConnection* connection, const QuicServerId& server_id,
       QuicCryptoClientConfig* crypto_config,
       QuicClientPushPromiseIndex* push_promise_index)
-      : QuicSpdyClientSession(config,
-                              supported_versions,
-                              connection,
-                              server_id,
-                              crypto_config,
-                              push_promise_index) {}
+      : QuicSpdyClientSession(config, supported_versions, connection, server_id,
+                              crypto_config, push_promise_index) {}
 
   std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override {
     return std::make_unique<MockQuicSpdyClientStream>(
@@ -232,14 +227,11 @@
   return ParsedQuicVersionToString(info.param);
 }
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicSpdyClientSessionTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicSpdyClientSessionTest,
                          ::testing::ValuesIn(AllSupportedVersions()),
                          ParamNameFormatter);
 
-TEST_P(QuicSpdyClientSessionTest, CryptoConnect) {
-  CompleteCryptoHandshake();
-}
+TEST_P(QuicSpdyClientSessionTest, CryptoConnect) { CompleteCryptoHandshake(); }
 
 TEST_P(QuicSpdyClientSessionTest, NoEncryptionAfterInitialEncryption) {
   if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.cc b/quiche/quic/core/http/quic_spdy_client_stream.cc
index e1677fb..044c616 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_client_stream.cc
@@ -44,9 +44,7 @@
 QuicSpdyClientStream::~QuicSpdyClientStream() = default;
 
 void QuicSpdyClientStream::OnInitialHeadersComplete(
-    bool fin,
-    size_t frame_len,
-    const QuicHeaderList& header_list) {
+    bool fin, size_t frame_len, const QuicHeaderList& header_list) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len, header_list);
 
   QUICHE_DCHECK(headers_decompressed());
@@ -118,16 +116,13 @@
 }
 
 void QuicSpdyClientStream::OnTrailingHeadersComplete(
-    bool fin,
-    size_t frame_len,
-    const QuicHeaderList& header_list) {
+    bool fin, size_t frame_len, const QuicHeaderList& header_list) {
   QuicSpdyStream::OnTrailingHeadersComplete(fin, frame_len, header_list);
   MarkTrailersConsumed();
 }
 
 void QuicSpdyClientStream::OnPromiseHeaderList(
-    QuicStreamId promised_id,
-    size_t frame_len,
+    QuicStreamId promised_id, size_t frame_len,
     const QuicHeaderList& header_list) {
   header_bytes_read_ += frame_len;
   int64_t content_length = -1;
@@ -149,8 +144,7 @@
 void QuicSpdyClientStream::OnBodyAvailable() {
   // For push streams, visitor will not be set until the rendezvous
   // between server promise and client request is complete.
-  if (visitor() == nullptr)
-    return;
+  if (visitor() == nullptr) return;
 
   while (HasBytesToRead()) {
     struct iovec iov;
@@ -179,8 +173,7 @@
 }
 
 size_t QuicSpdyClientStream::SendRequest(SpdyHeaderBlock headers,
-                                         absl::string_view body,
-                                         bool fin) {
+                                         absl::string_view body, bool fin) {
   QuicConnection::ScopedPacketFlusher flusher(session_->connection());
   bool send_fin_with_headers = fin && body.empty();
   size_t bytes_sent = body.size();
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.h b/quiche/quic/core/http/quic_spdy_client_stream.h
index ebda141..6311726 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.h
+++ b/quiche/quic/core/http/quic_spdy_client_stream.h
@@ -21,8 +21,7 @@
 // SPDY response.
 class QUIC_EXPORT_PRIVATE QuicSpdyClientStream : public QuicSpdyStream {
  public:
-  QuicSpdyClientStream(QuicStreamId id,
-                       QuicSpdyClientSession* session,
+  QuicSpdyClientStream(QuicStreamId id, QuicSpdyClientSession* session,
                        StreamType type);
   QuicSpdyClientStream(PendingStream* pending,
                        QuicSpdyClientSession* spdy_session);
@@ -31,18 +30,15 @@
   ~QuicSpdyClientStream() override;
 
   // Override the base class to parse and store headers.
-  void OnInitialHeadersComplete(bool fin,
-                                size_t frame_len,
+  void OnInitialHeadersComplete(bool fin, size_t frame_len,
                                 const QuicHeaderList& header_list) override;
 
   // Override the base class to parse and store trailers.
-  void OnTrailingHeadersComplete(bool fin,
-                                 size_t frame_len,
+  void OnTrailingHeadersComplete(bool fin, size_t frame_len,
                                  const QuicHeaderList& header_list) override;
 
   // Override the base class to handle creation of the push stream.
-  void OnPromiseHeaderList(QuicStreamId promised_id,
-                           size_t frame_len,
+  void OnPromiseHeaderList(QuicStreamId promised_id, size_t frame_len,
                            const QuicHeaderList& header_list) override;
 
   // QuicStream implementation called by the session when there's data for us.
@@ -50,8 +46,7 @@
 
   // Serializes the headers and body, sends it to the server, and
   // returns the number of bytes sent.
-  size_t SendRequest(spdy::SpdyHeaderBlock headers,
-                     absl::string_view body,
+  size_t SendRequest(spdy::SpdyHeaderBlock headers, absl::string_view body,
                      bool fin);
 
   // Returns the response data.
diff --git a/quiche/quic/core/http/quic_spdy_client_stream_test.cc b/quiche/quic/core/http/quic_spdy_client_stream_test.cc
index 0470f41..17901e0 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_stream_test.cc
@@ -36,22 +36,18 @@
       const ParsedQuicVersionVector& supported_versions,
       QuicConnection* connection,
       QuicClientPushPromiseIndex* push_promise_index)
-      : QuicSpdyClientSession(DefaultQuicConfig(),
-                              supported_versions,
+      : QuicSpdyClientSession(DefaultQuicConfig(), supported_versions,
                               connection,
                               QuicServerId("example.com", 443, false),
-                              &crypto_config_,
-                              push_promise_index),
+                              &crypto_config_, push_promise_index),
         crypto_config_(crypto_test_utils::ProofVerifierForTesting()) {}
   MockQuicSpdyClientSession(const MockQuicSpdyClientSession&) = delete;
   MockQuicSpdyClientSession& operator=(const MockQuicSpdyClientSession&) =
       delete;
   ~MockQuicSpdyClientSession() override = default;
 
-  MOCK_METHOD(bool,
-              WriteControlFrame,
-              (const QuicFrame& frame, TransmissionType type),
-              (override));
+  MOCK_METHOD(bool, WriteControlFrame,
+              (const QuicFrame& frame, TransmissionType type), (override));
 
   using QuicSession::ActivateStream;
 
@@ -64,13 +60,10 @@
   class StreamVisitor;
 
   QuicSpdyClientStreamTest()
-      : connection_(
-            new StrictMock<MockQuicConnection>(&helper_,
-                                               &alarm_factory_,
-                                               Perspective::IS_CLIENT,
-                                               SupportedVersions(GetParam()))),
-        session_(connection_->supported_versions(),
-                 connection_,
+      : connection_(new StrictMock<MockQuicConnection>(
+            &helper_, &alarm_factory_, Perspective::IS_CLIENT,
+            SupportedVersions(GetParam()))),
+        session_(connection_->supported_versions(), connection_,
                  &push_promise_index_),
         body_("hello world") {
     session_.Initialize();
@@ -110,8 +103,7 @@
   std::string body_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicSpdyClientStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QuicSpdyClientStreamTest,
                          ::testing::ValuesIn(AllSupportedVersions()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/core/http/quic_spdy_server_stream_base.h b/quiche/quic/core/http/quic_spdy_server_stream_base.h
index 22fb65d..dd3423b 100644
--- a/quiche/quic/core/http/quic_spdy_server_stream_base.h
+++ b/quiche/quic/core/http/quic_spdy_server_stream_base.h
@@ -11,8 +11,7 @@
 
 class QUIC_NO_EXPORT QuicSpdyServerStreamBase : public QuicSpdyStream {
  public:
-  QuicSpdyServerStreamBase(QuicStreamId id,
-                           QuicSpdySession* session,
+  QuicSpdyServerStreamBase(QuicStreamId id, QuicSpdySession* session,
                            StreamType type);
   QuicSpdyServerStreamBase(PendingStream* pending, QuicSpdySession* session);
   QuicSpdyServerStreamBase(const QuicSpdyServerStreamBase&) = delete;
diff --git a/quiche/quic/core/http/quic_spdy_session_test.cc b/quiche/quic/core/http/quic_spdy_session_test.cc
index 0a767c1..b5e895a 100644
--- a/quiche/quic/core/http/quic_spdy_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_session_test.cc
@@ -1355,8 +1355,8 @@
   QuicSocketAddress new_peer_address =
       QuicSocketAddress(QuicIpAddress::Loopback4(), kTestPort + 1);
 
-    EXPECT_CALL(*connection_,
-                SendConnectivityProbingPacket(nullptr, new_peer_address));
+  EXPECT_CALL(*connection_,
+              SendConnectivityProbingPacket(nullptr, new_peer_address));
 
   if (VersionHasIetfQuicFrames(transport_version())) {
     // Need to explicitly do this to emulate the reception of a PathChallenge,
diff --git a/quiche/quic/core/http/quic_spdy_stream_body_manager.h b/quiche/quic/core/http/quic_spdy_stream_body_manager.h
index fbd4420..34bf446 100644
--- a/quiche/quic/core/http/quic_spdy_stream_body_manager.h
+++ b/quiche/quic/core/http/quic_spdy_stream_body_manager.h
@@ -63,8 +63,7 @@
   // preassigned and will not be changed.  Returns the total number of bytes the
   // caller shall mark consumed.  Sets |*total_bytes_read| to the total number
   // of body bytes read.
-  ABSL_MUST_USE_RESULT size_t ReadBody(const struct iovec* iov,
-                                       size_t iov_len,
+  ABSL_MUST_USE_RESULT size_t ReadBody(const struct iovec* iov, size_t iov_len,
                                        size_t* total_bytes_read);
 
   bool HasBytesToRead() const { return !fragments_.empty(); }
diff --git a/quiche/quic/core/http/web_transport_stream_adapter.cc b/quiche/quic/core/http/web_transport_stream_adapter.cc
index ff19214..b6eca7b 100644
--- a/quiche/quic/core/http/web_transport_stream_adapter.cc
+++ b/quiche/quic/core/http/web_transport_stream_adapter.cc
@@ -11,14 +11,11 @@
 namespace quic {
 
 WebTransportStreamAdapter::WebTransportStreamAdapter(
-    QuicSession* session,
-    QuicStream* stream,
-    QuicStreamSequencer* sequencer)
+    QuicSession* session, QuicStream* stream, QuicStreamSequencer* sequencer)
     : session_(session), stream_(stream), sequencer_(sequencer) {}
 
 WebTransportStream::ReadResult WebTransportStreamAdapter::Read(
-    char* buffer,
-    size_t buffer_size) {
+    char* buffer, size_t buffer_size) {
   iovec iov;
   iov.iov_base = buffer;
   iov.iov_len = buffer_size;
diff --git a/quiche/quic/core/http/web_transport_stream_adapter.h b/quiche/quic/core/http/web_transport_stream_adapter.h
index 560b63f..7e8eeea 100644
--- a/quiche/quic/core/http/web_transport_stream_adapter.h
+++ b/quiche/quic/core/http/web_transport_stream_adapter.h
@@ -18,8 +18,7 @@
 class QUIC_EXPORT_PRIVATE WebTransportStreamAdapter
     : public WebTransportStream {
  public:
-  WebTransportStreamAdapter(QuicSession* session,
-                            QuicStream* stream,
+  WebTransportStreamAdapter(QuicSession* session, QuicStream* stream,
                             QuicStreamSequencer* sequencer);
 
   // WebTransportStream implementation.