diff --git a/quiche/common/quiche_circular_deque.h b/quiche/common/quiche_circular_deque.h
index f743b2d..bd319b1 100644
--- a/quiche/common/quiche_circular_deque.h
+++ b/quiche/common/quiche_circular_deque.h
@@ -37,8 +37,7 @@
 // inserted or erased in the middle.
 //
 // TODO(wub): Make memory grow/shrink strategies customizable.
-template <typename T,
-          size_t MinCapacityIncrement = 3,
+template <typename T, size_t MinCapacityIncrement = 3,
           typename Allocator = std::allocator<T>>
 class QUICHE_NO_EXPORT QuicheCircularDeque {
   using AllocatorTraits = std::allocator_traits<Allocator>;
@@ -214,8 +213,7 @@
   explicit QuicheCircularDeque(const allocator_type& alloc)
       : allocator_and_data_(alloc) {}
 
-  QuicheCircularDeque(size_type count,
-                      const T& value,
+  QuicheCircularDeque(size_type count, const T& value,
                       const Allocator& alloc = allocator_type())
       : allocator_and_data_(alloc) {
     resize(count, value);
@@ -232,8 +230,7 @@
       typename = std::enable_if_t<std::is_base_of<
           std::input_iterator_tag,
           typename std::iterator_traits<InputIt>::iterator_category>::value>>
-  QuicheCircularDeque(InputIt first,
-                      InputIt last,
+  QuicheCircularDeque(InputIt first, InputIt last,
                       const Allocator& alloc = allocator_type())
       : allocator_and_data_(alloc) {
     AssignRange(first, last);
@@ -241,9 +238,8 @@
 
   QuicheCircularDeque(const QuicheCircularDeque& other)
       : QuicheCircularDeque(
-            other,
-            AllocatorTraits::select_on_container_copy_construction(
-                other.allocator_and_data_.allocator())) {}
+            other, AllocatorTraits::select_on_container_copy_construction(
+                       other.allocator_and_data_.allocator())) {}
 
   QuicheCircularDeque(const QuicheCircularDeque& other,
                       const allocator_type& alloc)
@@ -499,8 +495,7 @@
   }
 
   friend QUICHE_NO_EXPORT std::ostream& operator<<(
-      std::ostream& os,
-      const QuicheCircularDeque& dq) {
+      std::ostream& os, const QuicheCircularDeque& dq) {
     os << "{";
     for (size_type pos = 0; pos != dq.size(); ++pos) {
       if (pos != 0) {
diff --git a/quiche/common/quiche_circular_deque_test.cc b/quiche/common/quiche_circular_deque_test.cc
index 6db7240..a239cd5 100644
--- a/quiche/common/quiche_circular_deque_test.cc
+++ b/quiche/common/quiche_circular_deque_test.cc
@@ -61,10 +61,8 @@
   std::shared_ptr<Counts> shared_counts_ = std::make_shared<Counts>();
 };
 
-template <typename T,
-          typename propagate_on_copy_assignment,
-          typename propagate_on_move_assignment,
-          typename propagate_on_swap,
+template <typename T, typename propagate_on_copy_assignment,
+          typename propagate_on_move_assignment, typename propagate_on_swap,
           bool equality_result,
           template <typename> class BaseAllocator = std::allocator>
 struct ConfigurableAllocator : public BaseAllocator<T> {
@@ -233,8 +231,8 @@
   dq3 = std::move(*&dq3);
   EXPECT_THAT(dq3, ElementsAre(3, 3, 3, 3, 3));
 
-  ASSERT_TRUE(decltype(
-      dq3.get_allocator())::propagate_on_container_move_assignment::value);
+  ASSERT_TRUE(decltype(dq3.get_allocator())::
+                  propagate_on_container_move_assignment::value);
   decltype(dq3) dq8;
   dq8 = std::move(*&dq3);
   EXPECT_THAT(dq8, ElementsAre(3, 3, 3, 3, 3));
diff --git a/quiche/common/quiche_data_reader.cc b/quiche/common/quiche_data_reader.cc
index 7724c6f..52b4af4 100644
--- a/quiche/common/quiche_data_reader.cc
+++ b/quiche/common/quiche_data_reader.cc
@@ -22,8 +22,7 @@
 QuicheDataReader::QuicheDataReader(const char* data, const size_t len)
     : QuicheDataReader(data, len, quiche::NETWORK_BYTE_ORDER) {}
 
-QuicheDataReader::QuicheDataReader(const char* data,
-                                   const size_t len,
+QuicheDataReader::QuicheDataReader(const char* data, const size_t len,
                                    quiche::Endianness endianness)
     : data_(data), len_(len), pos_(0), endianness_(endianness) {}
 
@@ -187,13 +186,9 @@
   return true;
 }
 
-bool QuicheDataReader::IsDoneReading() const {
-  return len_ == pos_;
-}
+bool QuicheDataReader::IsDoneReading() const { return len_ == pos_; }
 
-size_t QuicheDataReader::BytesRemaining() const {
-  return len_ - pos_;
-}
+size_t QuicheDataReader::BytesRemaining() const { return len_ - pos_; }
 
 bool QuicheDataReader::TruncateRemaining(size_t truncation_length) {
   if (truncation_length > BytesRemaining()) {
diff --git a/quiche/common/quiche_data_reader.h b/quiche/common/quiche_data_reader.h
index 67ca7b2..bf336f9 100644
--- a/quiche/common/quiche_data_reader.h
+++ b/quiche/common/quiche_data_reader.h
@@ -36,8 +36,7 @@
   QuicheDataReader(const char* data, const size_t len);
   // Constructs a reader using the specified endianness.
   // Caller must provide an underlying buffer to work on.
-  QuicheDataReader(const char* data,
-                   const size_t len,
+  QuicheDataReader(const char* data, const size_t len,
                    quiche::Endianness endianness);
   QuicheDataReader(const QuicheDataReader&) = delete;
   QuicheDataReader& operator=(const QuicheDataReader&) = delete;
diff --git a/quiche/common/quiche_data_writer.cc b/quiche/common/quiche_data_writer.cc
index d75ceae..5f83e1f 100644
--- a/quiche/common/quiche_data_writer.cc
+++ b/quiche/common/quiche_data_writer.cc
@@ -16,16 +16,13 @@
 QuicheDataWriter::QuicheDataWriter(size_t size, char* buffer)
     : QuicheDataWriter(size, buffer, quiche::NETWORK_BYTE_ORDER) {}
 
-QuicheDataWriter::QuicheDataWriter(size_t size,
-                                   char* buffer,
+QuicheDataWriter::QuicheDataWriter(size_t size, char* buffer,
                                    quiche::Endianness endianness)
     : buffer_(buffer), capacity_(size), length_(0), endianness_(endianness) {}
 
 QuicheDataWriter::~QuicheDataWriter() {}
 
-char* QuicheDataWriter::data() {
-  return buffer_;
-}
+char* QuicheDataWriter::data() { return buffer_; }
 
 bool QuicheDataWriter::WriteUInt8(uint8_t value) {
   return WriteBytes(&value, sizeof(value));
diff --git a/quiche/common/quiche_data_writer_test.cc b/quiche/common/quiche_data_writer_test.cc
index d58dafc..7ae15d2 100644
--- a/quiche/common/quiche_data_writer_test.cc
+++ b/quiche/common/quiche_data_writer_test.cc
@@ -19,9 +19,7 @@
 namespace test {
 namespace {
 
-char* AsChars(unsigned char* data) {
-  return reinterpret_cast<char*>(data);
-}
+char* AsChars(unsigned char* data) { return reinterpret_cast<char*>(data); }
 
 struct TestParams {
   explicit TestParams(quiche::Endianness endianness) : endianness(endianness) {}
@@ -47,8 +45,7 @@
 
 class QuicheDataWriterTest : public QuicheTestWithParam<TestParams> {};
 
-INSTANTIATE_TEST_SUITE_P(QuicheDataWriterTests,
-                         QuicheDataWriterTest,
+INSTANTIATE_TEST_SUITE_P(QuicheDataWriterTests, QuicheDataWriterTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/common/quiche_linked_hash_map_test.cc b/quiche/common/quiche_linked_hash_map_test.cc
index 4b2fb9b..0aa9c54 100644
--- a/quiche/common/quiche_linked_hash_map_test.cc
+++ b/quiche/common/quiche_linked_hash_map_test.cc
@@ -297,9 +297,7 @@
       << "Duplicate insertion should have given us the original iterator.";
 }
 
-static std::pair<int, int> Pair(int i, int j) {
-  return {i, j};
-}
+static std::pair<int, int> Pair(int i, int j) { return {i, j}; }
 
 // Test front accessors.
 TEST(LinkedHashMapTest, Front) {
diff --git a/quiche/common/quiche_text_utils.cc b/quiche/common/quiche_text_utils.cc
index e31e898..5b4ee8e 100644
--- a/quiche/common/quiche_text_utils.cc
+++ b/quiche/common/quiche_text_utils.cc
@@ -11,8 +11,7 @@
 namespace quiche {
 
 // static
-void QuicheTextUtils::Base64Encode(const uint8_t* data,
-                                   size_t data_len,
+void QuicheTextUtils::Base64Encode(const uint8_t* data, size_t data_len,
                                    std::string* output) {
   absl::Base64Escape(std::string(reinterpret_cast<const char*>(data), data_len),
                      output);
diff --git a/quiche/common/quiche_text_utils.h b/quiche/common/quiche_text_utils.h
index a7af5ef..2398559 100644
--- a/quiche/common/quiche_text_utils.h
+++ b/quiche/common/quiche_text_utils.h
@@ -45,8 +45,7 @@
   }
 
   // Base64 encodes with no padding |data_len| bytes of |data| into |output|.
-  static void Base64Encode(const uint8_t* data,
-                           size_t data_len,
+  static void Base64Encode(const uint8_t* data, size_t data_len,
                            std::string* output);
 
   // Decodes a base64-encoded |input|.  Returns nullopt when the input is
diff --git a/quiche/common/simple_buffer_allocator.cc b/quiche/common/simple_buffer_allocator.cc
index b2726ed..ff34984 100644
--- a/quiche/common/simple_buffer_allocator.cc
+++ b/quiche/common/simple_buffer_allocator.cc
@@ -6,16 +6,12 @@
 
 namespace quiche {
 
-char* SimpleBufferAllocator::New(size_t size) {
-  return new char[size];
-}
+char* SimpleBufferAllocator::New(size_t size) { return new char[size]; }
 
 char* SimpleBufferAllocator::New(size_t size, bool /* flag_enable */) {
   return New(size);
 }
 
-void SimpleBufferAllocator::Delete(char* buffer) {
-  delete[] buffer;
-}
+void SimpleBufferAllocator::Delete(char* buffer) { delete[] buffer; }
 
 }  // namespace quiche
diff --git a/quiche/quic/quic_transport/quic_transport_client_session.cc b/quiche/quic/quic_transport/quic_transport_client_session.cc
index e9d0da8..e96647a 100644
--- a/quiche/quic/quic_transport/quic_transport_client_session.cc
+++ b/quiche/quic/quic_transport/quic_transport_client_session.cc
@@ -27,19 +27,12 @@
 namespace quic {
 
 QuicTransportClientSession::QuicTransportClientSession(
-    QuicConnection* connection,
-    Visitor* owner,
-    const QuicConfig& config,
-    const ParsedQuicVersionVector& supported_versions,
-    const GURL& url,
-    QuicCryptoClientConfig* crypto_config,
-    url::Origin origin,
+    QuicConnection* connection, Visitor* owner, const QuicConfig& config,
+    const ParsedQuicVersionVector& supported_versions, const GURL& url,
+    QuicCryptoClientConfig* crypto_config, url::Origin origin,
     WebTransportVisitor* visitor,
     std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer)
-    : QuicSession(connection,
-                  owner,
-                  config,
-                  supported_versions,
+    : QuicSession(connection, owner, config, supported_versions,
                   /*num_expected_unidirectional_static_streams*/ 0,
                   std::move(datagram_observer)),
       url_(url),
diff --git a/quiche/quic/quic_transport/quic_transport_client_session.h b/quiche/quic/quic_transport/quic_transport_client_session.h
index 46bbb1a..e537ffb 100644
--- a/quiche/quic/quic_transport/quic_transport_client_session.h
+++ b/quiche/quic/quic_transport/quic_transport_client_session.h
@@ -40,13 +40,9 @@
       public QuicCryptoClientStream::ProofHandler {
  public:
   QuicTransportClientSession(
-      QuicConnection* connection,
-      Visitor* owner,
-      const QuicConfig& config,
-      const ParsedQuicVersionVector& supported_versions,
-      const GURL& url,
-      QuicCryptoClientConfig* crypto_config,
-      url::Origin origin,
+      QuicConnection* connection, Visitor* owner, const QuicConfig& config,
+      const ParsedQuicVersionVector& supported_versions, const GURL& url,
+      QuicCryptoClientConfig* crypto_config, url::Origin origin,
       WebTransportVisitor* visitor,
       std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer);
 
diff --git a/quiche/quic/quic_transport/quic_transport_client_session_test.cc b/quiche/quic/quic_transport/quic_transport_client_session_test.cc
index a26ebee..ac3977f 100644
--- a/quiche/quic/quic_transport/quic_transport_client_session_test.cc
+++ b/quiche/quic/quic_transport/quic_transport_client_session_test.cc
@@ -52,9 +52,7 @@
 class QuicTransportClientSessionTest : public QuicTest {
  protected:
   QuicTransportClientSessionTest()
-      : connection_(&helper_,
-                    &alarm_factory_,
-                    Perspective::IS_CLIENT,
+      : connection_(&helper_, &alarm_factory_, Perspective::IS_CLIENT,
                     GetVersions()),
         crypto_config_(crypto_test_utils::ProofVerifierForTesting()) {
     QuicEnableVersion(DefaultVersionForQuicTransport());
diff --git a/quiche/quic/quic_transport/quic_transport_integration_test.cc b/quiche/quic/quic_transport/quic_transport_integration_test.cc
index 2b27942..1826426 100644
--- a/quiche/quic/quic_transport/quic_transport_integration_test.cc
+++ b/quiche/quic/quic_transport/quic_transport_integration_test.cc
@@ -54,8 +54,7 @@
 
 class QuicTransportEndpointBase : public QuicEndpointBase {
  public:
-  QuicTransportEndpointBase(Simulator* simulator,
-                            const std::string& name,
+  QuicTransportEndpointBase(Simulator* simulator, const std::string& name,
                             const std::string& peer_name,
                             Perspective perspective)
       : QuicEndpointBase(simulator, name, peer_name) {
@@ -71,25 +70,16 @@
 
 class QuicTransportClientEndpoint : public QuicTransportEndpointBase {
  public:
-  QuicTransportClientEndpoint(Simulator* simulator,
-                              const std::string& name,
+  QuicTransportClientEndpoint(Simulator* simulator, const std::string& name,
                               const std::string& peer_name,
-                              const QuicConfig& config,
-                              url::Origin origin,
+                              const QuicConfig& config, url::Origin origin,
                               const std::string& path)
-      : QuicTransportEndpointBase(simulator,
-                                  name,
-                                  peer_name,
+      : QuicTransportEndpointBase(simulator, name, peer_name,
                                   Perspective::IS_CLIENT),
         crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
-        session_(connection_.get(),
-                 nullptr,
-                 config,
-                 GetVersions(),
+        session_(connection_.get(), nullptr, config, GetVersions(),
                  GURL("quic-transport://test.example.com:50000" + path),
-                 &crypto_config_,
-                 origin,
-                 &visitor_,
+                 &crypto_config_, origin, &visitor_,
                  /*datagram_observer=*/nullptr) {
     session_.Initialize();
   }
@@ -105,14 +95,11 @@
 
 class QuicTransportServerEndpoint : public QuicTransportEndpointBase {
  public:
-  QuicTransportServerEndpoint(Simulator* simulator,
-                              const std::string& name,
+  QuicTransportServerEndpoint(Simulator* simulator, const std::string& name,
                               const std::string& peer_name,
                               const QuicConfig& config,
                               std::vector<url::Origin> accepted_origins)
-      : QuicTransportEndpointBase(simulator,
-                                  name,
-                                  peer_name,
+      : QuicTransportEndpointBase(simulator, name, peer_name,
                                   Perspective::IS_SERVER),
         crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance(),
@@ -121,13 +108,8 @@
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
         session_(connection_.get(),
-                 /*owns_connection=*/false,
-                 nullptr,
-                 config,
-                 GetVersions(),
-                 &crypto_config_,
-                 &compressed_certs_cache_,
-                 accepted_origins) {
+                 /*owns_connection=*/false, nullptr, config, GetVersions(),
+                 &crypto_config_, &compressed_certs_cache_, accepted_origins) {
     session_.Initialize();
   }
 
diff --git a/quiche/quic/quic_transport/quic_transport_server_session.cc b/quiche/quic/quic_transport/quic_transport_server_session.cc
index 0f99541..cc0b4c2 100644
--- a/quiche/quic/quic_transport/quic_transport_server_session.cc
+++ b/quiche/quic/quic_transport/quic_transport_server_session.cc
@@ -36,17 +36,11 @@
 }  // namespace
 
 QuicTransportServerSession::QuicTransportServerSession(
-    QuicConnection* connection,
-    Visitor* owner,
-    const QuicConfig& config,
+    QuicConnection* connection, Visitor* owner, const QuicConfig& config,
     const ParsedQuicVersionVector& supported_versions,
     const QuicCryptoServerConfig* crypto_config,
-    QuicCompressedCertsCache* compressed_certs_cache,
-    ServerVisitor* visitor)
-    : QuicSession(connection,
-                  owner,
-                  config,
-                  supported_versions,
+    QuicCompressedCertsCache* compressed_certs_cache, ServerVisitor* visitor)
+    : QuicSession(connection, owner, config, supported_versions,
                   /*num_expected_unidirectional_static_streams*/ 0),
       visitor_(visitor) {
   for (const ParsedQuicVersion& version : supported_versions) {
@@ -77,10 +71,8 @@
 
 QuicTransportServerSession::ClientIndication::ClientIndication(
     QuicTransportServerSession* session)
-    : QuicStream(ClientIndicationStream(),
-                 session,
-                 /* is_static= */ false,
-                 StreamType::READ_UNIDIRECTIONAL),
+    : QuicStream(ClientIndicationStream(), session,
+                 /* is_static= */ false, StreamType::READ_UNIDIRECTIONAL),
       session_(session) {}
 
 void QuicTransportServerSession::ClientIndication::OnDataAvailable() {
diff --git a/quiche/quic/quic_transport/quic_transport_server_session.h b/quiche/quic/quic_transport/quic_transport_server_session.h
index 9580bcc..1b74e72 100644
--- a/quiche/quic/quic_transport/quic_transport_server_session.h
+++ b/quiche/quic/quic_transport/quic_transport_server_session.h
@@ -36,8 +36,7 @@
     virtual bool ProcessPath(const GURL& url) = 0;
   };
 
-  QuicTransportServerSession(QuicConnection* connection,
-                             Visitor* owner,
+  QuicTransportServerSession(QuicConnection* connection, Visitor* owner,
                              const QuicConfig& config,
                              const ParsedQuicVersionVector& supported_versions,
                              const QuicCryptoServerConfig* crypto_config,
diff --git a/quiche/quic/quic_transport/quic_transport_server_session_test.cc b/quiche/quic/quic_transport/quic_transport_server_session_test.cc
index c2690a0..0a9d8e2 100644
--- a/quiche/quic/quic_transport/quic_transport_server_session_test.cc
+++ b/quiche/quic/quic_transport/quic_transport_server_session_test.cc
@@ -57,9 +57,7 @@
 class QuicTransportServerSessionTest : public QuicTest {
  public:
   QuicTransportServerSessionTest()
-      : connection_(&helper_,
-                    &alarm_factory_,
-                    Perspective::IS_SERVER,
+      : connection_(&helper_, &alarm_factory_, Perspective::IS_SERVER,
                     GetVersions()),
         crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance(),
diff --git a/quiche/quic/quic_transport/quic_transport_stream.cc b/quiche/quic/quic_transport/quic_transport_stream.cc
index 8855b20..efa770e 100644
--- a/quiche/quic/quic_transport/quic_transport_stream.cc
+++ b/quiche/quic/quic_transport/quic_transport_stream.cc
@@ -14,16 +14,13 @@
 namespace quic {
 
 QuicTransportStream::QuicTransportStream(
-    QuicStreamId id,
-    QuicSession* session,
+    QuicStreamId id, QuicSession* session,
     QuicTransportSessionInterface* session_interface)
-    : QuicStream(id,
-                 session,
+    : QuicStream(id, session,
                  /*is_static=*/false,
-                 QuicUtils::GetStreamType(id,
-                                          session->connection()->perspective(),
-                                          session->IsIncomingStream(id),
-                                          session->version())),
+                 QuicUtils::GetStreamType(
+                     id, session->connection()->perspective(),
+                     session->IsIncomingStream(id), session->version())),
       adapter_(session, this, sequencer()),
       session_interface_(session_interface) {}
 
@@ -72,9 +69,7 @@
   return adapter_.ReadableBytes();
 }
 
-void QuicTransportStream::OnDataAvailable() {
-  adapter_.OnDataAvailable();
-}
+void QuicTransportStream::OnDataAvailable() { adapter_.OnDataAvailable(); }
 
 void QuicTransportStream::OnCanWriteNewData() {
   // Ensure the origin check has been completed, as the stream can be notified
diff --git a/quiche/quic/quic_transport/quic_transport_stream.h b/quiche/quic/quic_transport/quic_transport_stream.h
index aacc330..28c791b 100644
--- a/quiche/quic/quic_transport/quic_transport_stream.h
+++ b/quiche/quic/quic_transport/quic_transport_stream.h
@@ -25,8 +25,7 @@
 class QUIC_EXPORT_PRIVATE QuicTransportStream : public QuicStream,
                                                 public WebTransportStream {
  public:
-  QuicTransportStream(QuicStreamId id,
-                      QuicSession* session,
+  QuicTransportStream(QuicStreamId id, QuicSession* session,
                       QuicTransportSessionInterface* session_interface);
 
   // Reads at most |buffer_size| bytes into |buffer| and returns the number of
diff --git a/quiche/quic/quic_transport/quic_transport_stream_test.cc b/quiche/quic/quic_transport/quic_transport_stream_test.cc
index 7e456ae..46fa227 100644
--- a/quiche/quic/quic_transport/quic_transport_stream_test.cc
+++ b/quiche/quic/quic_transport/quic_transport_stream_test.cc
@@ -36,10 +36,8 @@
 class QuicTransportStreamTest : public QuicTest {
  public:
   QuicTransportStreamTest()
-      : connection_(new MockQuicConnection(&helper_,
-                                           &alarm_factory_,
-                                           Perspective::IS_CLIENT,
-                                           GetVersions())),
+      : connection_(new MockQuicConnection(
+            &helper_, &alarm_factory_, Perspective::IS_CLIENT, GetVersions())),
         session_(connection_) {
     QuicEnableVersion(DefaultVersionForQuicTransport());
     session_.Initialize();