diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_base.cc b/quiche/quic/core/batch_writer/quic_batch_writer_base.cc
index 0b39823..4a94c71 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_base.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_base.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/core/batch_writer/quic_batch_writer_base.h"
+
 #include <cstdint>
 
 #include "quiche/quic/platform/api/quic_export.h"
@@ -16,11 +17,8 @@
     : write_blocked_(false), batch_buffer_(std::move(batch_buffer)) {}
 
 WriteResult QuicBatchWriterBase::WritePacket(
-    const char* buffer,
-    size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    PerPacketOptions* options) {
+    const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+    const QuicSocketAddress& peer_address, PerPacketOptions* options) {
   const WriteResult result =
       InternalWritePacket(buffer, buf_len, self_address, peer_address, options);
 
@@ -32,11 +30,8 @@
 }
 
 WriteResult QuicBatchWriterBase::InternalWritePacket(
-    const char* buffer,
-    size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    PerPacketOptions* options) {
+    const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+    const QuicSocketAddress& peer_address, PerPacketOptions* options) {
   if (buf_len > kMaxOutgoingPacketSize) {
     return WriteResult(WRITE_STATUS_MSG_TOO_BIG, EMSGSIZE);
   }
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_base.h b/quiche/quic/core/batch_writer/quic_batch_writer_base.h
index 4e09a40..a5a1e38 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_base.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_base.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_CORE_BATCH_WRITER_QUIC_BATCH_WRITER_BASE_H_
 
 #include <cstdint>
+
 #include "quiche/quic/core/batch_writer/quic_batch_writer_buffer.h"
 #include "quiche/quic/core/quic_packet_writer.h"
 #include "quiche/quic/core/quic_types.h"
@@ -28,8 +29,7 @@
   // ATTENTION: If this write triggered a flush, and the flush failed, all
   // buffered packets will be dropped to allow the next write to work. The
   // number of dropped packets can be found in WriteResult.dropped_packets.
-  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;
@@ -97,8 +97,7 @@
 
   // Given the existing buffered writes(in buffered_writes()), whether a new
   // write(in the arguments) can be batched.
-  virtual CanBatchResult CanBatch(const char* buffer,
-                                  size_t buf_len,
+  virtual CanBatchResult CanBatch(const char* buffer, size_t buf_len,
                                   const QuicIpAddress& self_address,
                                   const QuicSocketAddress& peer_address,
                                   const PerPacketOptions* options,
@@ -127,8 +126,7 @@
   virtual FlushImplResult FlushImpl() = 0;
 
  private:
-  WriteResult InternalWritePacket(const char* buffer,
-                                  size_t buf_len,
+  WriteResult InternalWritePacket(const char* buffer, size_t buf_len,
                                   const QuicIpAddress& self_address,
                                   const QuicSocketAddress& peer_address,
                                   PerPacketOptions* options);
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc
index 1463812..ac7ddd7 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc
@@ -12,9 +12,7 @@
   memset(buffer_, 0, sizeof(buffer_));
 }
 
-void QuicBatchWriterBuffer::Clear() {
-  buffered_writes_.clear();
-}
+void QuicBatchWriterBuffer::Clear() { buffered_writes_.clear(); }
 
 std::string QuicBatchWriterBuffer::DebugString() const {
   std::ostringstream os;
@@ -54,11 +52,8 @@
 }
 
 QuicBatchWriterBuffer::PushResult QuicBatchWriterBuffer::PushBufferedWrite(
-    const char* buffer,
-    size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    const PerPacketOptions* options,
+    const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+    const QuicSocketAddress& peer_address, const PerPacketOptions* options,
     uint64_t release_time) {
   QUICHE_DCHECK(Invariants());
   QUICHE_DCHECK_LE(buf_len, kMaxOutgoingPacketSize);
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
index b6fc412..2369401 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
@@ -40,8 +40,7 @@
     bool buffer_copied;
   };
 
-  PushResult PushBufferedWrite(const char* buffer,
-                               size_t buf_len,
+  PushResult PushBufferedWrite(const char* buffer, size_t buf_len,
                                const QuicIpAddress& self_address,
                                const QuicSocketAddress& peer_address,
                                const PerPacketOptions* options,
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc b/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
index c3152b2..e081a79 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/core/batch_writer/quic_batch_writer_buffer.h"
+
 #include <memory>
 #include <string>
 
@@ -48,10 +49,8 @@
     return packet_buffer;
   }
 
-  void CheckBufferedWriteContent(int buffered_write_index,
-                                 char buffer_content,
-                                 size_t buf_len,
-                                 const QuicIpAddress& self_addr,
+  void CheckBufferedWriteContent(int buffered_write_index, char buffer_content,
+                                 size_t buf_len, const QuicIpAddress& self_addr,
                                  const QuicSocketAddress& peer_addr,
                                  const PerPacketOptions* options) {
     const BufferedWrite& buffered_write =
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_test.cc b/quiche/quic/core/batch_writer/quic_batch_writer_test.cc
index 2cd3111..4a06830 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_test.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/core/batch_writer/quic_batch_writer_test.h"
+
 #include "quiche/quic/core/batch_writer/quic_gso_batch_writer.h"
 #include "quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h"
 
@@ -47,8 +48,7 @@
 };
 
 INSTANTIATE_TEST_SUITE_P(
-    QuicGsoBatchWriterTest,
-    QuicUdpBatchWriterIOTest,
+    QuicGsoBatchWriterTest, QuicUdpBatchWriterIOTest,
     testing::ValuesIn(
         MakeQuicBatchWriterTestParams<QuicGsoBatchWriterIOTestDelegate>()));
 
@@ -67,8 +67,7 @@
 };
 
 INSTANTIATE_TEST_SUITE_P(
-    QuicSendmmsgBatchWriterTest,
-    QuicUdpBatchWriterIOTest,
+    QuicSendmmsgBatchWriterTest, QuicUdpBatchWriterIOTest,
     testing::ValuesIn(MakeQuicBatchWriterTestParams<
                       QuicSendmmsgBatchWriterIOTestDelegate>()));
 
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_test.h b/quiche/quic/core/batch_writer/quic_batch_writer_test.h
index e42457c..ebbb917 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_test.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_test.h
@@ -95,8 +95,7 @@
   int packet_size;
 
   QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os,
-      const QuicUdpBatchWriterIOTestParams& p) {
+      std::ostream& os, const QuicUdpBatchWriterIOTestParams& p) {
     os << "{ address_family: " << p.address_family
        << " data_size: " << p.data_size << " packet_size: " << p.packet_size
        << " }";
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc b/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc
index 297f04e..b6d6200 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc
@@ -5,6 +5,7 @@
 #include "quiche/quic/core/batch_writer/quic_gso_batch_writer.h"
 
 #include <time.h>
+
 #include <ctime>
 
 #include "quiche/quic/core/quic_linux_socket_utils.h"
@@ -38,10 +39,8 @@
 }
 
 QuicGsoBatchWriter::QuicGsoBatchWriter(
-    std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
-    int fd,
-    clockid_t clockid_for_release_time,
-    ReleaseTimeForceEnabler /*enabler*/)
+    std::unique_ptr<QuicBatchWriterBuffer> batch_buffer, int fd,
+    clockid_t clockid_for_release_time, ReleaseTimeForceEnabler /*enabler*/)
     : QuicUdpBatchWriter(std::move(batch_buffer), fd),
       clockid_for_release_time_(clockid_for_release_time),
       supports_release_time_(true) {
@@ -49,11 +48,8 @@
 }
 
 QuicGsoBatchWriter::CanBatchResult QuicGsoBatchWriter::CanBatch(
-    const char* /*buffer*/,
-    size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    const PerPacketOptions* options,
+    const char* /*buffer*/, size_t buf_len, const QuicIpAddress& self_address,
+    const QuicSocketAddress& peer_address, const PerPacketOptions* options,
     uint64_t release_time) const {
   // If there is nothing buffered already, this write will be included in this
   // batch.
@@ -146,8 +142,7 @@
 // static
 void QuicGsoBatchWriter::BuildCmsg(QuicMsgHdr* hdr,
                                    const QuicIpAddress& self_address,
-                                   uint16_t gso_size,
-                                   uint64_t release_time) {
+                                   uint16_t gso_size, uint64_t release_time) {
   hdr->SetIpInNextCmsg(self_address);
   if (gso_size > 0) {
     *hdr->GetNextCmsgData<uint16_t>(SOL_UDP, UDP_SEGMENT) = gso_size;
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer.h b/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
index 70add6a..17657fc 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
@@ -21,8 +21,7 @@
 
   bool SupportsReleaseTime() const final { return supports_release_time_; }
 
-  CanBatchResult CanBatch(const char* buffer,
-                          size_t buf_len,
+  CanBatchResult CanBatch(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           const PerPacketOptions* options,
@@ -34,8 +33,7 @@
   // Test only constructor to forcefully enable release time.
   struct QUIC_EXPORT_PRIVATE ReleaseTimeForceEnabler {};
   QuicGsoBatchWriter(std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
-                     int fd,
-                     clockid_t clockid_for_release_time,
+                     int fd, clockid_t clockid_for_release_time,
                      ReleaseTimeForceEnabler enabler);
 
   ReleaseTime GetReleaseTime(const PerPacketOptions* options) const override;
@@ -54,10 +52,8 @@
 
   static const int kCmsgSpace =
       kCmsgSpaceForIp + kCmsgSpaceForSegmentSize + kCmsgSpaceForTxTime;
-  static void BuildCmsg(QuicMsgHdr* hdr,
-                        const QuicIpAddress& self_address,
-                        uint16_t gso_size,
-                        uint64_t release_time);
+  static void BuildCmsg(QuicMsgHdr* hdr, const QuicIpAddress& self_address,
+                        uint16_t gso_size, uint64_t release_time);
 
   template <size_t CmsgSpace, typename CmsgBuilderT>
   FlushImplResult InternalFlushImpl(CmsgBuilderT cmsg_builder) {
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc b/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
index 2bf0ffc..efe4c71 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
@@ -29,9 +29,7 @@
   return length;
 }
 
-uint64_t MillisToNanos(uint64_t milliseconds) {
-  return milliseconds * 1000000;
-}
+uint64_t MillisToNanos(uint64_t milliseconds) { return milliseconds * 1000000; }
 
 class QUIC_EXPORT_PRIVATE TestQuicGsoBatchWriter : public QuicGsoBatchWriter {
  public:
@@ -73,9 +71,7 @@
 struct QUIC_EXPORT_PRIVATE TestBufferedWrite : public BufferedWrite {
   using BufferedWrite::BufferedWrite;
   TestBufferedWrite(const TestBufferedWrite& other)
-      : BufferedWrite(other.buffer,
-                      other.buf_len,
-                      other.self_address,
+      : BufferedWrite(other.buffer, other.buf_len, other.self_address,
                       other.peer_address,
                       other.options ? other.options->Clone()
                                     : std::unique_ptr<PerPacketOptions>(),
@@ -86,17 +82,11 @@
 static char unused_packet_buffer[kMaxOutgoingPacketSize];
 
 struct QUIC_EXPORT_PRIVATE BatchCriteriaTestData {
-  BatchCriteriaTestData(size_t buf_len,
-                        const QuicIpAddress& self_address,
+  BatchCriteriaTestData(size_t buf_len, const QuicIpAddress& self_address,
                         const QuicSocketAddress& peer_address,
-                        uint64_t release_time,
-                        bool can_batch,
-                        bool must_flush)
-      : buffered_write(unused_packet_buffer,
-                       buf_len,
-                       self_address,
-                       peer_address,
-                       std::unique_ptr<PerPacketOptions>(),
+                        uint64_t release_time, bool can_batch, bool must_flush)
+      : buffered_write(unused_packet_buffer, buf_len, self_address,
+                       peer_address, std::unique_ptr<PerPacketOptions>(),
                        release_time),
         can_batch(can_batch),
         must_flush(must_flush) {}
diff --git a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
index e03aed0..8568e26 100644
--- a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
+++ b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
@@ -7,17 +7,14 @@
 namespace quic {
 
 QuicSendmmsgBatchWriter::QuicSendmmsgBatchWriter(
-    std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
-    int fd)
+    std::unique_ptr<QuicBatchWriterBuffer> batch_buffer, int fd)
     : QuicUdpBatchWriter(std::move(batch_buffer), fd) {}
 
 QuicSendmmsgBatchWriter::CanBatchResult QuicSendmmsgBatchWriter::CanBatch(
-    const char* /*buffer*/,
-    size_t /*buf_len*/,
+    const char* /*buffer*/, size_t /*buf_len*/,
     const QuicIpAddress& /*self_address*/,
     const QuicSocketAddress& /*peer_address*/,
-    const PerPacketOptions* /*options*/,
-    uint64_t /*release_time*/) const {
+    const PerPacketOptions* /*options*/, uint64_t /*release_time*/) const {
   return CanBatchResult(/*can_batch=*/true, /*must_flush=*/false);
 }
 
diff --git a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
index de78fd1..04a1b28 100644
--- a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
+++ b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
@@ -15,8 +15,7 @@
   QuicSendmmsgBatchWriter(std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
                           int fd);
 
-  CanBatchResult CanBatch(const char* buffer,
-                          size_t buf_len,
+  CanBatchResult CanBatch(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           const PerPacketOptions* options,
diff --git a/quiche/quic/masque/masque_client_bin.cc b/quiche/quic/masque/masque_client_bin.cc
index a2d0c62..8fd5e52 100644
--- a/quiche/quic/masque/masque_client_bin.cc
+++ b/quiche/quic/masque/masque_client_bin.cc
@@ -113,6 +113,4 @@
 
 }  // namespace quic
 
-int main(int argc, char* argv[]) {
-  return quic::RunMasqueClient(argc, argv);
-}
+int main(int argc, char* argv[]) { return quic::RunMasqueClient(argc, argv); }
diff --git a/quiche/quic/masque/masque_client_session.h b/quiche/quic/masque/masque_client_session.h
index d89f4b4..07673c3 100644
--- a/quiche/quic/masque/masque_client_session.h
+++ b/quiche/quic/masque/masque_client_session.h
@@ -49,8 +49,7 @@
 
     // Close the encapsulated connection.
     virtual void CloseConnection(
-        QuicErrorCode error,
-        const std::string& details,
+        QuicErrorCode error, const std::string& details,
         ConnectionCloseBehavior connection_close_behavior) = 0;
   };
 
@@ -173,8 +172,7 @@
   MasqueMode masque_mode_;
   std::string uri_template_;
   std::list<ConnectUdpClientState> connect_udp_client_states_;
-  absl::flat_hash_map<QuicConnectionId,
-                      EncapsulatedClientSession*,
+  absl::flat_hash_map<QuicConnectionId, EncapsulatedClientSession*,
                       QuicConnectionIdHash>
       client_connection_id_registrations_;
   Owner* owner_;  // Unowned;
diff --git a/quiche/quic/masque/masque_client_tools.cc b/quiche/quic/masque/masque_client_tools.cc
index 993716a..92fd9d7 100644
--- a/quiche/quic/masque/masque_client_tools.cc
+++ b/quiche/quic/masque/masque_client_tools.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/masque/masque_client_tools.h"
+
 #include "quiche/quic/masque/masque_encapsulated_epoll_client.h"
 #include "quiche/quic/masque/masque_utils.h"
 #include "quiche/quic/platform/api/quic_default_proof_providers.h"
diff --git a/quiche/quic/masque/masque_dispatcher.cc b/quiche/quic/masque/masque_dispatcher.cc
index d55e799..6db6f8c 100644
--- a/quiche/quic/masque/masque_dispatcher.cc
+++ b/quiche/quic/masque/masque_dispatcher.cc
@@ -3,28 +3,23 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/masque/masque_dispatcher.h"
+
 #include "quiche/quic/masque/masque_server_session.h"
 
 namespace quic {
 
 MasqueDispatcher::MasqueDispatcher(
-    MasqueMode masque_mode,
-    const QuicConfig* config,
+    MasqueMode masque_mode, const QuicConfig* config,
     const QuicCryptoServerConfig* crypto_config,
-    QuicVersionManager* version_manager,
-    QuicEpollServer* epoll_server,
+    QuicVersionManager* version_manager, QuicEpollServer* epoll_server,
     std::unique_ptr<QuicConnectionHelperInterface> helper,
     std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
     std::unique_ptr<QuicAlarmFactory> alarm_factory,
     MasqueServerBackend* masque_server_backend,
     uint8_t expected_server_connection_id_length)
-    : QuicSimpleDispatcher(config,
-                           crypto_config,
-                           version_manager,
-                           std::move(helper),
-                           std::move(session_helper),
-                           std::move(alarm_factory),
-                           masque_server_backend,
+    : QuicSimpleDispatcher(config, crypto_config, version_manager,
+                           std::move(helper), std::move(session_helper),
+                           std::move(alarm_factory), masque_server_backend,
                            expected_server_connection_id_length),
       masque_mode_(masque_mode),
       epoll_server_(epoll_server),
diff --git a/quiche/quic/masque/masque_dispatcher.h b/quiche/quic/masque/masque_dispatcher.h
index 34130c9..90d319c 100644
--- a/quiche/quic/masque/masque_dispatcher.h
+++ b/quiche/quic/masque/masque_dispatcher.h
@@ -21,11 +21,9 @@
                                         public MasqueServerSession::Visitor {
  public:
   explicit MasqueDispatcher(
-      MasqueMode masque_mode,
-      const QuicConfig* config,
+      MasqueMode masque_mode, const QuicConfig* config,
       const QuicCryptoServerConfig* crypto_config,
-      QuicVersionManager* version_manager,
-      QuicEpollServer* epoll_server,
+      QuicVersionManager* version_manager, QuicEpollServer* epoll_server,
       std::unique_ptr<QuicConnectionHelperInterface> helper,
       std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
       std::unique_ptr<QuicAlarmFactory> alarm_factory,
@@ -59,8 +57,7 @@
   MasqueServerBackend* masque_server_backend_;  // Unowned.
   // Mapping from client connection IDs to server sessions, allows routing
   // incoming packets to the right MASQUE connection.
-  absl::flat_hash_map<QuicConnectionId,
-                      MasqueServerSession*,
+  absl::flat_hash_map<QuicConnectionId, MasqueServerSession*,
                       QuicConnectionIdHash>
       client_connection_id_registrations_;
 };
diff --git a/quiche/quic/masque/masque_encapsulated_client_session.cc b/quiche/quic/masque/masque_encapsulated_client_session.cc
index 66f6062..988b511 100644
--- a/quiche/quic/masque/masque_encapsulated_client_session.cc
+++ b/quiche/quic/masque/masque_encapsulated_client_session.cc
@@ -7,24 +7,17 @@
 namespace quic {
 
 MasqueEncapsulatedClientSession::MasqueEncapsulatedClientSession(
-    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,
     MasqueClientSession* masque_client_session)
-    : QuicSpdyClientSession(config,
-                            supported_versions,
-                            connection,
-                            server_id,
-                            crypto_config,
-                            push_promise_index),
+    : QuicSpdyClientSession(config, supported_versions, connection, server_id,
+                            crypto_config, push_promise_index),
       masque_client_session_(masque_client_session) {}
 
 void MasqueEncapsulatedClientSession::ProcessPacket(
-    absl::string_view packet,
-    QuicSocketAddress server_address) {
+    absl::string_view packet, QuicSocketAddress server_address) {
   QuicTime now = connection()->clock()->ApproximateNow();
   QuicReceivedPacket received_packet(packet.data(), packet.length(), now);
   connection()->ProcessUdpPacket(connection()->self_address(), server_address,
@@ -32,15 +25,13 @@
 }
 
 void MasqueEncapsulatedClientSession::CloseConnection(
-    QuicErrorCode error,
-    const std::string& details,
+    QuicErrorCode error, const std::string& details,
     ConnectionCloseBehavior connection_close_behavior) {
   connection()->CloseConnection(error, details, connection_close_behavior);
 }
 
 void MasqueEncapsulatedClientSession::OnConnectionClosed(
-    const QuicConnectionCloseFrame& frame,
-    ConnectionCloseSource source) {
+    const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) {
   QuicSpdyClientSession::OnConnectionClosed(frame, source);
   masque_client_session_->UnregisterConnectionId(
       connection()->client_connection_id(), this);
diff --git a/quiche/quic/masque/masque_encapsulated_client_session.h b/quiche/quic/masque/masque_encapsulated_client_session.h
index 7e1433d..16fc65e 100644
--- a/quiche/quic/masque/masque_encapsulated_client_session.h
+++ b/quiche/quic/masque/masque_encapsulated_client_session.h
@@ -29,8 +29,7 @@
   MasqueEncapsulatedClientSession(
       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,
       MasqueClientSession* masque_client_session);
@@ -45,8 +44,7 @@
   void ProcessPacket(absl::string_view packet,
                      QuicSocketAddress server_address) override;
   void CloseConnection(
-      QuicErrorCode error,
-      const std::string& details,
+      QuicErrorCode error, const std::string& details,
       ConnectionCloseBehavior connection_close_behavior) override;
 
   // From QuicSession.
diff --git a/quiche/quic/masque/masque_encapsulated_epoll_client.cc b/quiche/quic/masque/masque_encapsulated_epoll_client.cc
index 2845541..41dde4e 100644
--- a/quiche/quic/masque/masque_encapsulated_epoll_client.cc
+++ b/quiche/quic/masque/masque_encapsulated_epoll_client.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/masque/masque_encapsulated_epoll_client.h"
+
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/masque/masque_client_session.h"
 #include "quiche/quic/masque/masque_encapsulated_client_session.h"
@@ -19,8 +20,7 @@
  public:
   explicit MasquePacketWriter(MasqueEncapsulatedEpollClient* client)
       : client_(client) {}
-  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 {
@@ -81,17 +81,13 @@
 }  // namespace
 
 MasqueEncapsulatedEpollClient::MasqueEncapsulatedEpollClient(
-    QuicSocketAddress server_address,
-    const QuicServerId& server_id,
+    QuicSocketAddress server_address, const QuicServerId& server_id,
     QuicEpollServer* epoll_server,
     std::unique_ptr<ProofVerifier> proof_verifier,
     MasqueEpollClient* masque_client)
     : QuicClient(
-          server_address,
-          server_id,
-          MasqueSupportedVersions(),
-          MasqueEncapsulatedConfig(),
-          epoll_server,
+          server_address, server_id, MasqueSupportedVersions(),
+          MasqueEncapsulatedConfig(), epoll_server,
           std::make_unique<MasqueClientEpollNetworkHelper>(epoll_server, this),
           std::move(proof_verifier)),
       masque_client_(masque_client) {}
diff --git a/quiche/quic/masque/masque_epoll_client.cc b/quiche/quic/masque/masque_epoll_client.cc
index d20ffe4..6d6470b 100644
--- a/quiche/quic/masque/masque_epoll_client.cc
+++ b/quiche/quic/masque/masque_epoll_client.cc
@@ -124,9 +124,7 @@
   return masque_client;
 }
 
-void MasqueEpollClient::OnSettingsReceived() {
-  settings_received_ = true;
-}
+void MasqueEpollClient::OnSettingsReceived() { settings_received_ = true; }
 
 bool MasqueEpollClient::WaitUntilSettingsReceived() {
   while (connected() && !settings_received_) {
diff --git a/quiche/quic/masque/masque_epoll_server.cc b/quiche/quic/masque/masque_epoll_server.cc
index 8399c71..1efc5e1 100644
--- a/quiche/quic/masque/masque_epoll_server.cc
+++ b/quiche/quic/masque/masque_epoll_server.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/masque/masque_epoll_server.h"
+
 #include "quiche/quic/core/quic_epoll_alarm_factory.h"
 #include "quiche/quic/masque/masque_dispatcher.h"
 #include "quiche/quic/masque/masque_utils.h"
@@ -13,8 +14,7 @@
 
 MasqueEpollServer::MasqueEpollServer(MasqueMode masque_mode,
                                      MasqueServerBackend* masque_server_backend)
-    : QuicServer(CreateDefaultProofSource(),
-                 masque_server_backend,
+    : QuicServer(CreateDefaultProofSource(), masque_server_backend,
                  MasqueSupportedVersions()),
       masque_mode_(masque_mode),
       masque_server_backend_(masque_server_backend) {}
diff --git a/quiche/quic/masque/masque_server_backend.cc b/quiche/quic/masque/masque_server_backend.cc
index 193ba18..8dfe8b8 100644
--- a/quiche/quic/masque/masque_server_backend.cc
+++ b/quiche/quic/masque/masque_server_backend.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "quiche/quic/masque/masque_server_backend.h"
+
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
@@ -73,8 +74,8 @@
 
   auto it = backend_client_states_.find(request_handler->connection_id());
   if (it == backend_client_states_.end()) {
-    QUIC_LOG(ERROR) << "Could not find backend client for "
-                    << masque_path << request_headers.DebugString();
+    QUIC_LOG(ERROR) << "Could not find backend client for " << masque_path
+                    << request_headers.DebugString();
     return false;
   }
 
diff --git a/quiche/quic/masque/masque_server_backend.h b/quiche/quic/masque/masque_server_backend.h
index 482fa51..7480a86 100644
--- a/quiche/quic/masque/masque_server_backend.h
+++ b/quiche/quic/masque/masque_server_backend.h
@@ -66,9 +66,9 @@
     BackendClient* backend_client;
     std::vector<std::unique_ptr<QuicBackendResponse>> responses;
   };
-  absl::
-      flat_hash_map<QuicConnectionId, BackendClientState, QuicConnectionIdHash>
-          backend_client_states_;
+  absl::flat_hash_map<QuicConnectionId, BackendClientState,
+                      QuicConnectionIdHash>
+      backend_client_states_;
 };
 
 }  // namespace quic