diff --git a/quiche/quic/core/qpack/qpack_blocking_manager.cc b/quiche/quic/core/qpack/qpack_blocking_manager.cc
index 6ab7307..17b6e9f 100644
--- a/quiche/quic/core/qpack/qpack_blocking_manager.cc
+++ b/quiche/quic/core/qpack/qpack_blocking_manager.cc
@@ -69,8 +69,7 @@
 }
 
 bool QpackBlockingManager::blocking_allowed_on_stream(
-    QuicStreamId stream_id,
-    uint64_t maximum_blocked_streams) const {
+    QuicStreamId stream_id, uint64_t maximum_blocked_streams) const {
   // This should be the most common case: the limit is larger than the number of
   // streams that have unacknowledged header blocks (regardless of whether they
   // are blocked or not) plus one for stream |stream_id|.
diff --git a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
index 9e87f20..0f4766b 100644
--- a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
+++ b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
@@ -12,9 +12,7 @@
 namespace quic {
 
 QpackDecodedHeadersAccumulator::QpackDecodedHeadersAccumulator(
-    QuicStreamId id,
-    QpackDecoder* qpack_decoder,
-    Visitor* visitor,
+    QuicStreamId id, QpackDecoder* qpack_decoder, Visitor* visitor,
     size_t max_header_list_size)
     : decoder_(qpack_decoder->CreateProgressiveDecoder(id, this)),
       visitor_(visitor),
diff --git a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
index 27c94bd..0e6e31b 100644
--- a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
+++ b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
@@ -50,10 +50,8 @@
                                        absl::string_view error_message) = 0;
   };
 
-  QpackDecodedHeadersAccumulator(QuicStreamId id,
-                                 QpackDecoder* qpack_decoder,
-                                 Visitor* visitor,
-                                 size_t max_header_list_size);
+  QpackDecodedHeadersAccumulator(QuicStreamId id, QpackDecoder* qpack_decoder,
+                                 Visitor* visitor, size_t max_header_list_size);
   virtual ~QpackDecodedHeadersAccumulator() = default;
 
   // QpackProgressiveDecoder::HeadersHandlerInterface implementation.
diff --git a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
index 92d7511..b3e54be 100644
--- a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
+++ b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
@@ -42,8 +42,7 @@
 class MockVisitor : public QpackDecodedHeadersAccumulator::Visitor {
  public:
   ~MockVisitor() override = default;
-  MOCK_METHOD(void,
-              OnHeadersDecoded,
+  MOCK_METHOD(void, OnHeadersDecoded,
               (QuicHeaderList headers, bool header_list_size_limit_exceeded),
               (override));
   MOCK_METHOD(void, OnHeaderDecodingError,
@@ -56,12 +55,9 @@
 class QpackDecodedHeadersAccumulatorTest : public QuicTest {
  protected:
   QpackDecodedHeadersAccumulatorTest()
-      : qpack_decoder_(kMaxDynamicTableCapacity,
-                       kMaximumBlockedStreams,
+      : qpack_decoder_(kMaxDynamicTableCapacity, kMaximumBlockedStreams,
                        &encoder_stream_error_delegate_),
-        accumulator_(kTestStreamId,
-                     &qpack_decoder_,
-                     &visitor_,
+        accumulator_(kTestStreamId, &qpack_decoder_, &visitor_,
                      kMaxHeaderListSize) {
     qpack_decoder_.set_qpack_stream_sender_delegate(
         &decoder_stream_sender_delegate_);
diff --git a/quiche/quic/core/qpack/qpack_decoder.cc b/quiche/quic/core/qpack/qpack_decoder.cc
index e93db67..0569850 100644
--- a/quiche/quic/core/qpack/qpack_decoder.cc
+++ b/quiche/quic/core/qpack/qpack_decoder.cc
@@ -15,8 +15,7 @@
 namespace quic {
 
 QpackDecoder::QpackDecoder(
-    uint64_t maximum_dynamic_table_capacity,
-    uint64_t maximum_blocked_streams,
+    uint64_t maximum_dynamic_table_capacity, uint64_t maximum_blocked_streams,
     EncoderStreamErrorDelegate* encoder_stream_error_delegate)
     : encoder_stream_error_delegate_(encoder_stream_error_delegate),
       encoder_stream_receiver_(this),
diff --git a/quiche/quic/core/qpack/qpack_decoder.h b/quiche/quic/core/qpack/qpack_decoder.h
index 940535d..e063795 100644
--- a/quiche/quic/core/qpack/qpack_decoder.h
+++ b/quiche/quic/core/qpack/qpack_decoder.h
@@ -83,8 +83,7 @@
       QpackProgressiveDecoder::HeadersHandlerInterface* handler);
 
   // QpackEncoderStreamReceiver::Delegate implementation
-  void OnInsertWithNameReference(bool is_static,
-                                 uint64_t name_index,
+  void OnInsertWithNameReference(bool is_static, uint64_t name_index,
                                  absl::string_view value) override;
   void OnInsertWithoutNameReference(absl::string_view name,
                                     absl::string_view value) override;
diff --git a/quiche/quic/core/qpack/qpack_decoder_stream_receiver_test.cc b/quiche/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
index c78cbe7..6cee903 100644
--- a/quiche/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
+++ b/quiche/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
@@ -20,13 +20,10 @@
   ~MockDelegate() override = default;
 
   MOCK_METHOD(void, OnInsertCountIncrement, (uint64_t increment), (override));
-  MOCK_METHOD(void,
-              OnHeaderAcknowledgement,
-              (QuicStreamId stream_id),
+  MOCK_METHOD(void, OnHeaderAcknowledgement, (QuicStreamId stream_id),
               (override));
   MOCK_METHOD(void, OnStreamCancellation, (QuicStreamId stream_id), (override));
-  MOCK_METHOD(void,
-              OnErrorDetected,
+  MOCK_METHOD(void, OnErrorDetected,
               (QuicErrorCode error_code, absl::string_view error_message),
               (override));
 };
diff --git a/quiche/quic/core/qpack/qpack_decoder_test.cc b/quiche/quic/core/qpack/qpack_decoder_test.cc
index f15b3e8..e5b8504 100644
--- a/quiche/quic/core/qpack/qpack_decoder_test.cc
+++ b/quiche/quic/core/qpack/qpack_decoder_test.cc
@@ -36,8 +36,7 @@
 class QpackDecoderTest : public QuicTestWithParam<FragmentMode> {
  protected:
   QpackDecoderTest()
-      : qpack_decoder_(kMaximumDynamicTableCapacity,
-                       kMaximumBlockedStreams,
+      : qpack_decoder_(kMaximumDynamicTableCapacity, kMaximumBlockedStreams,
                        &encoder_stream_error_delegate_),
         fragment_mode_(GetParam()) {
     qpack_decoder_.set_qpack_stream_sender_delegate(
@@ -108,8 +107,7 @@
   std::unique_ptr<QpackProgressiveDecoder> progressive_decoder_;
 };
 
-INSTANTIATE_TEST_SUITE_P(All,
-                         QpackDecoderTest,
+INSTANTIATE_TEST_SUITE_P(All, QpackDecoderTest,
                          Values(FragmentMode::kSingleChunk,
                                 FragmentMode::kOctetByOctet));
 
diff --git a/quiche/quic/core/qpack/qpack_encoder.cc b/quiche/quic/core/qpack/qpack_encoder.cc
index db3f803..f70fda4 100644
--- a/quiche/quic/core/qpack/qpack_encoder.cc
+++ b/quiche/quic/core/qpack/qpack_encoder.cc
@@ -43,8 +43,7 @@
 
 // static
 QpackEncoder::Representation QpackEncoder::EncodeIndexedHeaderField(
-    bool is_static,
-    uint64_t index,
+    bool is_static, uint64_t index,
     QpackBlockingManager::IndexSet* referred_indices) {
   // Add |index| to |*referred_indices| only if entry is in the dynamic table.
   if (!is_static) {
@@ -56,9 +55,7 @@
 // static
 QpackEncoder::Representation
 QpackEncoder::EncodeLiteralHeaderFieldWithNameReference(
-    bool is_static,
-    uint64_t index,
-    absl::string_view value,
+    bool is_static, uint64_t index, absl::string_view value,
     QpackBlockingManager::IndexSet* referred_indices) {
   // Add |index| to |*referred_indices| only if entry is in the dynamic table.
   if (!is_static) {
@@ -70,14 +67,12 @@
 
 // static
 QpackEncoder::Representation QpackEncoder::EncodeLiteralHeaderField(
-    absl::string_view name,
-    absl::string_view value) {
+    absl::string_view name, absl::string_view value) {
   return Representation::LiteralHeaderField(name, value);
 }
 
 QpackEncoder::Representations QpackEncoder::FirstPassEncode(
-    QuicStreamId stream_id,
-    const spdy::Http2HeaderBlock& header_list,
+    QuicStreamId stream_id, const spdy::Http2HeaderBlock& header_list,
     QpackBlockingManager::IndexSet* referred_indices,
     QuicByteCount* encoder_stream_sent_byte_count) {
   // If previous instructions are buffered in |encoder_stream_sender_|,
@@ -369,8 +364,7 @@
 }
 
 std::string QpackEncoder::EncodeHeaderList(
-    QuicStreamId stream_id,
-    const spdy::Http2HeaderBlock& header_list,
+    QuicStreamId stream_id, const spdy::Http2HeaderBlock& header_list,
     QuicByteCount* encoder_stream_sent_byte_count) {
   // Keep track of all dynamic table indices that this header block refers to so
   // that it can be passed to QpackBlockingManager.
diff --git a/quiche/quic/core/qpack/qpack_encoder.h b/quiche/quic/core/qpack/qpack_encoder.h
index fedf628..a47e925 100644
--- a/quiche/quic/core/qpack/qpack_encoder.h
+++ b/quiche/quic/core/qpack/qpack_encoder.h
@@ -111,16 +111,13 @@
   // Generate indexed header field representation
   // and optionally update |*referred_indices|.
   static Representation EncodeIndexedHeaderField(
-      bool is_static,
-      uint64_t index,
+      bool is_static, uint64_t index,
       QpackBlockingManager::IndexSet* referred_indices);
 
   // Generate literal header field with name reference representation
   // and optionally update |*referred_indices|.
   static Representation EncodeLiteralHeaderFieldWithNameReference(
-      bool is_static,
-      uint64_t index,
-      absl::string_view value,
+      bool is_static, uint64_t index, absl::string_view value,
       QpackBlockingManager::IndexSet* referred_indices);
 
   // Generate literal header field representation.
@@ -139,8 +136,7 @@
   // absolute indices.  Returned representation objects may have
   // absl::string_views pointing to strings owned by |*header_list|.
   Representations FirstPassEncode(
-      QuicStreamId stream_id,
-      const spdy::Http2HeaderBlock& header_list,
+      QuicStreamId stream_id, const spdy::Http2HeaderBlock& header_list,
       QpackBlockingManager::IndexSet* referred_indices,
       QuicByteCount* encoder_stream_sent_byte_count);
 
diff --git a/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h b/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h
index 879c1b4..6db91e1 100644
--- a/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h
+++ b/quiche/quic/core/qpack/qpack_encoder_stream_receiver.h
@@ -28,8 +28,7 @@
     virtual ~Delegate() = default;
 
     // 5.2.1. Insert With Name Reference
-    virtual void OnInsertWithNameReference(bool is_static,
-                                           uint64_t name_index,
+    virtual void OnInsertWithNameReference(bool is_static, uint64_t name_index,
                                            absl::string_view value) = 0;
     // 5.2.2. Insert Without Name Reference
     virtual void OnInsertWithoutNameReference(absl::string_view name,
diff --git a/quiche/quic/core/qpack/qpack_encoder_stream_receiver_test.cc b/quiche/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
index 77103df..5ab7042 100644
--- a/quiche/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
+++ b/quiche/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
@@ -19,18 +19,14 @@
  public:
   ~MockDelegate() override = default;
 
-  MOCK_METHOD(void,
-              OnInsertWithNameReference,
+  MOCK_METHOD(void, OnInsertWithNameReference,
               (bool is_static, uint64_t name_index, absl::string_view value),
               (override));
-  MOCK_METHOD(void,
-              OnInsertWithoutNameReference,
-              (absl::string_view name, absl::string_view value),
-              (override));
+  MOCK_METHOD(void, OnInsertWithoutNameReference,
+              (absl::string_view name, absl::string_view value), (override));
   MOCK_METHOD(void, OnDuplicate, (uint64_t index), (override));
   MOCK_METHOD(void, OnSetDynamicTableCapacity, (uint64_t capacity), (override));
-  MOCK_METHOD(void,
-              OnErrorDetected,
+  MOCK_METHOD(void, OnErrorDetected,
               (QuicErrorCode error_code, absl::string_view error_message),
               (override));
 };
diff --git a/quiche/quic/core/qpack/qpack_encoder_stream_sender.cc b/quiche/quic/core/qpack/qpack_encoder_stream_sender.cc
index e9e64b3..574b3bb 100644
--- a/quiche/quic/core/qpack/qpack_encoder_stream_sender.cc
+++ b/quiche/quic/core/qpack/qpack_encoder_stream_sender.cc
@@ -25,9 +25,7 @@
 QpackEncoderStreamSender::QpackEncoderStreamSender() : delegate_(nullptr) {}
 
 void QpackEncoderStreamSender::SendInsertWithNameReference(
-    bool is_static,
-    uint64_t name_index,
-    absl::string_view value) {
+    bool is_static, uint64_t name_index, absl::string_view value) {
   instruction_encoder_.Encode(
       QpackInstructionWithValues::InsertWithNameReference(is_static, name_index,
                                                           value),
@@ -35,8 +33,7 @@
 }
 
 void QpackEncoderStreamSender::SendInsertWithoutNameReference(
-    absl::string_view name,
-    absl::string_view value) {
+    absl::string_view name, absl::string_view value) {
   instruction_encoder_.Encode(
       QpackInstructionWithValues::InsertWithoutNameReference(name, value),
       &buffer_);
diff --git a/quiche/quic/core/qpack/qpack_encoder_stream_sender.h b/quiche/quic/core/qpack/qpack_encoder_stream_sender.h
index 8ad5a13..ab53a1d 100644
--- a/quiche/quic/core/qpack/qpack_encoder_stream_sender.h
+++ b/quiche/quic/core/qpack/qpack_encoder_stream_sender.h
@@ -27,8 +27,7 @@
   // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#rfc.section.5.2
 
   // 5.2.1. Insert With Name Reference
-  void SendInsertWithNameReference(bool is_static,
-                                   uint64_t name_index,
+  void SendInsertWithNameReference(bool is_static, uint64_t name_index,
                                    absl::string_view value);
   // 5.2.2. Insert Without Name Reference
   void SendInsertWithoutNameReference(absl::string_view name,
diff --git a/quiche/quic/core/qpack/qpack_header_table.cc b/quiche/quic/core/qpack/qpack_header_table.cc
index fb2c76b..d0386f2 100644
--- a/quiche/quic/core/qpack/qpack_header_table.cc
+++ b/quiche/quic/core/qpack/qpack_header_table.cc
@@ -51,9 +51,7 @@
 }
 
 QpackEncoderHeaderTable::MatchType QpackEncoderHeaderTable::FindHeaderField(
-    absl::string_view name,
-    absl::string_view value,
-    bool* is_static,
+    absl::string_view name, absl::string_view value, bool* is_static,
     uint64_t* index) const {
   QpackLookupEntry query{name, value};
 
diff --git a/quiche/quic/core/qpack/qpack_header_table.h b/quiche/quic/core/qpack/qpack_header_table.h
index 2bbce45..f882e75 100644
--- a/quiche/quic/core/qpack/qpack_header_table.h
+++ b/quiche/quic/core/qpack/qpack_header_table.h
@@ -149,8 +149,7 @@
 
 template <typename DynamicEntryTable>
 bool QpackHeaderTableBase<DynamicEntryTable>::EntryFitsDynamicTableCapacity(
-    absl::string_view name,
-    absl::string_view value) const {
+    absl::string_view name, absl::string_view value) const {
   return QpackEntry::Size(name, value) <= dynamic_table_capacity_;
 }
 
@@ -178,8 +177,7 @@
 
 template <typename DynamicEntryTable>
 uint64_t QpackHeaderTableBase<DynamicEntryTable>::InsertEntry(
-    absl::string_view name,
-    absl::string_view value) {
+    absl::string_view name, absl::string_view value) {
   QUICHE_DCHECK(EntryFitsDynamicTableCapacity(name, value));
 
   const uint64_t index = dropped_entry_count_ + dynamic_entries_.size();
@@ -259,10 +257,8 @@
   // Returns the absolute index of an entry with matching name and value if such
   // exists, otherwise one with matching name is such exists.  |index| is zero
   // based for both the static and the dynamic table.
-  MatchType FindHeaderField(absl::string_view name,
-                            absl::string_view value,
-                            bool* is_static,
-                            uint64_t* index) const;
+  MatchType FindHeaderField(absl::string_view name, absl::string_view value,
+                            bool* is_static, uint64_t* index) const;
 
   // Returns the size of the largest entry that could be inserted into the
   // dynamic table without evicting entry |index|.  |index| might be larger than
diff --git a/quiche/quic/core/qpack/qpack_header_table_test.cc b/quiche/quic/core/qpack/qpack_header_table_test.cc
index 82dd39b..3450e66 100644
--- a/quiche/quic/core/qpack/qpack_header_table_test.cc
+++ b/quiche/quic/core/qpack/qpack_header_table_test.cc
@@ -97,11 +97,9 @@
  protected:
   ~QpackEncoderHeaderTableTest() override = default;
 
-  void ExpectMatch(absl::string_view name,
-                   absl::string_view value,
+  void ExpectMatch(absl::string_view name, absl::string_view value,
                    QpackEncoderHeaderTable::MatchType expected_match_type,
-                   bool expected_is_static,
-                   uint64_t expected_index) const {
+                   bool expected_is_static, uint64_t expected_index) const {
     // Initialize outparams to a value different from the expected to ensure
     // that FindHeaderField() sets them.
     bool is_static = !expected_is_static;
@@ -410,8 +408,7 @@
  protected:
   ~QpackDecoderHeaderTableTest() override = default;
 
-  void ExpectEntryAtIndex(bool is_static,
-                          uint64_t index,
+  void ExpectEntryAtIndex(bool is_static, uint64_t index,
                           absl::string_view expected_name,
                           absl::string_view expected_value) const {
     const auto* entry = table_.LookupEntry(is_static, index);
diff --git a/quiche/quic/core/qpack/qpack_index_conversions.cc b/quiche/quic/core/qpack/qpack_index_conversions.cc
index b71d024..a54bfcd 100644
--- a/quiche/quic/core/qpack/qpack_index_conversions.cc
+++ b/quiche/quic/core/qpack/qpack_index_conversions.cc
@@ -11,8 +11,7 @@
 namespace quic {
 
 uint64_t QpackAbsoluteIndexToEncoderStreamRelativeIndex(
-    uint64_t absolute_index,
-    uint64_t inserted_entry_count) {
+    uint64_t absolute_index, uint64_t inserted_entry_count) {
   QUICHE_DCHECK_LT(absolute_index, inserted_entry_count);
 
   return inserted_entry_count - absolute_index - 1;
@@ -26,8 +25,7 @@
 }
 
 bool QpackEncoderStreamRelativeIndexToAbsoluteIndex(
-    uint64_t relative_index,
-    uint64_t inserted_entry_count,
+    uint64_t relative_index, uint64_t inserted_entry_count,
     uint64_t* absolute_index) {
   if (relative_index >= inserted_entry_count) {
     return false;
@@ -48,8 +46,7 @@
   return true;
 }
 
-bool QpackPostBaseIndexToAbsoluteIndex(uint64_t post_base_index,
-                                       uint64_t base,
+bool QpackPostBaseIndexToAbsoluteIndex(uint64_t post_base_index, uint64_t base,
                                        uint64_t* absolute_index) {
   if (post_base_index >= std::numeric_limits<uint64_t>::max() - base) {
     return false;
diff --git a/quiche/quic/core/qpack/qpack_index_conversions.h b/quiche/quic/core/qpack/qpack_index_conversions.h
index d5d02c8..ddd51cf 100644
--- a/quiche/quic/core/qpack/qpack_index_conversions.h
+++ b/quiche/quic/core/qpack/qpack_index_conversions.h
@@ -24,35 +24,28 @@
 // 32 bytes), overflow is not possible.  The caller is responsible for providing
 // input that does not underflow.
 
-QUIC_EXPORT_PRIVATE uint64_t
-QpackAbsoluteIndexToEncoderStreamRelativeIndex(uint64_t absolute_index,
-                                               uint64_t inserted_entry_count);
+QUIC_EXPORT_PRIVATE uint64_t QpackAbsoluteIndexToEncoderStreamRelativeIndex(
+    uint64_t absolute_index, uint64_t inserted_entry_count);
 
-QUIC_EXPORT_PRIVATE uint64_t
-QpackAbsoluteIndexToRequestStreamRelativeIndex(uint64_t absolute_index,
-                                               uint64_t base);
+QUIC_EXPORT_PRIVATE uint64_t QpackAbsoluteIndexToRequestStreamRelativeIndex(
+    uint64_t absolute_index, uint64_t base);
 
 // Conversion functions used in the decoder operate on input received from the
 // network.  These functions return false on overflow or underflow.
 
 QUIC_EXPORT_PRIVATE bool QpackEncoderStreamRelativeIndexToAbsoluteIndex(
-    uint64_t relative_index,
-    uint64_t inserted_entry_count,
+    uint64_t relative_index, uint64_t inserted_entry_count,
     uint64_t* absolute_index);
 
 // On success, |*absolute_index| is guaranteed to be strictly less than
 // std::numeric_limits<uint64_t>::max().
 QUIC_EXPORT_PRIVATE bool QpackRequestStreamRelativeIndexToAbsoluteIndex(
-    uint64_t relative_index,
-    uint64_t base,
-    uint64_t* absolute_index);
+    uint64_t relative_index, uint64_t base, uint64_t* absolute_index);
 
 // On success, |*absolute_index| is guaranteed to be strictly less than
 // std::numeric_limits<uint64_t>::max().
 QUIC_EXPORT_PRIVATE bool QpackPostBaseIndexToAbsoluteIndex(
-    uint64_t post_base_index,
-    uint64_t base,
-    uint64_t* absolute_index);
+    uint64_t post_base_index, uint64_t base, uint64_t* absolute_index);
 
 }  // namespace quic
 
diff --git a/quiche/quic/core/qpack/qpack_instruction_decoder.h b/quiche/quic/core/qpack/qpack_instruction_decoder.h
index e8aa5ef..c848b3d 100644
--- a/quiche/quic/core/qpack/qpack_instruction_decoder.h
+++ b/quiche/quic/core/qpack/qpack_instruction_decoder.h
@@ -49,8 +49,7 @@
     // Implementations are allowed to destroy the QpackInstructionDecoder
     // instance synchronously.
     virtual void OnInstructionDecodingError(
-        ErrorCode error_code,
-        absl::string_view error_message) = 0;
+        ErrorCode error_code, absl::string_view error_message) = 0;
   };
 
   // Both |*language| and |*delegate| must outlive this object.
diff --git a/quiche/quic/core/qpack/qpack_instruction_decoder_test.cc b/quiche/quic/core/qpack/qpack_instruction_decoder_test.cc
index d5c753d..1a2aa2c 100644
--- a/quiche/quic/core/qpack/qpack_instruction_decoder_test.cc
+++ b/quiche/quic/core/qpack/qpack_instruction_decoder_test.cc
@@ -61,12 +61,9 @@
   MockDelegate& operator=(const MockDelegate&) = delete;
   ~MockDelegate() override = default;
 
-  MOCK_METHOD(bool,
-              OnInstructionDecoded,
-              (const QpackInstruction*),
+  MOCK_METHOD(bool, OnInstructionDecoded, (const QpackInstruction*),
               (override));
-  MOCK_METHOD(void,
-              OnInstructionDecodingError,
+  MOCK_METHOD(void, OnInstructionDecodingError,
               (QpackInstructionDecoder::ErrorCode error_code,
                absl::string_view error_message),
               (override));
@@ -123,8 +120,7 @@
   const FragmentMode fragment_mode_;
 };
 
-INSTANTIATE_TEST_SUITE_P(All,
-                         QpackInstructionDecoderTest,
+INSTANTIATE_TEST_SUITE_P(All, QpackInstructionDecoderTest,
                          Values(FragmentMode::kSingleChunk,
                                 FragmentMode::kOctetByOctet));
 
diff --git a/quiche/quic/core/qpack/qpack_instruction_encoder.cc b/quiche/quic/core/qpack/qpack_instruction_encoder.cc
index 2922c00..21f549c 100644
--- a/quiche/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quiche/quic/core/qpack/qpack_instruction_encoder.cc
@@ -100,8 +100,7 @@
   state_ = State::kStartField;
 }
 
-void QpackInstructionEncoder::DoVarintEncode(uint64_t varint,
-                                             uint64_t varint2,
+void QpackInstructionEncoder::DoVarintEncode(uint64_t varint, uint64_t varint2,
                                              std::string* output) {
   QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
                 field_->type == QpackInstructionFieldType::kVarint2 ||
diff --git a/quiche/quic/core/qpack/qpack_instruction_encoder.h b/quiche/quic/core/qpack/qpack_instruction_encoder.h
index 25f707a..9b7551d 100644
--- a/quiche/quic/core/qpack/qpack_instruction_encoder.h
+++ b/quiche/quic/core/qpack/qpack_instruction_encoder.h
@@ -54,8 +54,7 @@
   void DoSBit(bool s_bit);
   void DoVarintEncode(uint64_t varint, uint64_t varint2, std::string* output);
   void DoStartString(absl::string_view name, absl::string_view value);
-  void DoWriteString(absl::string_view name,
-                     absl::string_view value,
+  void DoWriteString(absl::string_view name, absl::string_view value,
                      std::string* output);
 
   // True if name or value should be Huffman encoded.
diff --git a/quiche/quic/core/qpack/qpack_instructions.cc b/quiche/quic/core/qpack/qpack_instructions.cc
index ee80897..9de0dcd 100644
--- a/quiche/quic/core/qpack/qpack_instructions.cc
+++ b/quiche/quic/core/qpack/qpack_instructions.cc
@@ -202,9 +202,7 @@
 
 // static
 QpackInstructionWithValues QpackInstructionWithValues::InsertWithNameReference(
-    bool is_static,
-    uint64_t name_index,
-    absl::string_view value) {
+    bool is_static, uint64_t name_index, absl::string_view value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ = InsertWithNameReferenceInstruction();
   instruction_with_values.s_bit_ = is_static;
@@ -217,8 +215,7 @@
 // static
 QpackInstructionWithValues
 QpackInstructionWithValues::InsertWithoutNameReference(
-    absl::string_view name,
-    absl::string_view value) {
+    absl::string_view name, absl::string_view value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ =
       InsertWithoutNameReferenceInstruction();
@@ -292,8 +289,7 @@
 
 // static
 QpackInstructionWithValues QpackInstructionWithValues::IndexedHeaderField(
-    bool is_static,
-    uint64_t index) {
+    bool is_static, uint64_t index) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ = QpackIndexedHeaderFieldInstruction();
   instruction_with_values.s_bit_ = is_static;
@@ -305,9 +301,7 @@
 // static
 QpackInstructionWithValues
 QpackInstructionWithValues::LiteralHeaderFieldNameReference(
-    bool is_static,
-    uint64_t index,
-    absl::string_view value) {
+    bool is_static, uint64_t index, absl::string_view value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ =
       QpackLiteralHeaderFieldNameReferenceInstruction();
@@ -320,8 +314,7 @@
 
 // static
 QpackInstructionWithValues QpackInstructionWithValues::LiteralHeaderField(
-    absl::string_view name,
-    absl::string_view value) {
+    absl::string_view name, absl::string_view value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ = QpackLiteralHeaderFieldInstruction();
   instruction_with_values.name_ = name;
diff --git a/quiche/quic/core/qpack/qpack_instructions.h b/quiche/quic/core/qpack/qpack_instructions.h
index e66651e..212f093 100644
--- a/quiche/quic/core/qpack/qpack_instructions.h
+++ b/quiche/quic/core/qpack/qpack_instructions.h
@@ -149,12 +149,9 @@
  public:
   // 5.2 Encoder stream instructions
   static QpackInstructionWithValues InsertWithNameReference(
-      bool is_static,
-      uint64_t name_index,
-      absl::string_view value);
+      bool is_static, uint64_t name_index, absl::string_view value);
   static QpackInstructionWithValues InsertWithoutNameReference(
-      absl::string_view name,
-      absl::string_view value);
+      absl::string_view name, absl::string_view value);
   static QpackInstructionWithValues Duplicate(uint64_t index);
   static QpackInstructionWithValues SetDynamicTableCapacity(uint64_t capacity);
 
@@ -170,9 +167,7 @@
   static QpackInstructionWithValues IndexedHeaderField(bool is_static,
                                                        uint64_t index);
   static QpackInstructionWithValues LiteralHeaderFieldNameReference(
-      bool is_static,
-      uint64_t index,
-      absl::string_view value);
+      bool is_static, uint64_t index, absl::string_view value);
   static QpackInstructionWithValues LiteralHeaderField(absl::string_view name,
                                                        absl::string_view value);
 
diff --git a/quiche/quic/core/qpack/qpack_progressive_decoder.cc b/quiche/quic/core/qpack/qpack_progressive_decoder.cc
index 1a326d5..7258128 100644
--- a/quiche/quic/core/qpack/qpack_progressive_decoder.cc
+++ b/quiche/quic/core/qpack/qpack_progressive_decoder.cc
@@ -153,9 +153,7 @@
   }
 }
 
-void QpackProgressiveDecoder::Cancel() {
-  cancelled_ = true;
-}
+void QpackProgressiveDecoder::Cancel() { cancelled_ = true; }
 
 bool QpackProgressiveDecoder::DoIndexedHeaderFieldInstruction() {
   if (!instruction_decoder_.s_bit()) {
@@ -405,8 +403,7 @@
   handler_->OnDecodingErrorDetected(error_code, error_message);
 }
 
-bool QpackProgressiveDecoder::DeltaBaseToBase(bool sign,
-                                              uint64_t delta_base,
+bool QpackProgressiveDecoder::DeltaBaseToBase(bool sign, uint64_t delta_base,
                                               uint64_t* base) {
   if (sign) {
     if (delta_base == std::numeric_limits<uint64_t>::max() ||
diff --git a/quiche/quic/core/qpack/qpack_receive_stream.h b/quiche/quic/core/qpack/qpack_receive_stream.h
index 0509fae..20ad878 100644
--- a/quiche/quic/core/qpack/qpack_receive_stream.h
+++ b/quiche/quic/core/qpack/qpack_receive_stream.h
@@ -19,8 +19,7 @@
  public:
   // Construct receive stream from pending stream, the |pending| object needs
   // to be deleted after the construction.
-  QpackReceiveStream(PendingStream* pending,
-                     QuicSession* session,
+  QpackReceiveStream(PendingStream* pending, QuicSession* session,
                      QpackStreamReceiver* receiver);
   QpackReceiveStream(const QpackReceiveStream&) = delete;
   QpackReceiveStream& operator=(const QpackReceiveStream&) = delete;
diff --git a/quiche/quic/core/qpack/qpack_receive_stream_test.cc b/quiche/quic/core/qpack/qpack_receive_stream_test.cc
index c148510..4f94802 100644
--- a/quiche/quic/core/qpack/qpack_receive_stream_test.cc
+++ b/quiche/quic/core/qpack/qpack_receive_stream_test.cc
@@ -51,9 +51,7 @@
  public:
   QpackReceiveStreamTest()
       : connection_(new StrictMock<MockQuicConnection>(
-            &helper_,
-            &alarm_factory_,
-            perspective(),
+            &helper_, &alarm_factory_, perspective(),
             SupportedVersions(GetParam().version))),
         session_(connection_) {
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
@@ -79,8 +77,7 @@
   QpackReceiveStream* qpack_receive_stream_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QpackReceiveStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QpackReceiveStreamTest,
                          ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QpackReceiveStreamTest, ResetQpackReceiveStream) {
diff --git a/quiche/quic/core/qpack/qpack_required_insert_count.h b/quiche/quic/core/qpack/qpack_required_insert_count.h
index f20c759..762dfb1 100644
--- a/quiche/quic/core/qpack/qpack_required_insert_count.h
+++ b/quiche/quic/core/qpack/qpack_required_insert_count.h
@@ -14,19 +14,16 @@
 // Calculate Encoded Required Insert Count from Required Insert Count and
 // MaxEntries according to
 // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#ric.
-QUIC_EXPORT_PRIVATE uint64_t
-QpackEncodeRequiredInsertCount(uint64_t required_insert_count,
-                               uint64_t max_entries);
+QUIC_EXPORT_PRIVATE uint64_t QpackEncodeRequiredInsertCount(
+    uint64_t required_insert_count, uint64_t max_entries);
 
 // Calculate Required Insert Count from Encoded Required Insert Count,
 // MaxEntries, and total number of dynamic table insertions according to
 // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#ric.  Returns true
 // on success, false on invalid input or overflow/underflow.
 QUIC_EXPORT_PRIVATE bool QpackDecodeRequiredInsertCount(
-    uint64_t encoded_required_insert_count,
-    uint64_t max_entries,
-    uint64_t total_number_of_inserts,
-    uint64_t* required_insert_count);
+    uint64_t encoded_required_insert_count, uint64_t max_entries,
+    uint64_t total_number_of_inserts, uint64_t* required_insert_count);
 
 }  // namespace quic
 
diff --git a/quiche/quic/core/qpack/qpack_round_trip_test.cc b/quiche/quic/core/qpack/qpack_round_trip_test.cc
index d729793..00a18c5 100644
--- a/quiche/quic/core/qpack/qpack_round_trip_test.cc
+++ b/quiche/quic/core/qpack/qpack_round_trip_test.cc
@@ -49,8 +49,7 @@
   }
 };
 
-INSTANTIATE_TEST_SUITE_P(All,
-                         QpackRoundTripTest,
+INSTANTIATE_TEST_SUITE_P(All, QpackRoundTripTest,
                          Values(FragmentMode::kSingleChunk,
                                 FragmentMode::kOctetByOctet));
 
diff --git a/quiche/quic/core/qpack/qpack_send_stream.cc b/quiche/quic/core/qpack/qpack_send_stream.cc
index c7be858..9616c1a 100644
--- a/quiche/quic/core/qpack/qpack_send_stream.cc
+++ b/quiche/quic/core/qpack/qpack_send_stream.cc
@@ -9,8 +9,7 @@
 #include "quiche/quic/core/quic_session.h"
 
 namespace quic {
-QpackSendStream::QpackSendStream(QuicStreamId id,
-                                 QuicSession* session,
+QpackSendStream::QpackSendStream(QuicStreamId id, QuicSession* session,
                                  uint64_t http3_stream_type)
     : QuicStream(id, session, /*is_static = */ true, WRITE_UNIDIRECTIONAL),
       http3_stream_type_(http3_stream_type),
diff --git a/quiche/quic/core/qpack/qpack_send_stream.h b/quiche/quic/core/qpack/qpack_send_stream.h
index 51cb25f..2d8f3f1 100644
--- a/quiche/quic/core/qpack/qpack_send_stream.h
+++ b/quiche/quic/core/qpack/qpack_send_stream.h
@@ -23,8 +23,7 @@
  public:
   // |session| can't be nullptr, and the ownership is not passed. |session| owns
   // this stream.
-  QpackSendStream(QuicStreamId id,
-                  QuicSession* session,
+  QpackSendStream(QuicStreamId id, QuicSession* session,
                   uint64_t http3_stream_type);
   QpackSendStream(const QpackSendStream&) = delete;
   QpackSendStream& operator=(const QpackSendStream&) = delete;
diff --git a/quiche/quic/core/qpack/qpack_send_stream_test.cc b/quiche/quic/core/qpack/qpack_send_stream_test.cc
index 40d679d..4f0cc2a 100644
--- a/quiche/quic/core/qpack/qpack_send_stream_test.cc
+++ b/quiche/quic/core/qpack/qpack_send_stream_test.cc
@@ -63,9 +63,7 @@
  public:
   QpackSendStreamTest()
       : connection_(new StrictMock<MockQuicConnection>(
-            &helper_,
-            &alarm_factory_,
-            perspective(),
+            &helper_, &alarm_factory_, perspective(),
             SupportedVersions(GetParam().version))),
         session_(connection_) {
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
@@ -99,8 +97,7 @@
   QpackSendStream* qpack_send_stream_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QpackSendStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests, QpackSendStreamTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
diff --git a/quiche/quic/core/qpack/value_splitting_header_list.cc b/quiche/quic/core/qpack/value_splitting_header_list.cc
index 41fd4c0..faeccdf 100644
--- a/quiche/quic/core/qpack/value_splitting_header_list.cc
+++ b/quiche/quic/core/qpack/value_splitting_header_list.cc
@@ -54,11 +54,11 @@
 }
 
 const ValueSplittingHeaderList::value_type&
-    ValueSplittingHeaderList::const_iterator::operator*() const {
+ValueSplittingHeaderList::const_iterator::operator*() const {
   return header_field_;
 }
 const ValueSplittingHeaderList::value_type*
-    ValueSplittingHeaderList::const_iterator::operator->() const {
+ValueSplittingHeaderList::const_iterator::operator->() const {
   return &header_field_;
 }