diff --git a/quiche/quic/qbone/mock_qbone_client.h b/quiche/quic/qbone/mock_qbone_client.h
index 1283431..8c278e9 100644
--- a/quiche/quic/qbone/mock_qbone_client.h
+++ b/quiche/quic/qbone/mock_qbone_client.h
@@ -13,9 +13,7 @@
 
 class MockQboneClient : public QboneClientInterface {
  public:
-  MOCK_METHOD(void,
-              ProcessPacketFromNetwork,
-              (absl::string_view packet),
+  MOCK_METHOD(void, ProcessPacketFromNetwork, (absl::string_view packet),
               (override));
 };
 
diff --git a/quiche/quic/qbone/mock_qbone_server_session.h b/quiche/quic/qbone/mock_qbone_server_session.h
index e889f97..eb0e4ea 100644
--- a/quiche/quic/qbone/mock_qbone_server_session.h
+++ b/quiche/quic/qbone/mock_qbone_server_session.h
@@ -13,8 +13,7 @@
 class MockQboneServerSession : public QboneServerSession {
  public:
   explicit MockQboneServerSession(QuicConnection* connection)
-      : QboneServerSession(CurrentSupportedVersions(),
-                           connection,
+      : QboneServerSession(CurrentSupportedVersions(), connection,
                            /*owner=*/nullptr,
                            /*config=*/{},
                            /*quic_crypto_server_config=*/nullptr,
diff --git a/quiche/quic/qbone/qbone_client.cc b/quiche/quic/qbone/qbone_client.cc
index 9f2fb09..5744eab 100644
--- a/quiche/quic/qbone/qbone_client.cc
+++ b/quiche/quic/qbone/qbone_client.cc
@@ -17,8 +17,7 @@
 namespace quic {
 namespace {
 std::unique_ptr<QuicClientBase::NetworkHelper> CreateNetworkHelper(
-    QuicEpollServer* epoll_server,
-    QboneClient* client) {
+    QuicEpollServer* epoll_server, QboneClient* client) {
   std::unique_ptr<QuicClientBase::NetworkHelper> helper =
       std::make_unique<QuicClientEpollNetworkHelper>(epoll_server, client);
   quic::AdjustTestValue("QboneClient/network_helper", &helper);
@@ -36,13 +35,10 @@
                          QbonePacketWriter* qbone_writer,
                          QboneClientControlStream::Handler* qbone_handler)
     : QuicClientBase(
-          server_id,
-          supported_versions,
-          config,
+          server_id, supported_versions, config,
           new QuicEpollConnectionHelper(epoll_server, QuicAllocator::SIMPLE),
           new QuicEpollAlarmFactory(epoll_server),
-          CreateNetworkHelper(epoll_server, this),
-          std::move(proof_verifier),
+          CreateNetworkHelper(epoll_server, this), std::move(proof_verifier),
           nullptr),
       qbone_writer_(qbone_writer),
       qbone_handler_(qbone_handler),
@@ -51,9 +47,7 @@
   crypto_config()->set_alpn("qbone");
 }
 
-QboneClient::~QboneClient() {
-  ResetSession();
-}
+QboneClient::~QboneClient() { ResetSession(); }
 
 QboneClientSession* QboneClient::qbone_session() {
   return static_cast<QboneClientSession*>(QuicClientBase::session());
diff --git a/quiche/quic/qbone/qbone_client.h b/quiche/quic/qbone/qbone_client.h
index ca4a32a..5f52679 100644
--- a/quiche/quic/qbone/qbone_client.h
+++ b/quiche/quic/qbone/qbone_client.h
@@ -20,11 +20,9 @@
  public:
   // Note that the epoll server, QBONE writer, and handler are owned
   // by the caller.
-  QboneClient(QuicSocketAddress server_address,
-              const QuicServerId& server_id,
+  QboneClient(QuicSocketAddress server_address, const QuicServerId& server_id,
               const ParsedQuicVersionVector& supported_versions,
-              QuicSession::Visitor* session_owner,
-              const QuicConfig& config,
+              QuicSession::Visitor* session_owner, const QuicConfig& config,
               QuicEpollServer* epoll_server,
               std::unique_ptr<ProofVerifier> proof_verifier,
               QbonePacketWriter* qbone_writer,
@@ -60,9 +58,7 @@
     return qbone_handler_;
   }
 
-  QuicSession::Visitor* session_owner() {
-    return session_owner_;
-  }
+  QuicSession::Visitor* session_owner() { return session_owner_; }
 
   bool HasActiveRequests() override;
 
diff --git a/quiche/quic/qbone/qbone_client_session.cc b/quiche/quic/qbone/qbone_client_session.cc
index ab21a34..4c22d23 100644
--- a/quiche/quic/qbone/qbone_client_session.cc
+++ b/quiche/quic/qbone/qbone_client_session.cc
@@ -21,11 +21,9 @@
 QboneClientSession::QboneClientSession(
     QuicConnection* connection,
     QuicCryptoClientConfig* quic_crypto_client_config,
-    QuicSession::Visitor* owner,
-    const QuicConfig& config,
+    QuicSession::Visitor* owner, const QuicConfig& config,
     const ParsedQuicVersionVector& supported_versions,
-    const QuicServerId& server_id,
-    QbonePacketWriter* writer,
+    const QuicServerId& server_id, QbonePacketWriter* writer,
     QboneClientControlStream::Handler* handler)
     : QboneSessionBase(connection, owner, config, supported_versions, writer),
       server_id_(server_id),
diff --git a/quiche/quic/qbone/qbone_client_session.h b/quiche/quic/qbone/qbone_client_session.h
index 37a1c28..b0bd5cf 100644
--- a/quiche/quic/qbone/qbone_client_session.h
+++ b/quiche/quic/qbone/qbone_client_session.h
@@ -21,11 +21,9 @@
  public:
   QboneClientSession(QuicConnection* connection,
                      QuicCryptoClientConfig* quic_crypto_client_config,
-                     QuicSession::Visitor* owner,
-                     const QuicConfig& config,
+                     QuicSession::Visitor* owner, const QuicConfig& config,
                      const ParsedQuicVersionVector& supported_versions,
-                     const QuicServerId& server_id,
-                     QbonePacketWriter* writer,
+                     const QuicServerId& server_id, QbonePacketWriter* writer,
                      QboneClientControlStream::Handler* handler);
   QboneClientSession(const QboneClientSession&) = delete;
   QboneClientSession& operator=(const QboneClientSession&) = delete;
diff --git a/quiche/quic/qbone/qbone_client_test.cc b/quiche/quic/qbone/qbone_client_test.cc
index dd6aa43..f796c46 100644
--- a/quiche/quic/qbone/qbone_client_test.cc
+++ b/quiche/quic/qbone/qbone_client_test.cc
@@ -77,22 +77,13 @@
  public:
   ConnectionOwningQboneServerSession(
       const ParsedQuicVersionVector& supported_versions,
-      QuicConnection* connection,
-      Visitor* owner,
-      const QuicConfig& config,
+      QuicConnection* connection, Visitor* owner, const QuicConfig& config,
       const QuicCryptoServerConfig* quic_crypto_server_config,
       QuicCompressedCertsCache* compressed_certs_cache,
       QbonePacketWriter* writer)
-      : QboneServerSession(supported_versions,
-                           connection,
-                           owner,
-                           config,
-                           quic_crypto_server_config,
-                           compressed_certs_cache,
-                           writer,
-                           TestLoopback6(),
-                           TestLoopback6(),
-                           64,
+      : QboneServerSession(supported_versions, connection, owner, config,
+                           quic_crypto_server_config, compressed_certs_cache,
+                           writer, TestLoopback6(), TestLoopback6(), 64,
                            nullptr),
         connection_(connection) {}
 
@@ -105,18 +96,14 @@
 class QuicQboneDispatcher : public QuicDispatcher {
  public:
   QuicQboneDispatcher(
-      const QuicConfig* config,
-      const QuicCryptoServerConfig* crypto_config,
+      const QuicConfig* config, const QuicCryptoServerConfig* crypto_config,
       QuicVersionManager* version_manager,
       std::unique_ptr<QuicConnectionHelperInterface> helper,
       std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
       std::unique_ptr<QuicAlarmFactory> alarm_factory,
       QbonePacketWriter* writer)
-      : QuicDispatcher(config,
-                       crypto_config,
-                       version_manager,
-                       std::move(helper),
-                       std::move(session_helper),
+      : QuicDispatcher(config, crypto_config, version_manager,
+                       std::move(helper), std::move(session_helper),
                        std::move(alarm_factory),
                        kQuicDefaultConnectionIdLength),
         writer_(writer) {}
@@ -175,15 +162,9 @@
                   const ParsedQuicVersionVector& supported_versions,
                   QuicEpollServer* epoll_server,
                   std::unique_ptr<ProofVerifier> proof_verifier)
-      : QboneClient(server_address,
-                    server_id,
-                    supported_versions,
-                    /*session_owner=*/nullptr,
-                    QuicConfig(),
-                    epoll_server,
-                    std::move(proof_verifier),
-                    &qbone_writer_,
-                    nullptr) {}
+      : QboneClient(server_address, server_id, supported_versions,
+                    /*session_owner=*/nullptr, QuicConfig(), epoll_server,
+                    std::move(proof_verifier), &qbone_writer_, nullptr) {}
 
   ~QboneTestClient() override {}
 
@@ -220,8 +201,7 @@
 
 class QboneClientTest : public QuicTestWithParam<ParsedQuicVersion> {};
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QboneClientTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QboneClientTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/qbone/qbone_control_stream.cc b/quiche/quic/qbone/qbone_control_stream.cc
index 08efbc2..5ded995 100644
--- a/quiche/quic/qbone/qbone_control_stream.cc
+++ b/quiche/quic/qbone/qbone_control_stream.cc
@@ -22,8 +22,7 @@
     : QuicStream(
           QboneConstants::GetControlStreamId(session->transport_version()),
           session,
-          /*is_static=*/true,
-          BIDIRECTIONAL),
+          /*is_static=*/true, BIDIRECTIONAL),
       pending_message_size_(0) {}
 
 QboneControlStreamBase::QboneControlStreamBase(quic::PendingStream* pending,
diff --git a/quiche/quic/qbone/qbone_control_stream.h b/quiche/quic/qbone/qbone_control_stream.h
index 5935aa5..379d735 100644
--- a/quiche/quic/qbone/qbone_control_stream.h
+++ b/quiche/quic/qbone/qbone_control_stream.h
@@ -34,7 +34,7 @@
 template <class T>
 class QUIC_EXPORT_PRIVATE QboneControlHandler {
  public:
-  virtual ~QboneControlHandler() { }
+  virtual ~QboneControlHandler() {}
 
   virtual void OnControlRequest(const T& request) = 0;
   virtual void OnControlError() = 0;
diff --git a/quiche/quic/qbone/qbone_packet_exchanger.h b/quiche/quic/qbone/qbone_packet_exchanger.h
index 12f44b1..4fd617b 100644
--- a/quiche/quic/qbone/qbone_packet_exchanger.h
+++ b/quiche/quic/qbone/qbone_packet_exchanger.h
@@ -59,9 +59,7 @@
   // Returns true if the write succeeds. blocked will be set to true if the
   // write failure is caused by the local network being blocked. error contains
   // the error message.
-  virtual bool WritePacket(const char* packet,
-                           size_t size,
-                           bool* blocked,
+  virtual bool WritePacket(const char* packet, size_t size, bool* blocked,
                            std::string* error) = 0;
 
   std::list<std::unique_ptr<QuicData>> packet_queue_;
diff --git a/quiche/quic/qbone/qbone_packet_exchanger_test.cc b/quiche/quic/qbone/qbone_packet_exchanger_test.cc
index bbd6456..be60841 100644
--- a/quiche/quic/qbone/qbone_packet_exchanger_test.cc
+++ b/quiche/quic/qbone/qbone_packet_exchanger_test.cc
@@ -69,9 +69,7 @@
   }
 
   // Implements QbonePacketExchanger::WritePacket.
-  bool WritePacket(const char* packet,
-                   size_t size,
-                   bool* blocked,
+  bool WritePacket(const char* packet, size_t size, bool* blocked,
                    std::string* error) override {
     *blocked = false;
 
diff --git a/quiche/quic/qbone/qbone_packet_processor.cc b/quiche/quic/qbone/qbone_packet_processor.cc
index 0dd0460..cad6cff 100644
--- a/quiche/quic/qbone/qbone_packet_processor.cc
+++ b/quiche/quic/qbone/qbone_packet_processor.cc
@@ -160,11 +160,8 @@
 }
 
 QbonePacketProcessor::ProcessingResult QbonePacketProcessor::ProcessIPv6Header(
-    std::string* packet,
-    Direction direction,
-    uint8_t* transport_protocol,
-    char** transport_data,
-    icmp6_hdr* icmp_header) {
+    std::string* packet, Direction direction, uint8_t* transport_protocol,
+    char** transport_data, icmp6_hdr* icmp_header) {
   // Check if the packet is big enough to have IPv6 header.
   if (packet->size() < kIPv6HeaderSize) {
     QUIC_DVLOG(1) << "Dropped malformed packet: IPv6 header too short";
diff --git a/quiche/quic/qbone/qbone_packet_processor.h b/quiche/quic/qbone/qbone_packet_processor.h
index 2a0f999..ab7ca00 100644
--- a/quiche/quic/qbone/qbone_packet_processor.h
+++ b/quiche/quic/qbone/qbone_packet_processor.h
@@ -131,10 +131,8 @@
   // |output| gets notified whenever the processor decides to send a packet, and
   // |stats| gets notified about any decisions that processor makes, without a
   // reference to which packet that decision was made about.
-  QbonePacketProcessor(QuicIpAddress self_ip,
-                       QuicIpAddress client_ip,
-                       size_t client_ip_subnet_length,
-                       OutputInterface* output,
+  QbonePacketProcessor(QuicIpAddress self_ip, QuicIpAddress client_ip,
+                       size_t client_ip_subnet_length, OutputInterface* output,
                        StatsInterface* stats);
   QbonePacketProcessor(const QbonePacketProcessor&) = delete;
   QbonePacketProcessor& operator=(const QbonePacketProcessor&) = delete;
@@ -187,8 +185,7 @@
  private:
   // Performs basic sanity and permission checks on the packet, and decreases
   // the TTL.
-  ProcessingResult ProcessIPv6Header(std::string* packet,
-                                     Direction direction,
+  ProcessingResult ProcessIPv6Header(std::string* packet, Direction direction,
                                      uint8_t* transport_protocol,
                                      char** transport_data,
                                      icmp6_hdr* icmp_header);
diff --git a/quiche/quic/qbone/qbone_packet_processor_test.cc b/quiche/quic/qbone/qbone_packet_processor_test.cc
index f831973..ed3b45c 100644
--- a/quiche/quic/qbone/qbone_packet_processor_test.cc
+++ b/quiche/quic/qbone/qbone_packet_processor_test.cc
@@ -102,19 +102,16 @@
 // clang-format on
 
 static const absl::string_view kReferenceClientPacket(
-    kReferenceClientPacketData,
-    arraysize(kReferenceClientPacketData));
+    kReferenceClientPacketData, arraysize(kReferenceClientPacketData));
 
 static const absl::string_view kReferenceNetworkPacket(
-    kReferenceNetworkPacketData,
-    arraysize(kReferenceNetworkPacketData));
+    kReferenceNetworkPacketData, arraysize(kReferenceNetworkPacketData));
 
 static const absl::string_view kReferenceClientSubnetPacket(
     kReferenceClientSubnetPacketData,
     arraysize(kReferenceClientSubnetPacketData));
 
-MATCHER_P(IsIcmpMessage,
-          icmp_type,
+MATCHER_P(IsIcmpMessage, icmp_type,
           "Checks whether the argument is an ICMP message of supplied type") {
   if (arg.size() < kTotalICMPv6HeaderSize) {
     return false;
@@ -125,12 +122,8 @@
 
 class MockPacketFilter : public QbonePacketProcessor::Filter {
  public:
-  MOCK_METHOD(ProcessingResult,
-              FilterPacket,
-              (Direction,
-               absl::string_view,
-               absl::string_view,
-               icmp6_hdr*,
+  MOCK_METHOD(ProcessingResult, FilterPacket,
+              (Direction, absl::string_view, absl::string_view, icmp6_hdr*,
                OutputInterface*),
               (override));
 };
diff --git a/quiche/quic/qbone/qbone_packet_processor_test_tools.h b/quiche/quic/qbone/qbone_packet_processor_test_tools.h
index 587f685..191a417 100644
--- a/quiche/quic/qbone/qbone_packet_processor_test_tools.h
+++ b/quiche/quic/qbone/qbone_packet_processor_test_tools.h
@@ -23,25 +23,15 @@
  public:
   MockPacketProcessorStats() {}
 
-  MOCK_METHOD(void,
-              OnPacketForwarded,
-              (QbonePacketProcessor::Direction),
+  MOCK_METHOD(void, OnPacketForwarded, (QbonePacketProcessor::Direction),
               (override));
-  MOCK_METHOD(void,
-              OnPacketDroppedSilently,
-              (QbonePacketProcessor::Direction),
+  MOCK_METHOD(void, OnPacketDroppedSilently, (QbonePacketProcessor::Direction),
               (override));
-  MOCK_METHOD(void,
-              OnPacketDroppedWithIcmp,
-              (QbonePacketProcessor::Direction),
+  MOCK_METHOD(void, OnPacketDroppedWithIcmp, (QbonePacketProcessor::Direction),
               (override));
-  MOCK_METHOD(void,
-              OnPacketDroppedWithTcpReset,
-              (QbonePacketProcessor::Direction),
-              (override));
-  MOCK_METHOD(void,
-              OnPacketDeferred,
-              (QbonePacketProcessor::Direction),
+  MOCK_METHOD(void, OnPacketDroppedWithTcpReset,
+              (QbonePacketProcessor::Direction), (override));
+  MOCK_METHOD(void, OnPacketDeferred, (QbonePacketProcessor::Direction),
               (override));
 };
 
diff --git a/quiche/quic/qbone/qbone_server_session.cc b/quiche/quic/qbone/qbone_server_session.cc
index ada978e..6f189e7 100644
--- a/quiche/quic/qbone/qbone_server_session.cc
+++ b/quiche/quic/qbone/qbone_server_session.cc
@@ -22,11 +22,9 @@
 namespace quic {
 
 bool QboneCryptoServerStreamHelper::CanAcceptClientHello(
-    const CryptoHandshakeMessage& chlo,
-    const QuicSocketAddress& client_address,
+    const CryptoHandshakeMessage& chlo, const QuicSocketAddress& client_address,
     const QuicSocketAddress& peer_address,
-    const QuicSocketAddress& self_address,
-    std::string* error_details) const {
+    const QuicSocketAddress& self_address, std::string* error_details) const {
   absl::string_view alpn;
   chlo.GetStringPiece(quic::kALPN, &alpn);
   if (alpn != QboneConstants::kQboneAlpn) {
@@ -38,16 +36,11 @@
 
 QboneServerSession::QboneServerSession(
     const quic::ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection,
-    Visitor* owner,
-    const QuicConfig& config,
+    QuicConnection* connection, Visitor* owner, const QuicConfig& config,
     const QuicCryptoServerConfig* quic_crypto_server_config,
-    QuicCompressedCertsCache* compressed_certs_cache,
-    QbonePacketWriter* writer,
-    QuicIpAddress self_ip,
-    QuicIpAddress client_ip,
-    size_t client_ip_subnet_length,
-    QboneServerControlStream::Handler* handler)
+    QuicCompressedCertsCache* compressed_certs_cache, QbonePacketWriter* writer,
+    QuicIpAddress self_ip, QuicIpAddress client_ip,
+    size_t client_ip_subnet_length, QboneServerControlStream::Handler* handler)
     : QboneSessionBase(connection, owner, config, supported_versions, writer),
       processor_(self_ip, client_ip, client_ip_subnet_length, this, this),
       quic_crypto_server_config_(quic_crypto_server_config),
diff --git a/quiche/quic/qbone/qbone_server_session.h b/quiche/quic/qbone/qbone_server_session.h
index 341b524..dbeb08b 100644
--- a/quiche/quic/qbone/qbone_server_session.h
+++ b/quiche/quic/qbone/qbone_server_session.h
@@ -35,15 +35,12 @@
       public QbonePacketProcessor::StatsInterface {
  public:
   QboneServerSession(const quic::ParsedQuicVersionVector& supported_versions,
-                     QuicConnection* connection,
-                     Visitor* owner,
+                     QuicConnection* connection, Visitor* owner,
                      const QuicConfig& config,
                      const QuicCryptoServerConfig* quic_crypto_server_config,
                      QuicCompressedCertsCache* compressed_certs_cache,
-                     QbonePacketWriter* writer,
-                     QuicIpAddress self_ip,
-                     QuicIpAddress client_ip,
-                     size_t client_ip_subnet_length,
+                     QbonePacketWriter* writer, QuicIpAddress self_ip,
+                     QuicIpAddress client_ip, size_t client_ip_subnet_length,
                      QboneServerControlStream::Handler* handler);
   QboneServerSession(const QboneServerSession&) = delete;
   QboneServerSession& operator=(const QboneServerSession&) = delete;
diff --git a/quiche/quic/qbone/qbone_session_base.cc b/quiche/quic/qbone/qbone_session_base.cc
index 1994c84..95bd7c7 100644
--- a/quiche/quic/qbone/qbone_session_base.cc
+++ b/quiche/quic/qbone/qbone_session_base.cc
@@ -31,15 +31,10 @@
   (perspective() == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
 QboneSessionBase::QboneSessionBase(
-    QuicConnection* connection,
-    Visitor* owner,
-    const QuicConfig& config,
+    QuicConnection* connection, Visitor* owner, const QuicConfig& config,
     const ParsedQuicVersionVector& supported_versions,
     QbonePacketWriter* writer)
-    : QuicSession(connection,
-                  owner,
-                  config,
-                  supported_versions,
+    : QuicSession(connection, owner, config, supported_versions,
                   /*num_expected_unidirectional_static_streams = */ 0) {
   set_writer(writer);
   const uint32_t max_streams =
diff --git a/quiche/quic/qbone/qbone_session_base.h b/quiche/quic/qbone/qbone_session_base.h
index 1304858..b1278bd 100644
--- a/quiche/quic/qbone/qbone_session_base.h
+++ b/quiche/quic/qbone/qbone_session_base.h
@@ -19,8 +19,7 @@
 
 class QUIC_EXPORT_PRIVATE QboneSessionBase : public QuicSession {
  public:
-  QboneSessionBase(QuicConnection* connection,
-                   Visitor* owner,
+  QboneSessionBase(QuicConnection* connection, Visitor* owner,
                    const QuicConfig& config,
                    const ParsedQuicVersionVector& supported_versions,
                    QbonePacketWriter* writer);
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index e774202..faa1d3a 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -72,8 +72,7 @@
   // ProofSource override.
   void GetProof(const QuicSocketAddress& server_address,
                 const QuicSocketAddress& client_address,
-                const std::string& hostname,
-                const std::string& server_config,
+                const std::string& hostname, const std::string& server_config,
                 QuicTransportVersion transport_version,
                 absl::string_view chlo_hash,
                 std::unique_ptr<Callback> callback) override {
@@ -103,10 +102,8 @@
 
   void ComputeTlsSignature(
       const QuicSocketAddress& server_address,
-      const QuicSocketAddress& client_address,
-      const std::string& hostname,
-      uint16_t signature_algorithm,
-      absl::string_view in,
+      const QuicSocketAddress& client_address, const std::string& hostname,
+      uint16_t signature_algorithm, absl::string_view in,
       std::unique_ptr<SignatureCallback> callback) override {
     if (!proof_source_) {
       callback->Run(/*ok=*/true, "Signature", /*details=*/nullptr);
@@ -144,16 +141,11 @@
 
   // ProofVerifier override
   QuicAsyncStatus VerifyProof(
-      const std::string& hostname,
-      const uint16_t port,
-      const std::string& server_config,
-      QuicTransportVersion transport_version,
-      absl::string_view chlo_hash,
-      const std::vector<std::string>& certs,
-      const std::string& cert_sct,
-      const std::string& signature,
-      const ProofVerifyContext* context,
-      std::string* error_details,
+      const std::string& hostname, const uint16_t port,
+      const std::string& server_config, QuicTransportVersion transport_version,
+      absl::string_view chlo_hash, const std::vector<std::string>& certs,
+      const std::string& cert_sct, const std::string& signature,
+      const ProofVerifyContext* context, std::string* error_details,
       std::unique_ptr<ProofVerifyDetails>* verify_details,
       std::unique_ptr<ProofVerifierCallback> callback) override {
     if (!proof_verifier_) {
@@ -166,14 +158,10 @@
   }
 
   QuicAsyncStatus VerifyCertChain(
-      const std::string& hostname,
-      const uint16_t port,
-      const std::vector<std::string>& certs,
-      const std::string& ocsp_response,
-      const std::string& cert_sct,
-      const ProofVerifyContext* context,
-      std::string* error_details,
-      std::unique_ptr<ProofVerifyDetails>* details,
+      const std::string& hostname, const uint16_t port,
+      const std::vector<std::string>& certs, const std::string& ocsp_response,
+      const std::string& cert_sct, const ProofVerifyContext* context,
+      std::string* error_details, std::unique_ptr<ProofVerifyDetails>* details,
       uint8_t* out_alert,
       std::unique_ptr<ProofVerifierCallback> callback) override {
     if (!proof_verifier_) {
@@ -278,8 +266,7 @@
 
  private:
   using TaskType = std::shared_ptr<InnerTask>;
-  std::priority_queue<TaskType,
-                      std::vector<TaskType>,
+  std::priority_queue<TaskType, std::vector<TaskType>,
                       std::function<bool(const TaskType&, const TaskType&)>>
       tasks_;
   MockQuicConnectionHelper* helper_;
@@ -414,8 +401,7 @@
   }
 
   void ExpectICMPTooBigResponse(const std::vector<std::string>& written_packets,
-                                const int mtu,
-                                const std::string& packet) {
+                                const int mtu, const std::string& packet) {
     auto* header = reinterpret_cast<const ip6_hdr*>(packet.data());
     icmp6_hdr icmp_header{};
     icmp_header.icmp6_type = ICMP6_PACKET_TOO_BIG;
@@ -554,8 +540,7 @@
   std::unique_ptr<QboneClientSession> client_peer_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QboneSessionTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QboneSessionTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/qbone/qbone_stream.cc b/quiche/quic/qbone/qbone_stream.cc
index dad501b..3ee8634 100644
--- a/quiche/quic/qbone/qbone_stream.cc
+++ b/quiche/quic/qbone/qbone_stream.cc
@@ -34,10 +34,8 @@
 
 QboneReadOnlyStream::QboneReadOnlyStream(QuicStreamId id,
                                          QboneSessionBase* session)
-    : QuicStream(id,
-                 session,
-                 /*is_static=*/false,
-                 READ_UNIDIRECTIONAL),
+    : QuicStream(id, session,
+                 /*is_static=*/false, READ_UNIDIRECTIONAL),
       session_(session) {
   // QBONE uses a LIFO queue to try to always make progress. An individual
   // packet may persist for upto to qbone_stream_ttl_secs seconds in memory.