diff --git a/quiche/quic/core/http/quic_header_list.cc b/quiche/quic/core/http/quic_header_list.cc
index 771e617..5751683 100644
--- a/quiche/quic/core/http/quic_header_list.cc
+++ b/quiche/quic/core/http/quic_header_list.cc
@@ -14,51 +14,18 @@
 
 namespace quic {
 
-QuicHeaderList::QuicHeaderList()
-    : max_header_list_size_(std::numeric_limits<size_t>::max()),
-      current_header_list_size_(0),
-      uncompressed_header_bytes_(0),
-      compressed_header_bytes_(0) {}
-
-QuicHeaderList::QuicHeaderList(QuicHeaderList&& other) = default;
-
-QuicHeaderList::QuicHeaderList(const QuicHeaderList& other) = default;
-
-QuicHeaderList& QuicHeaderList::operator=(const QuicHeaderList& other) =
-    default;
-
-QuicHeaderList& QuicHeaderList::operator=(QuicHeaderList&& other) = default;
-
-QuicHeaderList::~QuicHeaderList() {}
-
-void QuicHeaderList::OnHeaderBlockStart() {
-  QUIC_BUG_IF(quic_bug_12518_1, current_header_list_size_ != 0)
-      << "OnHeaderBlockStart called more than once!";
-}
-
 void QuicHeaderList::OnHeader(absl::string_view name, absl::string_view value) {
-  // Avoid infinite buffering of headers. No longer store headers
-  // once the current headers are over the limit.
-  if (current_header_list_size_ < max_header_list_size_) {
-    current_header_list_size_ += name.size();
-    current_header_list_size_ += value.size();
-    current_header_list_size_ += kQpackEntrySizeOverhead;
-    header_list_.emplace_back(std::string(name), std::string(value));
-  }
+  header_list_.emplace_back(std::string(name), std::string(value));
 }
 
 void QuicHeaderList::OnHeaderBlockEnd(size_t uncompressed_header_bytes,
                                       size_t compressed_header_bytes) {
   uncompressed_header_bytes_ = uncompressed_header_bytes;
   compressed_header_bytes_ = compressed_header_bytes;
-  if (current_header_list_size_ > max_header_list_size_) {
-    Clear();
-  }
 }
 
 void QuicHeaderList::Clear() {
   header_list_.clear();
-  current_header_list_size_ = 0;
   uncompressed_header_bytes_ = 0;
   compressed_header_bytes_ = 0;
 }
diff --git a/quiche/quic/core/http/quic_header_list.h b/quiche/quic/core/http/quic_header_list.h
index 51c2a82..ac64cec 100644
--- a/quiche/quic/core/http/quic_header_list.h
+++ b/quiche/quic/core/http/quic_header_list.h
@@ -19,25 +19,23 @@
 namespace quic {
 
 // A simple class that accumulates header pairs
-class QUICHE_EXPORT QuicHeaderList : public spdy::SpdyHeadersHandlerInterface {
+class QUICHE_EXPORT QuicHeaderList {
  public:
   using ListType =
       quiche::QuicheCircularDeque<std::pair<std::string, std::string>>;
   using value_type = ListType::value_type;
   using const_iterator = ListType::const_iterator;
 
-  QuicHeaderList();
-  QuicHeaderList(QuicHeaderList&& other);
-  QuicHeaderList(const QuicHeaderList& other);
-  QuicHeaderList& operator=(QuicHeaderList&& other);
-  QuicHeaderList& operator=(const QuicHeaderList& other);
-  ~QuicHeaderList() override;
+  QuicHeaderList() = default;
+  QuicHeaderList(QuicHeaderList&& other) = default;
+  QuicHeaderList(const QuicHeaderList& other) = default;
+  QuicHeaderList& operator=(QuicHeaderList&& other) = default;
+  QuicHeaderList& operator=(const QuicHeaderList& other) = default;
 
-  // From SpdyHeadersHandlerInteface.
-  void OnHeaderBlockStart() override;
-  void OnHeader(absl::string_view name, absl::string_view value) override;
+  void OnHeaderBlockStart() {}
+  void OnHeader(absl::string_view name, absl::string_view value);
   void OnHeaderBlockEnd(size_t uncompressed_header_bytes,
-                        size_t compressed_header_bytes) override;
+                        size_t compressed_header_bytes);
 
   void Clear();
 
@@ -50,28 +48,13 @@
   }
   size_t compressed_header_bytes() const { return compressed_header_bytes_; }
 
-  // Deprecated.  TODO(b/145909215): remove.
-  void set_max_header_list_size(size_t max_header_list_size) {
-    max_header_list_size_ = max_header_list_size;
-  }
-
   std::string DebugString() const;
 
  private:
   quiche::QuicheCircularDeque<std::pair<std::string, std::string>> header_list_;
 
-  // The limit on the size of the header list (defined by spec as name + value +
-  // overhead for each header field). Headers over this limit will not be
-  // buffered, and the list will be cleared upon OnHeaderBlockEnd.
-  size_t max_header_list_size_;
-
-  // Defined per the spec as the size of all header fields with an additional
-  // overhead for each field.
-  size_t current_header_list_size_;
-
-  // TODO(dahollings) Are these fields necessary?
-  size_t uncompressed_header_bytes_;
-  size_t compressed_header_bytes_;
+  size_t uncompressed_header_bytes_ = 0;
+  size_t compressed_header_bytes_ = 0;
 };
 
 inline bool operator==(const QuicHeaderList& l1, const QuicHeaderList& l2) {
diff --git a/quiche/quic/core/http/quic_header_list_test.cc b/quiche/quic/core/http/quic_header_list_test.cc
index 573aae5..e13e254 100644
--- a/quiche/quic/core/http/quic_header_list_test.cc
+++ b/quiche/quic/core/http/quic_header_list_test.cc
@@ -36,37 +36,6 @@
   EXPECT_EQ("{ foo=bar, april=fools, beep=, }", headers.DebugString());
 }
 
-TEST_F(QuicHeaderListTest, TooLarge) {
-  const size_t kMaxHeaderListSize = 256;
-
-  QuicHeaderList headers;
-  headers.set_max_header_list_size(kMaxHeaderListSize);
-  std::string key = "key";
-  std::string value(kMaxHeaderListSize, '1');
-  // Send a header that exceeds max_header_list_size.
-  headers.OnHeader(key, value);
-  // Send a second header exceeding max_header_list_size.
-  headers.OnHeader(key + "2", value);
-  // We should not allocate more memory after exceeding max_header_list_size.
-  EXPECT_LT(headers.DebugString().size(), 2 * value.size());
-  size_t total_bytes = 2 * (key.size() + value.size()) + 1;
-  headers.OnHeaderBlockEnd(total_bytes, total_bytes);
-
-  EXPECT_TRUE(headers.empty());
-  EXPECT_EQ("{ }", headers.DebugString());
-}
-
-TEST_F(QuicHeaderListTest, NotTooLarge) {
-  QuicHeaderList headers;
-  headers.set_max_header_list_size(1 << 20);
-  std::string key = "key";
-  std::string value(1 << 18, '1');
-  headers.OnHeader(key, value);
-  size_t total_bytes = key.size() + value.size();
-  headers.OnHeaderBlockEnd(total_bytes, total_bytes);
-  EXPECT_FALSE(headers.empty());
-}
-
 // This test verifies that QuicHeaderList is copyable and assignable.
 TEST_F(QuicHeaderListTest, IsCopyableAndAssignable) {
   QuicHeaderList headers;
diff --git a/quiche/quic/core/http/quic_spdy_session.cc b/quiche/quic/core/http/quic_spdy_session.cc
index 8c81b3c..d53a4b2 100644
--- a/quiche/quic/core/http/quic_spdy_session.cc
+++ b/quiche/quic/core/http/quic_spdy_session.cc
@@ -198,10 +198,62 @@
   return kDefaultQpackMaxDynamicTableCapacity;
 }
 
+// This class is only used in gQUIC.
+class SizeLimitingHeaderList : public spdy::SpdyHeadersHandlerInterface {
+ public:
+  ~SizeLimitingHeaderList() override = default;
+
+  void OnHeaderBlockStart() override {
+    QUIC_BUG_IF(quic_bug_12518_1, current_header_list_size_ != 0)
+        << "OnHeaderBlockStart called more than once!";
+  }
+
+  void OnHeader(absl::string_view name, absl::string_view value) override {
+    if (current_header_list_size_ < max_header_list_size_) {
+      current_header_list_size_ += name.size();
+      current_header_list_size_ += value.size();
+      current_header_list_size_ += kQpackEntrySizeOverhead;
+      header_list_.OnHeader(name, value);
+    }
+  }
+
+  void OnHeaderBlockEnd(size_t uncompressed_header_bytes,
+                        size_t compressed_header_bytes) override {
+    header_list_.OnHeaderBlockEnd(uncompressed_header_bytes,
+                                  compressed_header_bytes);
+    if (current_header_list_size_ > max_header_list_size_) {
+      Clear();
+    }
+  }
+
+  void set_max_header_list_size(size_t max_header_list_size) {
+    max_header_list_size_ = max_header_list_size;
+  }
+
+  void Clear() {
+    header_list_.Clear();
+    current_header_list_size_ = 0;
+  }
+
+  const QuicHeaderList& header_list() const { return header_list_; }
+
+ private:
+  QuicHeaderList header_list_;
+
+  // The limit on the size of the header list (defined by spec as name + value +
+  // overhead for each header field). Headers over this limit will not be
+  // buffered, and the list will be cleared upon OnHeaderBlockEnd().
+  size_t max_header_list_size_ = std::numeric_limits<size_t>::max();
+
+  // The total size of headers so far, including overhead.
+  size_t current_header_list_size_ = 0;
+};
+
 }  // namespace
 
 // A SpdyFramerVisitor that passes HEADERS frames to the QuicSpdyStream, and
 // closes the connection if any unexpected frames are received.
+// This class is only used in gQUIC.
 class QuicSpdySession::SpdyFramerVisitor
     : public SpdyFramerVisitorInterface,
       public SpdyFramerDebugVisitorInterface {
@@ -221,12 +273,13 @@
 
     LogHeaderCompressionRatioHistogram(
         /* using_qpack = */ false,
-        /* is_sent = */ false, header_list_.compressed_header_bytes(),
-        header_list_.uncompressed_header_bytes());
+        /* is_sent = */ false,
+        header_list_.header_list().compressed_header_bytes(),
+        header_list_.header_list().uncompressed_header_bytes());
 
     // Ignore pushed request headers.
     if (session_->IsConnected() && !expecting_pushed_headers_) {
-      session_->OnHeaderList(header_list_);
+      session_->OnHeaderList(header_list_.header_list());
     }
     expecting_pushed_headers_ = false;
     header_list_.Clear();
@@ -464,7 +517,7 @@
   }
 
   QuicSpdySession* session_;
-  QuicHeaderList header_list_;
+  SizeLimitingHeaderList header_list_;
 
   // True if the next OnHeaderFrameEnd() call signals the end of pushed request
   // headers.