diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 270ab51..132139e 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -76,10 +76,11 @@
 #include "quiche/quic/tools/quic_simple_client_stream.h"
 #include "quiche/quic/tools/quic_simple_server_stream.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
+using spdy::Http2HeaderBlock;
 using spdy::kV3LowestPriority;
 using spdy::SpdyFramer;
-using spdy::SpdyHeaderBlock;
 using spdy::SpdySerializedFrame;
 using spdy::SpdySettingsIR;
 using ::testing::_;
@@ -178,7 +179,7 @@
 void WriteHeadersOnStream(QuicSpdyStream* stream) {
   // Since QuicSpdyStream uses QuicHeaderList::empty() to detect too large
   // headers, it also fails when receiving empty headers.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":authority"] = "test.example.com:443";
   headers[":path"] = "/path";
   headers[":method"] = "GET";
@@ -680,7 +681,7 @@
 
   bool CheckResponseHeaders(QuicTestClient* client,
                             const std::string& expected_status) {
-    const spdy::SpdyHeaderBlock* response_headers = client->response_headers();
+    const spdy::Http2HeaderBlock* response_headers = client->response_headers();
     auto it = response_headers->find(":status");
     if (it == response_headers->end()) {
       ADD_FAILURE() << "Did not find :status header in response";
@@ -768,7 +769,7 @@
       return nullptr;
     }
 
-    spdy::SpdyHeaderBlock headers;
+    spdy::Http2HeaderBlock headers;
     headers[":scheme"] = "https";
     headers[":authority"] = "localhost";
     headers[":path"] = path;
@@ -1306,7 +1307,7 @@
 
   // Start client2 which will use a good connection ID length.
   std::unique_ptr<QuicTestClient> client2(CreateQuicClient(nullptr));
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1418,7 +1419,7 @@
   ASSERT_TRUE(Initialize());
 
   // Send a request in two parts: the request and then an empty packet with FIN.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1461,7 +1462,7 @@
 
   const int kNumRequests = 10;
 
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1482,7 +1483,7 @@
   ASSERT_TRUE(Initialize());
   std::unique_ptr<QuicTestClient> client2(CreateQuicClient(nullptr));
 
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1527,7 +1528,7 @@
   ASSERT_TRUE(Initialize());
 
   // Add a content length header with no body.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1549,7 +1550,7 @@
 
   // 1 MB body.
   std::string body(1024 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1571,7 +1572,7 @@
 
   // 100 KB body.
   std::string body(100 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1595,7 +1596,7 @@
 
   // 10 KB body.
   std::string body(1024 * 10, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1639,7 +1640,7 @@
 
   // 10 KB body.
   std::string body(1024 * 10, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1663,7 +1664,7 @@
 
   // 10 KB body.
   std::string body(1024 * 10, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1682,7 +1683,7 @@
 
   // 1 MB body.
   std::string body(1024 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1854,7 +1855,7 @@
   ASSERT_TRUE(Initialize());
 
   std::string body(20480, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -1998,7 +1999,7 @@
   ASSERT_TRUE(Initialize());
 
   std::string body(20480, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -2113,7 +2114,7 @@
         EXPECT_TRUE(
             GetClientConnection()->framer().HasEncrypterOfEncryptionLevel(
                 ENCRYPTION_HANDSHAKE));
-        SpdyHeaderBlock headers;
+        Http2HeaderBlock headers;
         headers[":method"] = "POST";
         headers[":path"] = "/foo";
         headers[":scheme"] = "https";
@@ -2238,7 +2239,7 @@
 
   // 1 MB body.
   std::string body(1024 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -2298,7 +2299,7 @@
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
 
   std::string body(kMaxOutgoingPacketSize, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -2324,7 +2325,7 @@
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
 
   std::string body(kMaxOutgoingPacketSize, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -2353,7 +2354,7 @@
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
 
   std::string large_body(1024 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -2425,7 +2426,7 @@
   QuicSessionPeer::SetMaxOpenOutgoingStreams(client_session,
                                              kServerMaxStreams + 1);
 
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -3868,7 +3869,7 @@
 class TestResponseListener : public QuicSpdyClientBase::ResponseListener {
  public:
   void OnCompleteResponse(QuicStreamId id,
-                          const SpdyHeaderBlock& response_headers,
+                          const Http2HeaderBlock& response_headers,
                           const std::string& response_body) override {
     QUIC_DVLOG(1) << "response for stream " << id << " "
                   << response_headers.DebugString() << "\n"
@@ -3920,7 +3921,7 @@
   }
 
   // Create a POST request and send the headers only.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -4369,7 +4370,7 @@
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
   // Lose the request.
   SetPacketLossPercentage(100);
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -4401,7 +4402,7 @@
  protected:
   void SendErrorResponse() override {
     QUIC_DLOG(INFO) << "Sending error response for stream " << id();
-    SpdyHeaderBlock headers;
+    Http2HeaderBlock headers;
     headers[":status"] = "500";
     headers["content-length"] = absl::StrCat(response_body_.size());
     // This method must call CloseReadSide to cause the test case, StopReading
@@ -4643,7 +4644,7 @@
   // and before the body is received, due to invalid content-length.
   // Set an invalid content-length, so the request will receive an early 500
   // response.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/garbage";
   headers[":scheme"] = "https";
@@ -4692,11 +4693,11 @@
   // Add a response with headers, body, and trailers.
   const std::string kBody = "body content";
 
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":status"] = "200";
   headers["content-length"] = absl::StrCat(kBody.size());
 
-  SpdyHeaderBlock trailers;
+  Http2HeaderBlock trailers;
   trailers["some-trailing-header"] = "trailing-header-value";
 
   memory_cache_backend_.AddResponse(server_hostname_, "/trailer_url",
@@ -4729,7 +4730,7 @@
   ASSERT_LT(INT64_C(4294967296), request_body_size_bytes);
   std::string body(kSizeBytes, 'a');
 
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -4851,7 +4852,7 @@
 TEST_P(EndToEndTest, WayTooLongRequestHeaders) {
   ASSERT_TRUE(Initialize());
 
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "GET";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -4901,7 +4902,7 @@
   client_connection->set_debug_visitor(&observer);
   // 100KB body.
   std::string body(100 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -5022,7 +5023,7 @@
 
   // 1 MB body.
   std::string body(1024 * 1024, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -5150,7 +5151,7 @@
   // INCOMPLETE_RESPONSE will cause the server to not to send the trailer
   // (and the FIN) after the response body.
   std::string response_body(1305, 'a');
-  SpdyHeaderBlock response_headers;
+  Http2HeaderBlock response_headers;
   response_headers[":status"] = absl::StrCat(200);
   response_headers["content-length"] = absl::StrCat(response_body.length());
   memory_cache_backend_.AddSpecialResponse(
@@ -5732,7 +5733,7 @@
   client_->client()->Initialize();
 
   // Send a request before handshake finishes.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/bar";
   headers[":scheme"] = "https";
@@ -5752,7 +5753,7 @@
   ASSERT_TRUE(Initialize());
 
   // Send a request without a fin, to keep the stream open
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -5934,7 +5935,7 @@
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
 
   std::string body(kMaxOutgoingPacketSize, 'a');
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ -6549,7 +6550,7 @@
   EXPECT_TRUE(server_session->GetWebTransportSession(web_transport->id()) !=
               nullptr);
   server_thread_->Resume();
-  const spdy::SpdyHeaderBlock* response_headers = client_->response_headers();
+  const spdy::Http2HeaderBlock* response_headers = client_->response_headers();
   auto it = response_headers->find("bar");
   EXPECT_NE(it, response_headers->end());
   EXPECT_EQ(it->second, "baz");
@@ -6961,7 +6962,7 @@
     return;
   }
   // Missing :path header.
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":scheme"] = "https";
   headers[":authority"] = "localhost";
   headers[":method"] = "CONNECT";
@@ -6984,7 +6985,7 @@
     return;
   }
   // This extended CONNECT should be rejected.
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":scheme"] = "https";
   headers[":authority"] = "localhost";
   headers[":method"] = "CONNECT";
@@ -6996,7 +6997,7 @@
   CheckResponseHeaders("400");
 
   // Vanilla CONNECT should be sent to backend.
-  spdy::SpdyHeaderBlock headers2;
+  spdy::Http2HeaderBlock headers2;
   headers2[":authority"] = "localhost";
   headers2[":method"] = "CONNECT";
 
@@ -7012,7 +7013,7 @@
   SetQuicReloadableFlag(quic_act_upon_invalid_header, true);
   ASSERT_TRUE(Initialize());
 
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":scheme"] = "https";
   headers[":authority"] = "localhost";
   headers[":method"] = "GET";
@@ -7031,11 +7032,11 @@
   ASSERT_TRUE(Initialize());
 
   // Add a response with transfer-encoding headers.
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":status"] = "200";
   headers["transfer-encoding"] = "gzip";
 
-  SpdyHeaderBlock trailers;
+  Http2HeaderBlock trailers;
   trailers["some-trailing-header"] = "trailing-header-value";
 
   memory_cache_backend_.AddResponse(server_hostname_, "/eep",
@@ -7051,7 +7052,7 @@
   SetQuicReloadableFlag(quic_act_upon_invalid_header, true);
   ASSERT_TRUE(Initialize());
 
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":scheme"] = "https";
   headers[":authority"] = "localhost";
   headers[":method"] = "GET";
@@ -7068,7 +7069,7 @@
   SetQuicReloadableFlag(quic_act_upon_invalid_header, true);
   ASSERT_TRUE(Initialize());
 
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":scheme"] = "https";
   headers[":authority"] = "localhost";
   headers[":method"] = "GET";
diff --git a/quiche/quic/core/http/quic_client_promised_info.cc b/quiche/quic/core/http/quic_client_promised_info.cc
index 2567fde..db53585 100644
--- a/quiche/quic/core/http/quic_client_promised_info.cc
+++ b/quiche/quic/core/http/quic_client_promised_info.cc
@@ -11,7 +11,7 @@
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
@@ -42,10 +42,10 @@
       QuicTime::Delta::FromSeconds(kPushPromiseTimeoutSecs));
 }
 
-bool QuicClientPromisedInfo::OnPromiseHeaders(const SpdyHeaderBlock& headers) {
+bool QuicClientPromisedInfo::OnPromiseHeaders(const Http2HeaderBlock& headers) {
   // RFC7540, Section 8.2, requests MUST be safe [RFC7231], Section
   // 4.2.1.  GET and HEAD are the methods that are safe and required.
-  SpdyHeaderBlock::const_iterator it = headers.find(spdy::kHttp2MethodHeader);
+  Http2HeaderBlock::const_iterator it = headers.find(spdy::kHttp2MethodHeader);
   if (it == headers.end()) {
     QUIC_DVLOG(1) << "Promise for stream " << id_ << " has no method";
     Reset(QUIC_INVALID_PROMISE_METHOD);
@@ -72,8 +72,9 @@
   return true;
 }
 
-void QuicClientPromisedInfo::OnResponseHeaders(const SpdyHeaderBlock& headers) {
-  response_headers_ = std::make_unique<SpdyHeaderBlock>(headers.Clone());
+void QuicClientPromisedInfo::OnResponseHeaders(
+    const Http2HeaderBlock& headers) {
+  response_headers_ = std::make_unique<Http2HeaderBlock>(headers.Clone());
   if (client_request_delegate_) {
     // We already have a client request waiting.
     FinalValidation();
@@ -112,7 +113,7 @@
 }
 
 QuicAsyncStatus QuicClientPromisedInfo::HandleClientRequest(
-    const SpdyHeaderBlock& request_headers,
+    const Http2HeaderBlock& request_headers,
     QuicClientPushPromiseIndex::Delegate* delegate) {
   if (session_->IsClosedStream(id_)) {
     // There was a RST on the response stream.
diff --git a/quiche/quic/core/http/quic_client_promised_info.h b/quiche/quic/core/http/quic_client_promised_info.h
index 68eaecd..7b4f460 100644
--- a/quiche/quic/core/http/quic_client_promised_info.h
+++ b/quiche/quic/core/http/quic_client_promised_info.h
@@ -14,6 +14,7 @@
 #include "quiche/quic/core/quic_alarm.h"
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/platform/api/quic_export.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -39,15 +40,15 @@
   void Init();
 
   // Validate promise headers etc. Returns true if headers are valid.
-  bool OnPromiseHeaders(const spdy::SpdyHeaderBlock& headers);
+  bool OnPromiseHeaders(const spdy::Http2HeaderBlock& headers);
 
   // Store response, possibly proceed with final validation.
-  void OnResponseHeaders(const spdy::SpdyHeaderBlock& headers);
+  void OnResponseHeaders(const spdy::Http2HeaderBlock& headers);
 
   // Rendezvous between this promised stream and a client request that
   // has a matching URL.
   virtual QuicAsyncStatus HandleClientRequest(
-      const spdy::SpdyHeaderBlock& headers,
+      const spdy::Http2HeaderBlock& headers,
       QuicClientPushPromiseIndex::Delegate* delegate);
 
   void Cancel() override;
@@ -67,9 +68,9 @@
   // validation requires the response headers (for the actual Vary
   // field list), the promise headers (taking the role of the "cached"
   // request), and the client request headers.
-  spdy::SpdyHeaderBlock* request_headers() { return &request_headers_; }
+  spdy::Http2HeaderBlock* request_headers() { return &request_headers_; }
 
-  spdy::SpdyHeaderBlock* response_headers() { return response_headers_.get(); }
+  spdy::Http2HeaderBlock* response_headers() { return response_headers_.get(); }
 
   // After validation, client will use this to access the pushed stream.
 
@@ -99,9 +100,9 @@
   QuicSpdyClientSessionBase* session_;
   QuicStreamId id_;
   std::string url_;
-  spdy::SpdyHeaderBlock request_headers_;
-  std::unique_ptr<spdy::SpdyHeaderBlock> response_headers_;
-  spdy::SpdyHeaderBlock client_request_headers_;
+  spdy::Http2HeaderBlock request_headers_;
+  std::unique_ptr<spdy::Http2HeaderBlock> response_headers_;
+  spdy::Http2HeaderBlock client_request_headers_;
   QuicClientPushPromiseIndex::Delegate* client_request_delegate_;
 
   // The promise will commit suicide eventually if it is not claimed by a GET
diff --git a/quiche/quic/core/http/quic_client_promised_info_test.cc b/quiche/quic/core/http/quic_client_promised_info_test.cc
index 7636579..469c0c2 100644
--- a/quiche/quic/core/http/quic_client_promised_info_test.cc
+++ b/quiche/quic/core/http/quic_client_promised_info_test.cc
@@ -20,7 +20,7 @@
 #include "quiche/quic/test_tools/quic_spdy_session_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 using testing::_;
 using testing::StrictMock;
 
@@ -122,12 +122,12 @@
   std::unique_ptr<QuicSpdyClientStream> stream_;
   std::unique_ptr<StreamVisitor> stream_visitor_;
   std::unique_ptr<QuicSpdyClientStream> promised_stream_;
-  SpdyHeaderBlock headers_;
+  Http2HeaderBlock headers_;
   std::string body_;
-  SpdyHeaderBlock push_promise_;
+  Http2HeaderBlock push_promise_;
   QuicStreamId promise_id_;
   std::string promise_url_;
-  SpdyHeaderBlock client_request_;
+  Http2HeaderBlock client_request_;
 };
 
 TEST_F(QuicClientPromisedInfoTest, PushPromise) {
diff --git a/quiche/quic/core/http/quic_client_push_promise_index.cc b/quiche/quic/core/http/quic_client_push_promise_index.cc
index 60a51c1..00ac30a 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index.cc
+++ b/quiche/quic/core/http/quic_client_push_promise_index.cc
@@ -9,8 +9,6 @@
 #include "quiche/quic/core/http/quic_client_promised_info.h"
 #include "quiche/quic/core/http/spdy_server_push_utils.h"
 
-using spdy::SpdyHeaderBlock;
-
 namespace quic {
 
 QuicClientPushPromiseIndex::QuicClientPushPromiseIndex() {}
@@ -29,7 +27,7 @@
 }
 
 QuicAsyncStatus QuicClientPushPromiseIndex::Try(
-    const spdy::SpdyHeaderBlock& request,
+    const spdy::Http2HeaderBlock& request,
     QuicClientPushPromiseIndex::Delegate* delegate, TryHandle** handle) {
   std::string url(SpdyServerPushUtils::GetPromisedUrlFromHeaders(request));
   auto it = promised_by_url_.find(url);
diff --git a/quiche/quic/core/http/quic_client_push_promise_index.h b/quiche/quic/core/http/quic_client_push_promise_index.h
index ba786d8..c00a17e 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index.h
+++ b/quiche/quic/core/http/quic_client_push_promise_index.h
@@ -10,6 +10,7 @@
 #include "quiche/quic/core/http/quic_spdy_client_session_base.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -32,9 +33,9 @@
     // is honored.  If Vary is not present, return true.  If Vary is
     // present, return whether designated header fields of
     // |promise_request| and |client_request| match.
-    virtual bool CheckVary(const spdy::SpdyHeaderBlock& client_request,
-                           const spdy::SpdyHeaderBlock& promise_request,
-                           const spdy::SpdyHeaderBlock& promise_response) = 0;
+    virtual bool CheckVary(const spdy::Http2HeaderBlock& client_request,
+                           const spdy::Http2HeaderBlock& promise_request,
+                           const spdy::Http2HeaderBlock& promise_response) = 0;
 
     // On rendezvous success, provides the promised |stream|.  Callee
     // does not inherit ownership of |stream|.  On rendezvous failure,
@@ -84,7 +85,7 @@
   // cancel the request if need be.  The caller does not inherit
   // ownership of |*handle|, and it ceases to be valid if the caller
   // invokes |handle->Cancel()| or if |delegate->OnReponse()| fires.
-  QuicAsyncStatus Try(const spdy::SpdyHeaderBlock& request, Delegate* delegate,
+  QuicAsyncStatus Try(const spdy::Http2HeaderBlock& request, Delegate* delegate,
                       TryHandle** handle);
 
   QuicPromisedByUrlMap* promised_by_url() { return &promised_by_url_; }
diff --git a/quiche/quic/core/http/quic_client_push_promise_index_test.cc b/quiche/quic/core/http/quic_client_push_promise_index_test.cc
index d491710..58104fd 100644
--- a/quiche/quic/core/http/quic_client_push_promise_index_test.cc
+++ b/quiche/quic/core/http/quic_client_push_promise_index_test.cc
@@ -64,7 +64,7 @@
   StrictMock<MockQuicConnection>* connection_;
   MockQuicSpdyClientSession session_;
   QuicClientPushPromiseIndex index_;
-  spdy::SpdyHeaderBlock request_;
+  spdy::Http2HeaderBlock request_;
   std::string url_;
   MockQuicClientPromisedInfo promised_;
   QuicClientPushPromiseIndex::TryHandle* handle_;
diff --git a/quiche/quic/core/http/quic_header_list.h b/quiche/quic/core/http/quic_header_list.h
index 9cccf02..ac25f89 100644
--- a/quiche/quic/core/http/quic_header_list.h
+++ b/quiche/quic/core/http/quic_header_list.h
@@ -14,7 +14,6 @@
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/common/quiche_circular_deque.h"
-#include "quiche/spdy/core/spdy_header_block.h"
 #include "quiche/spdy/core/spdy_headers_handler_interface.h"
 
 namespace quic {
diff --git a/quiche/quic/core/http/quic_headers_stream_test.cc b/quiche/quic/core/http/quic_headers_stream_test.cc
index 2e1849a..f4c48c0 100644
--- a/quiche/quic/core/http/quic_headers_stream_test.cc
+++ b/quiche/quic/core/http/quic_headers_stream_test.cc
@@ -28,12 +28,14 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/common/quiche_endian.h"
 #include "quiche/spdy/core/http2_frame_decoder_adapter.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/recording_headers_handler.h"
 #include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 #include "quiche/spdy/test_tools/spdy_test_utils.h"
 
 using spdy::ERROR_CODE_PROTOCOL_ERROR;
+using spdy::Http2HeaderBlock;
 using spdy::RecordingHeadersHandler;
 using spdy::SETTINGS_ENABLE_PUSH;
 using spdy::SETTINGS_HEADER_TABLE_SIZE;
@@ -47,7 +49,6 @@
 using spdy::SpdyFramer;
 using spdy::SpdyFramerVisitorInterface;
 using spdy::SpdyGoAwayIR;
-using spdy::SpdyHeaderBlock;
 using spdy::SpdyHeadersHandlerInterface;
 using spdy::SpdyHeadersIR;
 using spdy::SpdyPingId;
@@ -353,7 +354,7 @@
   StrictMock<MockQuicConnection>* connection_;
   StrictMock<MockQuicSpdySession> session_;
   QuicHeadersStream* headers_stream_;
-  SpdyHeaderBlock headers_;
+  Http2HeaderBlock headers_;
   std::unique_ptr<RecordingHeadersHandler> headers_handler_;
   std::string body_;
   std::string saved_data_;
diff --git a/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc b/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc
index f3b16ef..c036c2c 100644
--- a/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc
@@ -17,7 +17,7 @@
 }
 
 size_t QuicServerInitiatedSpdyStream::WriteHeaders(
-    spdy::SpdyHeaderBlock /*header_block*/, bool /*fin*/,
+    spdy::Http2HeaderBlock /*header_block*/, bool /*fin*/,
     quiche::QuicheReferenceCountedPointer<
         QuicAckListenerInterface> /*ack_listener*/) {
   QUIC_BUG(Writing headers in QuicServerInitiatedSpdyStream)
diff --git a/quiche/quic/core/http/quic_server_initiated_spdy_stream.h b/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
index a93cb40..a47a712 100644
--- a/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
+++ b/quiche/quic/core/http/quic_server_initiated_spdy_stream.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_CORE_HTTP_QUIC_SERVER_INITIATED_SPDY_STREAM_H_
 
 #include "quiche/quic/core/http/quic_spdy_stream.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -19,7 +20,7 @@
 
   void OnBodyAvailable() override;
   size_t WriteHeaders(
-      spdy::SpdyHeaderBlock header_block, bool fin,
+      spdy::Http2HeaderBlock header_block, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener) override;
   void OnInitialHeadersComplete(bool fin, size_t frame_len,
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.cc b/quiche/quic/core/http/quic_spdy_client_session_base.cc
index 5a5c72b..75ecb8b 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.cc
@@ -12,7 +12,7 @@
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
@@ -38,7 +38,7 @@
 }
 
 void QuicSpdyClientSessionBase::OnInitialHeadersComplete(
-    QuicStreamId stream_id, const SpdyHeaderBlock& response_headers) {
+    QuicStreamId stream_id, const Http2HeaderBlock& response_headers) {
   // Note that the strong ordering of the headers stream means that
   // QuicSpdyClientStream::OnPromiseHeadersComplete must have already
   // been called (on the associated stream) if this is a promised
@@ -100,9 +100,9 @@
   stream->OnPromiseHeaderList(promised_stream_id, frame_len, header_list);
 }
 
-bool QuicSpdyClientSessionBase::HandlePromised(QuicStreamId /* associated_id */,
-                                               QuicStreamId promised_id,
-                                               const SpdyHeaderBlock& headers) {
+bool QuicSpdyClientSessionBase::HandlePromised(
+    QuicStreamId /* associated_id */, QuicStreamId promised_id,
+    const Http2HeaderBlock& headers) {
   // TODO(b/136295430): Do not treat |promised_id| as a stream ID when using
   // IETF QUIC.
   // Due to pathalogical packet re-ordering, it is possible that
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.h b/quiche/quic/core/http/quic_spdy_client_session_base.h
index 79e49ab..04a0d76 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.h
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.h
@@ -11,6 +11,7 @@
 #include "quiche/quic/core/http/quic_spdy_session.h"
 #include "quiche/quic/core/quic_crypto_client_stream.h"
 #include "quiche/quic/platform/api/quic_export.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -60,7 +61,7 @@
   // needed to detect promised server push streams, as part of
   // client-request to push-stream rendezvous.
   void OnInitialHeadersComplete(QuicStreamId stream_id,
-                                const spdy::SpdyHeaderBlock& response_headers);
+                                const spdy::Http2HeaderBlock& response_headers);
 
   // Called by |QuicSpdyClientStream| on receipt of PUSH_PROMISE, does
   // some session level validation and creates the
@@ -69,7 +70,7 @@
   // stream and returns false otherwise.
   virtual bool HandlePromised(QuicStreamId associated_id,
                               QuicStreamId promised_id,
-                              const spdy::SpdyHeaderBlock& headers);
+                              const spdy::Http2HeaderBlock& headers);
 
   // For cross-origin server push, this should verify the server is
   // authoritative per [RFC2818], Section 3.  Roughly, subjectAltName
diff --git a/quiche/quic/core/http/quic_spdy_client_session_test.cc b/quiche/quic/core/http/quic_spdy_client_session_test.cc
index 6ebacc5..a39a1ac 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_test.cc
@@ -39,8 +39,9 @@
 #include "quiche/quic/test_tools/quic_stream_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/quic/test_tools/simple_session_cache.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
@@ -215,7 +216,7 @@
   ::testing::NiceMock<PacketSavingConnection>* connection_;
   std::unique_ptr<TestQuicSpdyClientSession> session_;
   QuicClientPushPromiseIndex push_promise_index_;
-  SpdyHeaderBlock push_promise_;
+  Http2HeaderBlock push_promise_;
   std::string promise_url_;
   QuicStreamId promised_stream_id_;
   QuicStreamId associated_stream_id_;
@@ -715,7 +716,7 @@
               OnStreamReset(promised_stream_id_, QUIC_REFUSED_STREAM));
 
   session_->ResetPromised(promised_stream_id_, QUIC_REFUSED_STREAM);
-  SpdyHeaderBlock promise_headers;
+  Http2HeaderBlock promise_headers;
   EXPECT_FALSE(session_->HandlePromised(associated_stream_id_,
                                         promised_stream_id_, promise_headers));
 
@@ -820,14 +821,14 @@
   EXPECT_NE(session_->GetPromisedStream(promised_stream_id_), nullptr);
   EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
 
-  session_->OnInitialHeadersComplete(promised_stream_id_, SpdyHeaderBlock());
+  session_->OnInitialHeadersComplete(promised_stream_id_, Http2HeaderBlock());
 }
 
 TEST_P(QuicSpdyClientSessionTest, OnInitialHeadersCompleteIsNotPush) {
   // Initialize crypto before the client session will create a stream.
   CompleteCryptoHandshake();
   session_->CreateOutgoingBidirectionalStream();
-  session_->OnInitialHeadersComplete(promised_stream_id_, SpdyHeaderBlock());
+  session_->OnInitialHeadersComplete(promised_stream_id_, Http2HeaderBlock());
 }
 
 TEST_P(QuicSpdyClientSessionTest, DeletePromised) {
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.cc b/quiche/quic/core/http/quic_spdy_client_stream.cc
index 044c616..92277f9 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_client_stream.cc
@@ -16,7 +16,7 @@
 #include "quiche/common/quiche_text_utils.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
@@ -126,7 +126,7 @@
     const QuicHeaderList& header_list) {
   header_bytes_read_ += frame_len;
   int64_t content_length = -1;
-  SpdyHeaderBlock promise_headers;
+  Http2HeaderBlock promise_headers;
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &content_length,
                                          &promise_headers)) {
     QUIC_DLOG(ERROR) << "Failed to parse promise headers: "
@@ -172,7 +172,7 @@
   }
 }
 
-size_t QuicSpdyClientStream::SendRequest(SpdyHeaderBlock headers,
+size_t QuicSpdyClientStream::SendRequest(Http2HeaderBlock headers,
                                          absl::string_view body, bool fin) {
   QuicConnection::ScopedPacketFlusher flusher(session_->connection());
   bool send_fin_with_headers = fin && body.empty();
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.h b/quiche/quic/core/http/quic_spdy_client_stream.h
index 6311726..a0806d7 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.h
+++ b/quiche/quic/core/http/quic_spdy_client_stream.h
@@ -11,6 +11,7 @@
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/http/quic_spdy_stream.h"
 #include "quiche/quic/core/quic_packets.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -46,16 +47,16 @@
 
   // Serializes the headers and body, sends it to the server, and
   // returns the number of bytes sent.
-  size_t SendRequest(spdy::SpdyHeaderBlock headers, absl::string_view body,
+  size_t SendRequest(spdy::Http2HeaderBlock headers, absl::string_view body,
                      bool fin);
 
   // Returns the response data.
   const std::string& data() { return data_; }
 
   // Returns whatever headers have been received for this stream.
-  const spdy::SpdyHeaderBlock& response_headers() { return response_headers_; }
+  const spdy::Http2HeaderBlock& response_headers() { return response_headers_; }
 
-  const spdy::SpdyHeaderBlock& preliminary_headers() {
+  const spdy::Http2HeaderBlock& preliminary_headers() {
     return preliminary_headers_;
   }
 
@@ -74,7 +75,7 @@
 
  private:
   // The parsed headers received from the server.
-  spdy::SpdyHeaderBlock response_headers_;
+  spdy::Http2HeaderBlock response_headers_;
 
   // The parsed content-length, or -1 if none is specified.
   int64_t content_length_;
@@ -89,7 +90,7 @@
   // that may arrive before the response headers when the request has
   // Expect: 100-continue.
   bool has_preliminary_headers_;
-  spdy::SpdyHeaderBlock preliminary_headers_;
+  spdy::Http2HeaderBlock preliminary_headers_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_client_stream_test.cc b/quiche/quic/core/http/quic_spdy_client_stream_test.cc
index 17901e0..d5b4137 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_stream_test.cc
@@ -21,7 +21,7 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/common/simple_buffer_allocator.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 using testing::_;
 using testing::StrictMock;
 
@@ -99,7 +99,7 @@
   MockQuicSpdyClientSession session_;
   QuicSpdyClientStream* stream_;
   std::unique_ptr<StreamVisitor> stream_visitor_;
-  SpdyHeaderBlock headers_;
+  Http2HeaderBlock headers_;
   std::string body_;
 };
 
@@ -292,7 +292,7 @@
   // Send trailers before sending the body. Even though a FIN has been received
   // the stream should not be closed, as it does not yet have all the data bytes
   // promised by the final offset field.
-  SpdyHeaderBlock trailer_block;
+  Http2HeaderBlock trailer_block;
   trailer_block["trailer key"] = "trailer value";
   trailer_block[kFinalOffsetHeaderKey] = absl::StrCat(body_.size());
   auto trailers = AsHeaderList(trailer_block);
diff --git a/quiche/quic/core/http/quic_spdy_server_stream_base_test.cc b/quiche/quic/core/http/quic_spdy_server_stream_base_test.cc
index ff14bb7..317d174 100644
--- a/quiche/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quiche/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -12,6 +12,7 @@
 #include "quiche/quic/test_tools/quic_spdy_session_peer.h"
 #include "quiche/quic/test_tools/quic_stream_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 using testing::_;
 
@@ -308,7 +309,7 @@
 TEST_F(QuicSpdyServerStreamBaseTest, EmptyHeaders) {
   SetQuicReloadableFlag(quic_verify_request_headers_2, true);
   SetQuicReloadableFlag(quic_act_upon_invalid_header, true);
-  spdy::SpdyHeaderBlock empty_header;
+  spdy::Http2HeaderBlock empty_header;
   quic::test::NoopQpackStreamSenderDelegate encoder_stream_sender_delegate;
   quic::test::NoopDecoderStreamErrorDelegate decoder_stream_error_delegate;
   auto qpack_encoder =
diff --git a/quiche/quic/core/http/quic_spdy_session.cc b/quiche/quic/core/http/quic_spdy_session.cc
index d830fa8..8b6d5ea 100644
--- a/quiche/quic/core/http/quic_spdy_session.cc
+++ b/quiche/quic/core/http/quic_spdy_session.cc
@@ -34,6 +34,7 @@
 #include "quiche/spdy/core/http2_frame_decoder_adapter.h"
 
 using http2::Http2DecoderAdapter;
+using spdy::Http2HeaderBlock;
 using spdy::Http2WeightToSpdy3Priority;
 using spdy::Spdy3PriorityToHttp2Weight;
 using spdy::SpdyErrorCode;
@@ -41,7 +42,6 @@
 using spdy::SpdyFramerDebugVisitorInterface;
 using spdy::SpdyFramerVisitorInterface;
 using spdy::SpdyFrameType;
-using spdy::SpdyHeaderBlock;
 using spdy::SpdyHeadersHandlerInterface;
 using spdy::SpdyHeadersIR;
 using spdy::SpdyPingId;
@@ -690,7 +690,7 @@
 }
 
 size_t QuicSpdySession::WriteHeadersOnHeadersStream(
-    QuicStreamId id, SpdyHeaderBlock headers, bool fin,
+    QuicStreamId id, Http2HeaderBlock headers, bool fin,
     const spdy::SpdyStreamPrecedence& precedence,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
@@ -802,7 +802,7 @@
 
 void QuicSpdySession::WritePushPromise(QuicStreamId original_stream_id,
                                        QuicStreamId promised_stream_id,
-                                       SpdyHeaderBlock headers) {
+                                       Http2HeaderBlock headers) {
   if (perspective() == Perspective::IS_CLIENT) {
     QUIC_BUG(quic_bug_10360_4) << "Client shouldn't send PUSH_PROMISE";
     return;
@@ -909,7 +909,7 @@
 }
 
 size_t QuicSpdySession::WriteHeadersOnHeadersStreamImpl(
-    QuicStreamId id, spdy::SpdyHeaderBlock headers, bool fin,
+    QuicStreamId id, spdy::Http2HeaderBlock headers, bool fin,
     QuicStreamId parent_stream_id, int weight, bool exclusive,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
diff --git a/quiche/quic/core/http/quic_spdy_session.h b/quiche/quic/core/http/quic_spdy_session.h
index f117328..f1ef594 100644
--- a/quiche/quic/core/http/quic_spdy_session.h
+++ b/quiche/quic/core/http/quic_spdy_session.h
@@ -34,6 +34,7 @@
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/common/quiche_circular_deque.h"
 #include "quiche/spdy/core/http2_frame_decoder_adapter.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -109,7 +110,7 @@
                                QuicByteCount /*payload_length*/) {}
   virtual void OnHeadersFrameSent(
       QuicStreamId /*stream_id*/,
-      const spdy::SpdyHeaderBlock& /*header_block*/) {}
+      const spdy::Http2HeaderBlock& /*header_block*/) {}
 
   // 0-RTT related events.
   virtual void OnSettingsFrameResumed(const SettingsFrame& /*frame*/) {}
@@ -199,7 +200,7 @@
   // If provided, |ack_notifier_delegate| will be registered to be notified when
   // we have seen ACKs for all packets resulting from this call.
   virtual size_t WriteHeadersOnHeadersStream(
-      QuicStreamId id, spdy::SpdyHeaderBlock headers, bool fin,
+      QuicStreamId id, spdy::Http2HeaderBlock headers, bool fin,
       const spdy::SpdyStreamPrecedence& precedence,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
@@ -230,7 +231,7 @@
   // PUSH_PROMISE frame to peer.
   virtual void WritePushPromise(QuicStreamId original_stream_id,
                                 QuicStreamId promised_stream_id,
-                                spdy::SpdyHeaderBlock headers);
+                                spdy::Http2HeaderBlock headers);
 
   QpackEncoder* qpack_encoder();
   QpackDecoder* qpack_decoder();
@@ -482,7 +483,7 @@
   QuicStream* ProcessPendingStream(PendingStream* pending) override;
 
   size_t WriteHeadersOnHeadersStreamImpl(
-      QuicStreamId id, spdy::SpdyHeaderBlock headers, bool fin,
+      QuicStreamId id, spdy::Http2HeaderBlock headers, bool fin,
       QuicStreamId parent_stream_id, int weight, bool exclusive,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
diff --git a/quiche/quic/core/http/quic_spdy_session_test.cc b/quiche/quic/core/http/quic_spdy_session_test.cc
index 4baaae9..2ef3183 100644
--- a/quiche/quic/core/http/quic_spdy_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_session_test.cc
@@ -51,10 +51,10 @@
 #include "quiche/common/test_tools/quiche_test_utils.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
+using spdy::Http2HeaderBlock;
 using spdy::kV3HighestPriority;
 using spdy::Spdy3PriorityToHttp2Weight;
 using spdy::SpdyFramer;
-using spdy::SpdyHeaderBlock;
 using spdy::SpdyPriority;
 using spdy::SpdyPriorityIR;
 using spdy::SpdySerializedFrame;
@@ -578,7 +578,7 @@
     WebTransportHttp3* web_transport =
         session_.GetWebTransportSession(session_id);
     ASSERT_TRUE(web_transport != nullptr);
-    spdy::SpdyHeaderBlock header_block;
+    spdy::Http2HeaderBlock header_block;
     web_transport->HeadersReceived(header_block);
   }
 
@@ -1548,7 +1548,7 @@
   // Write until the header stream is flow control blocked.
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .WillOnce(Invoke(&ClearControlFrame));
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   SimpleRandom random;
   while (!headers_stream->IsFlowControlBlocked() && stream_id < 2000) {
     EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
@@ -1889,7 +1889,7 @@
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   // Write headers with FIN set to close write side of stream.
   // Header block does not matter.
-  stream->WriteHeaders(SpdyHeaderBlock(), /* fin = */ true, nullptr);
+  stream->WriteHeaders(Http2HeaderBlock(), /* fin = */ true, nullptr);
 
   // Receive headers that are too large or empty, with FIN set.
   // This causes the stream to be reset.  No frames must be written after this.
@@ -3704,7 +3704,7 @@
 
   TestStream* stream = session_.CreateOutgoingBidirectionalStream();
   EXPECT_CALL(*writer_, IsWriteBlocked()).WillRepeatedly(Return(true));
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "GET";  // entry with index 2 in HPACK static table
   stream->WriteHeaders(std::move(headers), /* fin = */ true, nullptr);
 
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index fd33936..b7bcbc2 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -36,7 +36,7 @@
 #include "quiche/common/quiche_text_utils.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 using spdy::SpdyPriority;
 
 namespace quic {
@@ -246,7 +246,7 @@
 QuicSpdyStream::~QuicSpdyStream() {}
 
 size_t QuicSpdyStream::WriteHeaders(
-    SpdyHeaderBlock header_block, bool fin,
+    Http2HeaderBlock header_block, bool fin,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
   if (!AssertNotWebTransportDataStream("writing headers")) {
@@ -337,7 +337,7 @@
 }
 
 size_t QuicSpdyStream::WriteTrailers(
-    SpdyHeaderBlock trailer_block,
+    Http2HeaderBlock trailer_block,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
   if (fin_sent()) {
@@ -909,9 +909,9 @@
 }
 
 // static
-bool QuicSpdyStream::ParseHeaderStatusCode(const SpdyHeaderBlock& header,
+bool QuicSpdyStream::ParseHeaderStatusCode(const Http2HeaderBlock& header,
                                            int* status_code) {
-  SpdyHeaderBlock::const_iterator it = header.find(spdy::kHttp2StatusHeader);
+  Http2HeaderBlock::const_iterator it = header.find(spdy::kHttp2StatusHeader);
   if (it == header.end()) {
     return false;
   }
@@ -1155,7 +1155,7 @@
 bool QuicSpdyStream::OnUnknownFrameEnd() { return true; }
 
 size_t QuicSpdyStream::WriteHeadersImpl(
-    spdy::SpdyHeaderBlock header_block, bool fin,
+    spdy::Http2HeaderBlock header_block, bool fin,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
   if (!VersionUsesHttp3(transport_version())) {
@@ -1263,7 +1263,7 @@
 }
 
 void QuicSpdyStream::MaybeProcessSentWebTransportHeaders(
-    spdy::SpdyHeaderBlock& headers) {
+    spdy::Http2HeaderBlock& headers) {
   if (!spdy_session_->SupportsWebTransport()) {
     return;
   }
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index 1a45682..ffc2e18 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -36,8 +36,8 @@
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
-#include "quiche/spdy/core/spdy_header_block.h"
 
 namespace quic {
 
@@ -124,7 +124,7 @@
   // number of bytes sent, including data sent on the encoder stream when using
   // QPACK.
   virtual size_t WriteHeaders(
-      spdy::SpdyHeaderBlock header_block, bool fin,
+      spdy::Http2HeaderBlock header_block, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
 
@@ -136,7 +136,7 @@
   // always have the FIN flag set.  Returns the number of bytes sent, including
   // data sent on the encoder stream when using QPACK.
   virtual size_t WriteTrailers(
-      spdy::SpdyHeaderBlock trailer_block,
+      spdy::Http2HeaderBlock trailer_block,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
 
@@ -178,7 +178,7 @@
 
   // Returns true if header contains a valid 3-digit status and parse the status
   // code to |status_code|.
-  static bool ParseHeaderStatusCode(const spdy::SpdyHeaderBlock& header,
+  static bool ParseHeaderStatusCode(const spdy::Http2HeaderBlock& header,
                                     int* status_code);
 
   // Returns true when all data from the peer has been read and consumed,
@@ -198,7 +198,7 @@
   bool trailers_decompressed() const { return trailers_decompressed_; }
 
   // Returns whatever trailers have been received for this stream.
-  const spdy::SpdyHeaderBlock& received_trailers() const {
+  const spdy::Http2HeaderBlock& received_trailers() const {
     return received_trailers_;
   }
 
@@ -301,7 +301,7 @@
   virtual void OnTrailingHeadersComplete(bool fin, size_t frame_len,
                                          const QuicHeaderList& header_list);
   virtual size_t WriteHeadersImpl(
-      spdy::SpdyHeaderBlock header_block, bool fin,
+      spdy::Http2HeaderBlock header_block, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
 
@@ -357,7 +357,7 @@
   QuicByteCount GetNumFrameHeadersInInterval(QuicStreamOffset offset,
                                              QuicByteCount data_length) const;
 
-  void MaybeProcessSentWebTransportHeaders(spdy::SpdyHeaderBlock& headers);
+  void MaybeProcessSentWebTransportHeaders(spdy::Http2HeaderBlock& headers);
   void MaybeProcessReceivedWebTransportHeaders();
 
   // Writes HTTP/3 DATA frame header. If |force_write| is true, use
@@ -398,7 +398,7 @@
   bool trailers_consumed_;
 
   // The parsed trailers received from the peer.
-  spdy::SpdyHeaderBlock received_trailers_;
+  spdy::Http2HeaderBlock received_trailers_;
 
   // Headers accumulator for decoding HEADERS frame payload.
   std::unique_ptr<QpackDecodedHeadersAccumulator>
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc
index ef695cc..e59b4d3 100644
--- a/quiche/quic/core/http/quic_spdy_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -39,9 +39,9 @@
 #include "quiche/common/quiche_mem_slice_storage.h"
 #include "quiche/common/simple_buffer_allocator.h"
 
+using spdy::Http2HeaderBlock;
 using spdy::kV3HighestPriority;
 using spdy::kV3LowestPriority;
-using spdy::SpdyHeaderBlock;
 using spdy::SpdyPriority;
 using testing::_;
 using testing::AnyNumber;
@@ -243,7 +243,7 @@
   MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
 
   size_t WriteHeadersImpl(
-      spdy::SpdyHeaderBlock header_block, bool fin,
+      spdy::Http2HeaderBlock header_block, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
       /*ack_listener*/) override {
     saved_headers_ = std::move(header_block);
@@ -258,7 +258,7 @@
   }
 
   const std::string& data() const { return data_; }
-  const spdy::SpdyHeaderBlock& saved_headers() const { return saved_headers_; }
+  const spdy::Http2HeaderBlock& saved_headers() const { return saved_headers_; }
 
   // Expose protected accessor.
   const QuicStreamSequencer* sequencer() const {
@@ -280,7 +280,7 @@
 
  private:
   bool should_process_data_;
-  spdy::SpdyHeaderBlock saved_headers_;
+  spdy::Http2HeaderBlock saved_headers_;
   std::string data_;
   size_t headers_payload_length_;
 };
@@ -376,7 +376,7 @@
   // Return QPACK-encoded header block without using the dynamic table.
   std::string EncodeQpackHeaders(
       std::vector<std::pair<absl::string_view, absl::string_view>> headers) {
-    SpdyHeaderBlock header_block;
+    Http2HeaderBlock header_block;
     for (const auto& header_field : headers) {
       header_block.AppendValueOrAddHeader(header_field.first,
                                           header_field.second);
@@ -386,7 +386,7 @@
   }
 
   // Return QPACK-encoded header block without using the dynamic table.
-  std::string EncodeQpackHeaders(const SpdyHeaderBlock& header) {
+  std::string EncodeQpackHeaders(const Http2HeaderBlock& header) {
     NoopQpackStreamSenderDelegate encoder_stream_sender_delegate;
     auto qpack_encoder = std::make_unique<QpackEncoder>(session_.get());
     qpack_encoder->set_qpack_stream_sender_delegate(
@@ -458,7 +458,7 @@
     session_->GetMutableCryptoStream()->OnHandshakeMessage(message);
   }
 
-  QuicHeaderList ProcessHeaders(bool fin, const SpdyHeaderBlock& headers) {
+  QuicHeaderList ProcessHeaders(bool fin, const Http2HeaderBlock& headers) {
     QuicHeaderList h = AsHeaderList(headers);
     stream_->OnStreamHeaderList(fin, h.uncompressed_header_bytes(), h);
     return h;
@@ -482,7 +482,7 @@
 
   // Construct HEADERS frame with QPACK-encoded |headers| without using the
   // dynamic table.
-  std::string HeadersFrame(const SpdyHeaderBlock& headers) {
+  std::string HeadersFrame(const Http2HeaderBlock& headers) {
     return HeadersFrame(EncodeQpackHeaders(headers));
   }
 
@@ -530,7 +530,7 @@
   TestStream* stream_;
   TestStream* stream2_;
 
-  SpdyHeaderBlock headers_;
+  Http2HeaderBlock headers_;
 };
 
 INSTANTIATE_TEST_SUITE_P(Tests, QuicSpdyStreamTest,
@@ -1281,11 +1281,11 @@
   stream_->ConsumeHeaderList();
 
   // Receive trailing headers.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["key1"] = "value1";
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
-  SpdyHeaderBlock trailers_block_with_final_offset = trailers_block.Clone();
+  Http2HeaderBlock trailers_block_with_final_offset = trailers_block.Clone();
   if (!UsesHttp3()) {
     // :final-offset pseudo-header is only added if trailers are sent
     // on the headers stream.
@@ -1328,7 +1328,7 @@
   std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   // Receive trailing headers.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["key1"] = "value1";
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
@@ -1371,7 +1371,7 @@
   stream_->ConsumeHeaderList();
 
   // Receive trailing headers, without kFinalOffsetHeaderKey.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["key1"] = "value1";
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
@@ -1405,7 +1405,7 @@
   stream_->ConsumeHeaderList();
 
   // Receive trailing headers with FIN deliberately set to false.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["foo"] = "bar";
   auto trailers = AsHeaderList(trailers_block);
 
@@ -1432,7 +1432,7 @@
   stream_->ConsumeHeaderList();
 
   // Receive trailing headers after FIN already received.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["foo"] = "bar";
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
@@ -1461,7 +1461,7 @@
   stream_->OnStreamFrame(frame);
 
   // Receive trailing headers after FIN already received.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["foo"] = "bar";
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
@@ -1504,10 +1504,10 @@
 
   // Write the initial headers, without a FIN.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/false, nullptr);
 
   // Writing trailers implicitly sends a FIN.
-  SpdyHeaderBlock trailers;
+  Http2HeaderBlock trailers;
   trailers["trailer key"] = "trailer value";
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
   stream_->WriteTrailers(std::move(trailers), nullptr);
@@ -1537,10 +1537,10 @@
   // Write the initial headers, without a FIN.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   EXPECT_CALL(debug_visitor, OnHeadersFrameSent(stream_->id(), _));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/false, nullptr);
 
   // Writing trailers implicitly sends a FIN.
-  SpdyHeaderBlock trailers;
+  Http2HeaderBlock trailers;
   trailers["trailer key"] = "trailer value";
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
   EXPECT_CALL(debug_visitor, OnHeadersFrameSent(stream_->id(), _));
@@ -1561,7 +1561,7 @@
   EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _)).Times(2);
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   EXPECT_CALL(debug_visitor, OnHeadersFrameSent(stream_->id(), _));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/false, nullptr);
 
   // PRIORITY_UPDATE frame on the control stream.
   auto send_control_stream =
@@ -1594,7 +1594,7 @@
   // PRIORITY_UPDATE frame is not sent this time, because one is already sent.
   EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _)).Times(2);
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/true, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/true, nullptr);
 }
 
 // Test that when writing trailers, the trailers that are actually sent to the
@@ -1610,7 +1610,7 @@
 
   // Write the initial headers.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/false, nullptr);
 
   // Write non-zero body data to force a non-zero final offset.
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(AtLeast(1));
@@ -1626,10 +1626,10 @@
 
   // The final offset field in the trailing headers is populated with the
   // number of body bytes written (including queued bytes).
-  SpdyHeaderBlock trailers;
+  Http2HeaderBlock trailers;
   trailers["trailer key"] = "trailer value";
 
-  SpdyHeaderBlock expected_trailers(trailers.Clone());
+  Http2HeaderBlock expected_trailers(trailers.Clone());
   // :final-offset pseudo-header is only added if trailers are sent
   // on the headers stream.
   if (!UsesHttp3()) {
@@ -1654,7 +1654,7 @@
 
   // Write the initial headers.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/false, nullptr);
 
   // Write non-zero body data.
   const int kBodySize = 1 * 1024;  // 1 kB
@@ -1664,7 +1664,7 @@
   // Headers and body have been fully written, there is no queued data. Writing
   // trailers marks the end of this stream, and thus the write side is closed.
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
-  stream_->WriteTrailers(SpdyHeaderBlock(), nullptr);
+  stream_->WriteTrailers(Http2HeaderBlock(), nullptr);
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
@@ -1683,7 +1683,7 @@
 
   // Write the initial headers.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/false, nullptr);
 
   // Write non-zero body data, but only consume partially, ensuring queueing.
   const int kBodySize = 1 * 1024;  // 1 kB
@@ -1698,7 +1698,7 @@
   // Writing trailers will send a FIN, but not close the write side of the
   // stream as there are queued bytes.
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
-  stream_->WriteTrailers(SpdyHeaderBlock(), nullptr);
+  stream_->WriteTrailers(Http2HeaderBlock(), nullptr);
   EXPECT_TRUE(stream_->fin_sent());
   EXPECT_FALSE(stream_->write_side_closed());
 
@@ -1720,12 +1720,12 @@
 
   // Write the initial headers, with a FIN.
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
-  stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/true, nullptr);
+  stream_->WriteHeaders(Http2HeaderBlock(), /*fin=*/true, nullptr);
   EXPECT_TRUE(stream_->fin_sent());
 
   // Writing Trailers should fail, as the FIN has already been sent.
   // populated with the number of body bytes written.
-  EXPECT_QUIC_BUG(stream_->WriteTrailers(SpdyHeaderBlock(), nullptr),
+  EXPECT_QUIC_BUG(stream_->WriteTrailers(Http2HeaderBlock(), nullptr),
                   "Trailers cannot be sent after a FIN");
 }
 
@@ -2097,7 +2097,7 @@
   // A header block that will take more than one block of sequencer buffer.
   // This ensures that when the trailers are consumed, some buffer buckets will
   // be freed.
-  SpdyHeaderBlock trailers_block;
+  Http2HeaderBlock trailers_block;
   trailers_block["key1"] = std::string(10000, 'x');
   std::string trailers = HeadersFrame(trailers_block);
 
@@ -2844,7 +2844,7 @@
       .WillOnce(InvokeWithoutArgs([this]() { stream_->StopReading(); }));
 
   // Receive another HEADERS frame, with no header fields.
-  std::string trailers2 = HeadersFrame(SpdyHeaderBlock());
+  std::string trailers2 = HeadersFrame(Http2HeaderBlock());
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), false, offset, trailers2));
 }
@@ -3017,7 +3017,7 @@
           DoAll(SaveArg<1>(&headers_frame_payload_length),
                 Invoke(session_.get(), &MockQuicSpdySession::ConsumeData)));
 
-  SpdyHeaderBlock request_headers;
+  Http2HeaderBlock request_headers;
   request_headers["foo"] = "bar";
   size_t write_headers_return_value =
       stream_->WriteHeaders(std::move(request_headers), /*fin=*/true, nullptr);
@@ -3079,7 +3079,7 @@
   EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _))
       .Times(AnyNumber());
 
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":method"] = "CONNECT";
   headers[":protocol"] = "webtransport";
   stream_->WriteHeaders(std::move(headers), /*fin=*/false, nullptr);
diff --git a/quiche/quic/core/http/spdy_server_push_utils.cc b/quiche/quic/core/http/spdy_server_push_utils.cc
index 103f6dd..22dc13f 100644
--- a/quiche/quic/core/http/spdy_server_push_utils.cc
+++ b/quiche/quic/core/http/spdy_server_push_utils.cc
@@ -7,13 +7,13 @@
 #include "absl/strings/string_view.h"
 #include "url/gurl.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
 // static
 std::string SpdyServerPushUtils::GetPromisedUrlFromHeaders(
-    const SpdyHeaderBlock& headers) {
+    const Http2HeaderBlock& headers) {
   // RFC 7540, Section 8.1.2.3: All HTTP/2 requests MUST include exactly
   // one valid value for the ":method", ":scheme", and ":path" pseudo-header
   // fields, unless it is a CONNECT request.
@@ -31,7 +31,7 @@
   // POST as cacheable, ...
   //
   // So the only methods allowed in a PUSH_PROMISE are GET and HEAD.
-  SpdyHeaderBlock::const_iterator it = headers.find(":method");
+  Http2HeaderBlock::const_iterator it = headers.find(":method");
   if (it == headers.end() || (it->second != "GET" && it->second != "HEAD")) {
     return std::string();
   }
@@ -67,14 +67,14 @@
 
 // static
 std::string SpdyServerPushUtils::GetPromisedHostNameFromHeaders(
-    const SpdyHeaderBlock& headers) {
+    const Http2HeaderBlock& headers) {
   // TODO(fayang): Consider just checking out the value of the ":authority" key
   // in headers.
   return GURL(GetPromisedUrlFromHeaders(headers)).host();
 }
 
 // static
-bool SpdyServerPushUtils::PromisedUrlIsValid(const SpdyHeaderBlock& headers) {
+bool SpdyServerPushUtils::PromisedUrlIsValid(const Http2HeaderBlock& headers) {
   std::string url(GetPromisedUrlFromHeaders(headers));
   return !url.empty() && GURL(url).is_valid();
 }
diff --git a/quiche/quic/core/http/spdy_server_push_utils.h b/quiche/quic/core/http/spdy_server_push_utils.h
index c79f52c..a924158 100644
--- a/quiche/quic/core/http/spdy_server_push_utils.h
+++ b/quiche/quic/core/http/spdy_server_push_utils.h
@@ -7,7 +7,7 @@
 
 #include "absl/strings/string_view.h"
 #include "quiche/quic/platform/api/quic_export.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -20,15 +20,15 @@
   // conform to HTTP/2 spec or if the ":method" header contains a forbidden
   // method for PUSH_PROMISE.
   static std::string GetPromisedUrlFromHeaders(
-      const spdy::SpdyHeaderBlock& headers);
+      const spdy::Http2HeaderBlock& headers);
 
   // Returns hostname, or empty string if missing.
   static std::string GetPromisedHostNameFromHeaders(
-      const spdy::SpdyHeaderBlock& headers);
+      const spdy::Http2HeaderBlock& headers);
 
   // Returns true if result of |GetPromisedUrlFromHeaders()| is non-empty
   // and is a well-formed URL.
-  static bool PromisedUrlIsValid(const spdy::SpdyHeaderBlock& headers);
+  static bool PromisedUrlIsValid(const spdy::Http2HeaderBlock& headers);
 
   // Returns a canonical, valid URL for a PUSH_PROMISE with the specified
   // ":scheme", ":authority", and ":path" header fields, or an empty
diff --git a/quiche/quic/core/http/spdy_server_push_utils_test.cc b/quiche/quic/core/http/spdy_server_push_utils_test.cc
index d9aff41..b11bcbe 100644
--- a/quiche/quic/core/http/spdy_server_push_utils_test.cc
+++ b/quiche/quic/core/http/spdy_server_push_utils_test.cc
@@ -10,7 +10,7 @@
 #include "absl/base/macros.h"
 #include "quiche/quic/platform/api/quic_test.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 namespace test {
@@ -18,7 +18,7 @@
 using GetPromisedUrlFromHeaders = QuicTest;
 
 TEST_F(GetPromisedUrlFromHeaders, Basic) {
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "GET";
   EXPECT_EQ(SpdyServerPushUtils::GetPromisedUrlFromHeaders(headers), "");
   headers[":scheme"] = "https";
@@ -35,7 +35,7 @@
 }
 
 TEST_F(GetPromisedUrlFromHeaders, Connect) {
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "CONNECT";
   EXPECT_EQ(SpdyServerPushUtils::GetPromisedUrlFromHeaders(headers), "");
   headers[":authority"] = "www.google.com";
@@ -47,7 +47,7 @@
 }
 
 TEST_F(GetPromisedUrlFromHeaders, InvalidUserinfo) {
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "GET";
   headers[":authority"] = "user@www.google.com";
   headers[":scheme"] = "https";
@@ -56,7 +56,7 @@
 }
 
 TEST_F(GetPromisedUrlFromHeaders, InvalidPath) {
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "GET";
   headers[":authority"] = "www.google.com";
   headers[":scheme"] = "https";
@@ -67,7 +67,7 @@
 using GetPromisedHostNameFromHeaders = QuicTest;
 
 TEST_F(GetPromisedHostNameFromHeaders, NormalUsage) {
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":method"] = "GET";
   EXPECT_EQ(SpdyServerPushUtils::GetPromisedHostNameFromHeaders(headers), "");
   headers[":scheme"] = "https";
diff --git a/quiche/quic/core/http/spdy_utils.cc b/quiche/quic/core/http/spdy_utils.cc
index b8282e4..873d39c 100644
--- a/quiche/quic/core/http/spdy_utils.cc
+++ b/quiche/quic/core/http/spdy_utils.cc
@@ -20,13 +20,13 @@
 #include "quiche/common/quiche_text_utils.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
 // static
 bool SpdyUtils::ExtractContentLengthFromHeaders(int64_t* content_length,
-                                                SpdyHeaderBlock* headers) {
+                                                Http2HeaderBlock* headers) {
   auto it = headers->find("content-length");
   if (it == headers->end()) {
     return false;
@@ -61,7 +61,7 @@
 
 bool SpdyUtils::CopyAndValidateHeaders(const QuicHeaderList& header_list,
                                        int64_t* content_length,
-                                       SpdyHeaderBlock* headers) {
+                                       Http2HeaderBlock* headers) {
   for (const auto& p : header_list) {
     const std::string& name = p.first;
     if (name.empty()) {
@@ -90,7 +90,7 @@
 bool SpdyUtils::CopyAndValidateTrailers(const QuicHeaderList& header_list,
                                         bool expect_final_byte_offset,
                                         size_t* final_byte_offset,
-                                        SpdyHeaderBlock* trailers) {
+                                        Http2HeaderBlock* trailers) {
   bool found_final_byte_offset = false;
   for (const auto& p : header_list) {
     const std::string& name = p.first;
@@ -135,7 +135,7 @@
 // static
 // TODO(danzh): Move it to quic/tools/ and switch to use GURL.
 bool SpdyUtils::PopulateHeaderBlockFromUrl(const std::string url,
-                                           SpdyHeaderBlock* headers) {
+                                           Http2HeaderBlock* headers) {
   (*headers)[":method"] = "GET";
   size_t pos = url.find("://");
   if (pos == std::string::npos) {
diff --git a/quiche/quic/core/http/spdy_utils.h b/quiche/quic/core/http/spdy_utils.h
index d88087c..05a237d 100644
--- a/quiche/quic/core/http/spdy_utils.h
+++ b/quiche/quic/core/http/spdy_utils.h
@@ -14,8 +14,8 @@
 #include "quiche/quic/core/http/quic_header_list.h"
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/platform/api/quic_export.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_header_block.h"
 
 namespace quic {
 
@@ -27,14 +27,14 @@
   // Returns true on success, false if parsing fails or content-length header is
   // missing.
   static bool ExtractContentLengthFromHeaders(int64_t* content_length,
-                                              spdy::SpdyHeaderBlock* headers);
+                                              spdy::Http2HeaderBlock* headers);
 
-  // Copies a list of headers to a SpdyHeaderBlock.
+  // Copies a list of headers to a Http2HeaderBlock.
   static bool CopyAndValidateHeaders(const QuicHeaderList& header_list,
                                      int64_t* content_length,
-                                     spdy::SpdyHeaderBlock* headers);
+                                     spdy::Http2HeaderBlock* headers);
 
-  // Copies a list of headers to a SpdyHeaderBlock.
+  // Copies a list of headers to a Http2HeaderBlock.
   // If |expect_final_byte_offset| is true, requires exactly one header field
   // with key kFinalOffsetHeaderKey and an integer value.
   // If |expect_final_byte_offset| is false, no kFinalOffsetHeaderKey may be
@@ -47,12 +47,12 @@
   static bool CopyAndValidateTrailers(const QuicHeaderList& header_list,
                                       bool expect_final_byte_offset,
                                       size_t* final_byte_offset,
-                                      spdy::SpdyHeaderBlock* trailers);
+                                      spdy::Http2HeaderBlock* trailers);
 
   // Populates the fields of |headers| to make a GET request of |url|,
   // which must be fully-qualified.
   static bool PopulateHeaderBlockFromUrl(const std::string url,
-                                         spdy::SpdyHeaderBlock* headers);
+                                         spdy::Http2HeaderBlock* headers);
 
   // Returns the advertised QUIC version from the specified alternative service
   // advertisement, or ParsedQuicVersion::Unsupported() if no supported version
diff --git a/quiche/quic/core/http/spdy_utils_test.cc b/quiche/quic/core/http/spdy_utils_test.cc
index 718d548..43177ba 100644
--- a/quiche/quic/core/http/spdy_utils_test.cc
+++ b/quiche/quic/core/http/spdy_utils_test.cc
@@ -12,7 +12,7 @@
 #include "quiche/quic/core/quic_versions.h"
 #include "quiche/quic/platform/api/quic_test.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 using testing::Pair;
 using testing::UnorderedElementsAre;
 
@@ -64,7 +64,7 @@
                            {"cookie", " fin!"}});
 
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block,
@@ -80,7 +80,7 @@
 TEST_F(CopyAndValidateHeaders, EmptyName) {
   auto headers = FromList({{"foo", "foovalue"}, {"", "barvalue"}, {"baz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_FALSE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
 }
@@ -89,7 +89,7 @@
   auto headers =
       FromList({{"foo", "foovalue"}, {"bar", "barvalue"}, {"bAz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_FALSE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
 }
@@ -101,7 +101,7 @@
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
@@ -118,7 +118,7 @@
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_FALSE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
 }
@@ -129,7 +129,7 @@
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block,
@@ -149,7 +149,7 @@
                            {"bar", "barvalue"},
                            {"baz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_FALSE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
 }
@@ -161,7 +161,7 @@
                            {"foo", "boo"},
                            {"baz", "buzz"}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
@@ -176,7 +176,7 @@
                            {"set-cookie", "value2"},
                            {"set-cookie", "value3"}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(Pair(
@@ -191,7 +191,7 @@
                            {"cookie", "value1"},
                            {"baz", ""}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
@@ -207,7 +207,7 @@
                            {"baz", ""},
                            {"cookie", "value2"}});
   int64_t content_length = -1;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
@@ -223,7 +223,7 @@
   // gets parsed successfully.
   auto trailers = FromList({{kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_EQ(1234u, final_byte_offset);
@@ -234,7 +234,7 @@
   // not present.
   QuicHeaderList trailers;
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
       trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
@@ -245,7 +245,7 @@
   // not expected.
   QuicHeaderList trailers;
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
       trailers, kDoNotExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_TRUE(block.empty());
@@ -256,7 +256,7 @@
   // the rest of the header block is valid.
   auto trailers = FromList({{"key", "value"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
@@ -266,7 +266,7 @@
   // even if the rest of the header block is valid.
   auto trailers = FromList({{"key", "value"}, {kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kDoNotExpectFinalByteOffset, &final_byte_offset, &block));
 }
@@ -276,7 +276,7 @@
   // present.
   auto trailers = FromList({{"key", "value"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kDoNotExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_THAT(block, UnorderedElementsAre(Pair("key", "value")));
@@ -287,7 +287,7 @@
   // valid block of trailers.
   auto trailers = FromList({{"", "value"}, {kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
@@ -297,7 +297,7 @@
   auto trailers =
       FromList({{":pseudo_key", "value"}, {kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
@@ -316,7 +316,7 @@
                             {"other_key", "value"},
                             {"key", "non_contiguous_duplicate"}});
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
       *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_THAT(
@@ -340,7 +340,7 @@
                            {"cookie", " non_contiguous_cookie!"}});
 
   size_t final_byte_offset = 0;
-  SpdyHeaderBlock block;
+  Http2HeaderBlock block;
   EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
       *headers, kExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_THAT(
@@ -354,7 +354,7 @@
 
 TEST_F(PopulateHeaderBlockFromUrl, NormalUsage) {
   std::string url = "https://www.google.com/index.html";
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   EXPECT_TRUE(SpdyUtils::PopulateHeaderBlockFromUrl(url, &headers));
   EXPECT_EQ("https", headers[":scheme"].as_string());
   EXPECT_EQ("www.google.com", headers[":authority"].as_string());
@@ -363,7 +363,7 @@
 
 TEST_F(PopulateHeaderBlockFromUrl, UrlWithNoPath) {
   std::string url = "https://www.google.com";
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   EXPECT_TRUE(SpdyUtils::PopulateHeaderBlockFromUrl(url, &headers));
   EXPECT_EQ("https", headers[":scheme"].as_string());
   EXPECT_EQ("www.google.com", headers[":authority"].as_string());
@@ -371,7 +371,7 @@
 }
 
 TEST_F(PopulateHeaderBlockFromUrl, Failure) {
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   EXPECT_FALSE(SpdyUtils::PopulateHeaderBlockFromUrl("/", &headers));
   EXPECT_FALSE(SpdyUtils::PopulateHeaderBlockFromUrl("/index.html", &headers));
   EXPECT_FALSE(
diff --git a/quiche/quic/core/http/web_transport_http3.cc b/quiche/quic/core/http/web_transport_http3.cc
index a9babe8..888331e 100644
--- a/quiche/quic/core/http/web_transport_http3.cc
+++ b/quiche/quic/core/http/web_transport_http3.cc
@@ -29,7 +29,7 @@
 
 namespace {
 class QUIC_NO_EXPORT NoopWebTransportVisitor : public WebTransportVisitor {
-  void OnSessionReady(const spdy::SpdyHeaderBlock&) override {}
+  void OnSessionReady(const spdy::Http2HeaderBlock&) override {}
   void OnSessionClosed(WebTransportSessionError /*error_code*/,
                        const std::string& /*error_message*/) override {}
   void OnIncomingBidirectionalStreamAvailable() override {}
@@ -159,7 +159,7 @@
   connect_stream_->WriteOrBufferBody("", /*fin=*/true);
 }
 
-void WebTransportHttp3::HeadersReceived(const spdy::SpdyHeaderBlock& headers) {
+void WebTransportHttp3::HeadersReceived(const spdy::Http2HeaderBlock& headers) {
   if (session_->perspective() == Perspective::IS_CLIENT) {
     int status_code;
     if (!QuicSpdyStream::ParseHeaderStatusCode(headers, &status_code)) {
diff --git a/quiche/quic/core/http/web_transport_http3.h b/quiche/quic/core/http/web_transport_http3.h
index 3924a7d..67c2fc8 100644
--- a/quiche/quic/core/http/web_transport_http3.h
+++ b/quiche/quic/core/http/web_transport_http3.h
@@ -17,7 +17,7 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -44,7 +44,7 @@
   WebTransportHttp3(QuicSpdySession* session, QuicSpdyStream* connect_stream,
                     WebTransportSessionId id);
 
-  void HeadersReceived(const spdy::SpdyHeaderBlock& headers);
+  void HeadersReceived(const spdy::Http2HeaderBlock& headers);
   void SetVisitor(std::unique_ptr<WebTransportVisitor> visitor) {
     visitor_ = std::move(visitor);
   }
diff --git a/quiche/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc b/quiche/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
index e24a647..b046565 100644
--- a/quiche/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
+++ b/quiche/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
@@ -21,7 +21,7 @@
 #include "quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "quiche/quic/test_tools/qpack/qpack_encoder_peer.h"
 #include "quiche/common/quiche_circular_deque.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace test {
diff --git a/quiche/quic/core/qpack/qpack_decoder_test.cc b/quiche/quic/core/qpack/qpack_decoder_test.cc
index e5b8504..36bc6f9 100644
--- a/quiche/quic/core/qpack/qpack_decoder_test.cc
+++ b/quiche/quic/core/qpack/qpack_decoder_test.cc
@@ -13,7 +13,6 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
-#include "quiche/spdy/core/spdy_header_block.h"
 
 using ::testing::_;
 using ::testing::Eq;
diff --git a/quiche/quic/core/qpack/qpack_encoder.h b/quiche/quic/core/qpack/qpack_encoder.h
index a47e925..abd72ce 100644
--- a/quiche/quic/core/qpack/qpack_encoder.h
+++ b/quiche/quic/core/qpack/qpack_encoder.h
@@ -20,7 +20,7 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/platform/api/quic_exported_stats.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 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 00a18c5..1ed12e9 100644
--- a/quiche/quic/core/qpack/qpack_round_trip_test.cc
+++ b/quiche/quic/core/qpack/qpack_round_trip_test.cc
@@ -10,7 +10,7 @@
 #include "quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h"
 #include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 using ::testing::Values;
 
diff --git a/quiche/quic/core/qpack/value_splitting_header_list.h b/quiche/quic/core/qpack/value_splitting_header_list.h
index cc9939a..e275033 100644
--- a/quiche/quic/core/qpack/value_splitting_header_list.h
+++ b/quiche/quic/core/qpack/value_splitting_header_list.h
@@ -7,7 +7,7 @@
 
 #include "absl/strings/string_view.h"
 #include "quiche/quic/platform/api/quic_export.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/core/web_transport_interface.h b/quiche/quic/core/web_transport_interface.h
index ea8747d..bfccf7d 100644
--- a/quiche/quic/core/web_transport_interface.h
+++ b/quiche/quic/core/web_transport_interface.h
@@ -17,7 +17,7 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -94,7 +94,7 @@
 
   // Notifies the visitor when the session is ready to exchange application
   // data.
-  virtual void OnSessionReady(const spdy::SpdyHeaderBlock& headers) = 0;
+  virtual void OnSessionReady(const spdy::Http2HeaderBlock& headers) = 0;
 
   // Notifies the visitor when the session has been closed.
   virtual void OnSessionClosed(WebTransportSessionError error_code,
diff --git a/quiche/quic/masque/masque_client_session.cc b/quiche/quic/masque/masque_client_session.cc
index 28ba839..03d2cfb 100644
--- a/quiche/quic/masque/masque_client_session.cc
+++ b/quiche/quic/masque/masque_client_session.cc
@@ -19,6 +19,7 @@
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/tools/quic_url.h"
 #include "quiche/common/platform/api/quiche_url_utils.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/masque/masque_client_tools.cc b/quiche/quic/masque/masque_client_tools.cc
index 92fd9d7..2c21a77 100644
--- a/quiche/quic/masque/masque_client_tools.cc
+++ b/quiche/quic/masque/masque_client_tools.cc
@@ -9,6 +9,7 @@
 #include "quiche/quic/platform/api/quic_default_proof_providers.h"
 #include "quiche/quic/tools/fake_proof_verifier.h"
 #include "quiche/quic/tools/quic_url.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace tools {
diff --git a/quiche/quic/masque/masque_server_backend.h b/quiche/quic/masque/masque_server_backend.h
index a862097..cb4b067 100644
--- a/quiche/quic/masque/masque_server_backend.h
+++ b/quiche/quic/masque/masque_server_backend.h
@@ -9,6 +9,7 @@
 #include "quiche/quic/masque/masque_utils.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/tools/quic_memory_cache_backend.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/masque/masque_server_session.h b/quiche/quic/masque/masque_server_session.h
index d820137..20b85a1 100644
--- a/quiche/quic/masque/masque_server_session.h
+++ b/quiche/quic/masque/masque_server_session.h
@@ -12,6 +12,7 @@
 #include "quiche/quic/masque/masque_utils.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/tools/quic_simple_server_session.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/test_tools/mock_quic_client_promised_info.h b/quiche/quic/test_tools/mock_quic_client_promised_info.h
index 3dca99e..acaefef 100644
--- a/quiche/quic/test_tools/mock_quic_client_promised_info.h
+++ b/quiche/quic/test_tools/mock_quic_client_promised_info.h
@@ -10,6 +10,7 @@
 #include "quiche/quic/core/http/quic_client_promised_info.h"
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace test {
@@ -21,7 +22,7 @@
   ~MockQuicClientPromisedInfo() override;
 
   MOCK_METHOD(QuicAsyncStatus, HandleClientRequest,
-              (const spdy::SpdyHeaderBlock& headers,
+              (const spdy::Http2HeaderBlock& headers,
                QuicClientPushPromiseIndex::Delegate*),
               (override));
 };
diff --git a/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h b/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h
index e3b9680..90da363 100644
--- a/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h
+++ b/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h
@@ -13,7 +13,7 @@
 #include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace test {
diff --git a/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h b/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h
index fc4621f..8226342 100644
--- a/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h
+++ b/quiche/quic/test_tools/qpack/qpack_encoder_test_utils.h
@@ -11,7 +11,6 @@
 #include "quiche/quic/core/qpack/qpack_encoder.h"
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
-#include "quiche/spdy/core/spdy_header_block.h"
 
 namespace quic {
 namespace test {
diff --git a/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc b/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc
index 9901a70..282e33f 100644
--- a/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc
+++ b/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -323,7 +323,7 @@
       ++decoded_it;
       continue;
     }
-    // SpdyHeaderBlock does not support erasing by iterator, only by key.
+    // Http2HeaderBlock does not support erasing by iterator, only by key.
     ++decoded_it;
     expected_header_list.erase(key);
     // This will invalidate |key|.
diff --git a/quiche/quic/test_tools/qpack/qpack_offline_decoder.h b/quiche/quic/test_tools/qpack/qpack_offline_decoder.h
index 71cb92a..07fa276 100644
--- a/quiche/quic/test_tools/qpack/qpack_offline_decoder.h
+++ b/quiche/quic/test_tools/qpack/qpack_offline_decoder.h
@@ -12,7 +12,7 @@
 #include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/test_tools/quic_spdy_session_peer.cc b/quiche/quic/test_tools/quic_spdy_session_peer.cc
index 62348cb..ea92067 100644
--- a/quiche/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quiche/quic/test_tools/quic_spdy_session_peer.cc
@@ -46,7 +46,7 @@
 
 // static
 size_t QuicSpdySessionPeer::WriteHeadersOnHeadersStream(
-    QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
+    QuicSpdySession* session, QuicStreamId id, spdy::Http2HeaderBlock headers,
     bool fin, const spdy::SpdyStreamPrecedence& precedence,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
diff --git a/quiche/quic/test_tools/quic_spdy_session_peer.h b/quiche/quic/test_tools/quic_spdy_session_peer.h
index d87104f..87d38ee 100644
--- a/quiche/quic/test_tools/quic_spdy_session_peer.h
+++ b/quiche/quic/test_tools/quic_spdy_session_peer.h
@@ -12,6 +12,7 @@
 #include "quiche/quic/core/qpack/qpack_send_stream.h"
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/core/quic_write_blocked_list.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -32,7 +33,7 @@
   static void SetMaxInboundHeaderListSize(QuicSpdySession* session,
                                           size_t max_inbound_header_size);
   static size_t WriteHeadersOnHeadersStream(
-      QuicSpdySession* session, QuicStreamId id, spdy::SpdyHeaderBlock headers,
+      QuicSpdySession* session, QuicStreamId id, spdy::Http2HeaderBlock headers,
       bool fin, const spdy::SpdyStreamPrecedence& precedence,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
diff --git a/quiche/quic/test_tools/quic_test_backend.cc b/quiche/quic/test_tools/quic_test_backend.cc
index 756c560..983db8e 100644
--- a/quiche/quic/test_tools/quic_test_backend.cc
+++ b/quiche/quic/test_tools/quic_test_backend.cc
@@ -28,7 +28,7 @@
  public:
   SessionCloseVisitor(WebTransportSession* session) : session_(session) {}
 
-  void OnSessionReady(const spdy::SpdyHeaderBlock& /*headers*/) override {}
+  void OnSessionReady(const spdy::Http2HeaderBlock& /*headers*/) override {}
   void OnSessionClosed(WebTransportSessionError /*error_code*/,
                        const std::string& /*error_message*/) override {}
 
diff --git a/quiche/quic/test_tools/quic_test_backend.h b/quiche/quic/test_tools/quic_test_backend.h
index 33549cc..e59eb91 100644
--- a/quiche/quic/test_tools/quic_test_backend.h
+++ b/quiche/quic/test_tools/quic_test_backend.h
@@ -7,6 +7,7 @@
 
 #include "quiche/quic/tools/quic_memory_cache_backend.h"
 #include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace test {
diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
index cffcfa2..9a834c8 100644
--- a/quiche/quic/test_tools/quic_test_client.cc
+++ b/quiche/quic/test_tools/quic_test_client.cc
@@ -373,7 +373,7 @@
 }
 
 ssize_t QuicTestClient::SendRequest(const std::string& uri) {
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
     return 0;
   }
@@ -381,7 +381,7 @@
 }
 
 ssize_t QuicTestClient::SendRequestAndRstTogether(const std::string& uri) {
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
     return 0;
   }
@@ -406,7 +406,7 @@
 }
 
 ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
-    const spdy::SpdyHeaderBlock* headers, absl::string_view body, bool fin,
+    const spdy::Http2HeaderBlock* headers, absl::string_view body, bool fin,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
   if (headers) {
@@ -416,8 +416,8 @@
     if (rv == QUIC_SUCCESS) return 1;
     if (rv == QUIC_PENDING) {
       // May need to retry request if asynchronous rendezvous fails.
-      std::unique_ptr<spdy::SpdyHeaderBlock> new_headers(
-          new spdy::SpdyHeaderBlock(headers->Clone()));
+      std::unique_ptr<spdy::Http2HeaderBlock> new_headers(
+          new spdy::Http2HeaderBlock(headers->Clone()));
       push_promise_data_to_resend_ = std::make_unique<TestClientDataToResend>(
           std::move(new_headers), body, fin, this, std::move(ack_listener));
       return 1;
@@ -435,7 +435,7 @@
 
   ssize_t ret = 0;
   if (headers != nullptr) {
-    spdy::SpdyHeaderBlock spdy_headers(headers->Clone());
+    spdy::Http2HeaderBlock spdy_headers(headers->Clone());
     if (spdy_headers[":authority"].as_string().empty()) {
       spdy_headers[":authority"] = client_->server_id().host();
     }
@@ -448,17 +448,17 @@
   return ret;
 }
 
-ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
+ssize_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
                                     absl::string_view body) {
   return SendMessage(headers, body, /*fin=*/true);
 }
 
-ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
+ssize_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
                                     absl::string_view body, bool fin) {
   return SendMessage(headers, body, fin, /*flush=*/true);
 }
 
-ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
+ssize_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
                                     absl::string_view body, bool fin,
                                     bool flush) {
   // Always force creation of a stream for SendMessage.
@@ -499,7 +499,7 @@
 const std::string& QuicTestClient::response_body() const { return response_; }
 
 std::string QuicTestClient::SendCustomSynchronousRequest(
-    const spdy::SpdyHeaderBlock& headers, const std::string& body) {
+    const spdy::Http2HeaderBlock& headers, const std::string& body) {
   // Clear connection state here and only track this synchronous request.
   ClearPerConnectionState();
   if (SendMessage(headers, body) == 0) {
@@ -514,7 +514,7 @@
 }
 
 std::string QuicTestClient::SendSynchronousRequest(const std::string& uri) {
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
     return "";
   }
@@ -674,7 +674,7 @@
   return response_headers_complete_;
 }
 
-const spdy::SpdyHeaderBlock* QuicTestClient::response_headers() const {
+const spdy::Http2HeaderBlock* QuicTestClient::response_headers() const {
   for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
     if (stream.second->headers_decompressed()) {
       response_headers_ = stream.second->response_headers().Clone();
@@ -684,7 +684,7 @@
   return &response_headers_;
 }
 
-const spdy::SpdyHeaderBlock* QuicTestClient::preliminary_headers() const {
+const spdy::Http2HeaderBlock* QuicTestClient::preliminary_headers() const {
   for (std::pair<QuicStreamId, QuicSpdyClientStream*> stream : open_streams_) {
     size_t bytes_read =
         stream.second->stream_bytes_read() + stream.second->header_bytes_read();
@@ -696,7 +696,7 @@
   return &preliminary_headers_;
 }
 
-const spdy::SpdyHeaderBlock& QuicTestClient::response_trailers() const {
+const spdy::Http2HeaderBlock& QuicTestClient::response_trailers() const {
   return response_trailers_;
 }
 
@@ -761,9 +761,9 @@
 }
 
 bool QuicTestClient::CheckVary(
-    const spdy::SpdyHeaderBlock& /*client_request*/,
-    const spdy::SpdyHeaderBlock& /*promise_request*/,
-    const spdy::SpdyHeaderBlock& /*promise_response*/) {
+    const spdy::Http2HeaderBlock& /*client_request*/,
+    const spdy::Http2HeaderBlock& /*promise_request*/,
+    const spdy::Http2HeaderBlock& /*promise_response*/) {
   return true;
 }
 
@@ -833,7 +833,7 @@
 }
 
 QuicTestClient::TestClientDataToResend::TestClientDataToResend(
-    std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+    std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
     bool fin, QuicTestClient* test_client,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener)
@@ -864,10 +864,11 @@
 QuicTestClient::PerStreamState::PerStreamState(
     QuicRstStreamErrorCode stream_error, bool response_complete,
     bool response_headers_complete,
-    const spdy::SpdyHeaderBlock& response_headers,
-    const spdy::SpdyHeaderBlock& preliminary_headers,
-    const std::string& response, const spdy::SpdyHeaderBlock& response_trailers,
-    uint64_t bytes_read, uint64_t bytes_written, int64_t response_body_size)
+    const spdy::Http2HeaderBlock& response_headers,
+    const spdy::Http2HeaderBlock& preliminary_headers,
+    const std::string& response,
+    const spdy::Http2HeaderBlock& response_trailers, uint64_t bytes_read,
+    uint64_t bytes_written, int64_t response_body_size)
     : stream_error(stream_error),
       response_complete(response_complete),
       response_headers_complete(response_headers_complete),
@@ -882,7 +883,7 @@
 QuicTestClient::PerStreamState::~PerStreamState() = default;
 
 bool QuicTestClient::PopulateHeaderBlockFromUrl(
-    const std::string& uri, spdy::SpdyHeaderBlock* headers) {
+    const std::string& uri, spdy::Http2HeaderBlock* headers) {
   std::string url;
   if (absl::StartsWith(uri, "https://") || absl::StartsWith(uri, "http://")) {
     url = uri;
diff --git a/quiche/quic/test_tools/quic_test_client.h b/quiche/quic/test_tools/quic_test_client.h
index 078f96b..1ba088e 100644
--- a/quiche/quic/test_tools/quic_test_client.h
+++ b/quiche/quic/test_tools/quic_test_client.h
@@ -18,6 +18,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/tools/quic_client.h"
 #include "quiche/common/quiche_linked_hash_map.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -133,23 +134,23 @@
       const std::vector<std::string>& url_list);
   // Sends a request containing |headers| and |body| and returns the number of
   // bytes sent (the size of the serialized request headers and body).
-  ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
+  ssize_t SendMessage(const spdy::Http2HeaderBlock& headers,
                       absl::string_view body);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body).
-  ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
+  ssize_t SendMessage(const spdy::Http2HeaderBlock& headers,
                       absl::string_view body, bool fin);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body). If |flush| is true, will wait for the message to
   // be flushed before returning.
-  ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
+  ssize_t SendMessage(const spdy::Http2HeaderBlock& headers,
                       absl::string_view body, bool fin, bool flush);
   // Sends a request containing |headers| and |body|, waits for the response,
   // and returns the response body.
-  std::string SendCustomSynchronousRequest(const spdy::SpdyHeaderBlock& headers,
-                                           const std::string& body);
+  std::string SendCustomSynchronousRequest(
+      const spdy::Http2HeaderBlock& headers, const std::string& body);
   // Sends a GET request for |uri|, waits for the response, and returns the
   // response body.
   std::string SendSynchronousRequest(const std::string& uri);
@@ -170,14 +171,14 @@
   // is received. 2) returns state of the oldest active stream which have
   // received partial response (if any).
   // Group 1.
-  const spdy::SpdyHeaderBlock& response_trailers() const;
+  const spdy::Http2HeaderBlock& response_trailers() const;
   bool response_complete() const;
   int64_t response_body_size() const;
   const std::string& response_body() const;
   // Group 2.
   bool response_headers_complete() const;
-  const spdy::SpdyHeaderBlock* response_headers() const;
-  const spdy::SpdyHeaderBlock* preliminary_headers() const;
+  const spdy::Http2HeaderBlock* response_headers() const;
+  const spdy::Http2HeaderBlock* preliminary_headers() const;
   int64_t response_size() const;
   size_t bytes_read() const;
   size_t bytes_written() const;
@@ -225,9 +226,9 @@
   void OnClose(QuicSpdyStream* stream) override;
 
   // From QuicClientPushPromiseIndex::Delegate
-  bool CheckVary(const spdy::SpdyHeaderBlock& client_request,
-                 const spdy::SpdyHeaderBlock& promise_request,
-                 const spdy::SpdyHeaderBlock& promise_response) override;
+  bool CheckVary(const spdy::Http2HeaderBlock& client_request,
+                 const spdy::Http2HeaderBlock& promise_request,
+                 const spdy::Http2HeaderBlock& promise_response) override;
   void OnRendezvousResult(QuicSpdyStream*) override;
 
   // Configures client_ to take ownership of and use the writer.
@@ -253,7 +254,7 @@
   // stores the request in case it needs to be resent.  If |headers| is
   // null, only the body will be sent on the stream.
   ssize_t GetOrCreateStreamAndSendRequest(
-      const spdy::SpdyHeaderBlock* headers, absl::string_view body, bool fin,
+      const spdy::Http2HeaderBlock* headers, absl::string_view body, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
 
@@ -309,7 +310,7 @@
   // request. If |uri| is a relative URL, the QuicServerId will be
   // use to specify the authority.
   bool PopulateHeaderBlockFromUrl(const std::string& uri,
-                                  spdy::SpdyHeaderBlock* headers);
+                                  spdy::Http2HeaderBlock* headers);
 
   // Waits for a period of time that is long enough to receive all delayed acks
   // sent by peer.
@@ -330,7 +331,7 @@
   class TestClientDataToResend : public QuicClient::QuicDataToResend {
    public:
     TestClientDataToResend(
-        std::unique_ptr<spdy::SpdyHeaderBlock> headers, absl::string_view body,
+        std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
         bool fin, QuicTestClient* test_client,
         quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
             ack_listener);
@@ -350,10 +351,10 @@
     PerStreamState(const PerStreamState& other);
     PerStreamState(QuicRstStreamErrorCode stream_error, bool response_complete,
                    bool response_headers_complete,
-                   const spdy::SpdyHeaderBlock& response_headers,
-                   const spdy::SpdyHeaderBlock& preliminary_headers,
+                   const spdy::Http2HeaderBlock& response_headers,
+                   const spdy::Http2HeaderBlock& preliminary_headers,
                    const std::string& response,
-                   const spdy::SpdyHeaderBlock& response_trailers,
+                   const spdy::Http2HeaderBlock& response_trailers,
                    uint64_t bytes_read, uint64_t bytes_written,
                    int64_t response_body_size);
     ~PerStreamState();
@@ -361,10 +362,10 @@
     QuicRstStreamErrorCode stream_error;
     bool response_complete;
     bool response_headers_complete;
-    spdy::SpdyHeaderBlock response_headers;
-    spdy::SpdyHeaderBlock preliminary_headers;
+    spdy::Http2HeaderBlock response_headers;
+    spdy::Http2HeaderBlock preliminary_headers;
     std::string response;
-    spdy::SpdyHeaderBlock response_trailers;
+    spdy::Http2HeaderBlock response_trailers;
     uint64_t bytes_read;
     uint64_t bytes_written;
     int64_t response_body_size;
@@ -395,11 +396,11 @@
 
   bool response_complete_;
   bool response_headers_complete_;
-  mutable spdy::SpdyHeaderBlock preliminary_headers_;
-  mutable spdy::SpdyHeaderBlock response_headers_;
+  mutable spdy::Http2HeaderBlock preliminary_headers_;
+  mutable spdy::Http2HeaderBlock response_headers_;
 
   // Parsed response trailers (if present), copied from the stream in OnClose.
-  spdy::SpdyHeaderBlock response_trailers_;
+  spdy::Http2HeaderBlock response_trailers_;
 
   spdy::SpdyPriority priority_;
   std::string response_;
diff --git a/quiche/quic/test_tools/quic_test_utils.cc b/quiche/quic/test_tools/quic_test_utils.cc
index e52130e..cfb947a 100644
--- a/quiche/quic/test_tools/quic_test_utils.cc
+++ b/quiche/quic/test_tools/quic_test_utils.cc
@@ -771,9 +771,9 @@
     : match_(match), rendezvous_fired_(false), rendezvous_stream_(nullptr) {}
 
 bool TestPushPromiseDelegate::CheckVary(
-    const spdy::SpdyHeaderBlock& /*client_request*/,
-    const spdy::SpdyHeaderBlock& /*promise_request*/,
-    const spdy::SpdyHeaderBlock& /*promise_response*/) {
+    const spdy::Http2HeaderBlock& /*client_request*/,
+    const spdy::Http2HeaderBlock& /*promise_request*/,
+    const spdy::Http2HeaderBlock& /*promise_response*/) {
   QUIC_DVLOG(1) << "match " << match_;
   return match_;
 }
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index b649fc4..7340e7e 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -42,6 +42,7 @@
 #include "quiche/quic/test_tools/simple_quic_framer.h"
 #include "quiche/common/quiche_mem_slice_storage.h"
 #include "quiche/common/simple_buffer_allocator.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -1006,7 +1007,7 @@
 
   MOCK_METHOD(void, OnDataFrameSent, (QuicStreamId, QuicByteCount), (override));
   MOCK_METHOD(void, OnHeadersFrameSent,
-              (QuicStreamId, const spdy::SpdyHeaderBlock&), (override));
+              (QuicStreamId, const spdy::Http2HeaderBlock&), (override));
 };
 
 class TestQuicSpdyServerSession : public QuicServerSessionBase {
@@ -1077,9 +1078,9 @@
   // fields match for promise request and client request.
   explicit TestPushPromiseDelegate(bool match);
 
-  bool CheckVary(const spdy::SpdyHeaderBlock& client_request,
-                 const spdy::SpdyHeaderBlock& promise_request,
-                 const spdy::SpdyHeaderBlock& promise_response) override;
+  bool CheckVary(const spdy::Http2HeaderBlock& client_request,
+                 const spdy::Http2HeaderBlock& promise_request,
+                 const spdy::Http2HeaderBlock& promise_response) override;
 
   void OnRendezvousResult(QuicSpdyStream* stream) override;
 
diff --git a/quiche/quic/test_tools/web_transport_resets_backend.cc b/quiche/quic/test_tools/web_transport_resets_backend.cc
index aa48dd6..63bb842 100644
--- a/quiche/quic/test_tools/web_transport_resets_backend.cc
+++ b/quiche/quic/test_tools/web_transport_resets_backend.cc
@@ -36,7 +36,7 @@
  public:
   ResetsVisitor(WebTransportSession* session) : session_(session) {}
 
-  void OnSessionReady(const spdy::SpdyHeaderBlock& /*headers*/) override {}
+  void OnSessionReady(const spdy::Http2HeaderBlock& /*headers*/) override {}
   void OnSessionClosed(WebTransportSessionError /*error_code*/,
                        const std::string& /*error_message*/) override {}
 
diff --git a/quiche/quic/test_tools/web_transport_resets_backend.h b/quiche/quic/test_tools/web_transport_resets_backend.h
index d3b490c..c5ffbe0 100644
--- a/quiche/quic/test_tools/web_transport_resets_backend.h
+++ b/quiche/quic/test_tools/web_transport_resets_backend.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_TEST_TOOLS_WEB_TRANSPORT_RESETS_BACKEND_H_
 
 #include "quiche/quic/test_tools/quic_test_backend.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace test {
diff --git a/quiche/quic/test_tools/web_transport_test_tools.h b/quiche/quic/test_tools/web_transport_test_tools.h
index 3a4603c..353b48f 100644
--- a/quiche/quic/test_tools/web_transport_test_tools.h
+++ b/quiche/quic/test_tools/web_transport_test_tools.h
@@ -7,13 +7,15 @@
 
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 namespace test {
 
 class MockWebTransportSessionVisitor : public WebTransportVisitor {
  public:
-  MOCK_METHOD(void, OnSessionReady, (const spdy::SpdyHeaderBlock&), (override));
+  MOCK_METHOD(void, OnSessionReady, (const spdy::Http2HeaderBlock&),
+              (override));
   MOCK_METHOD(void, OnSessionClosed,
               (WebTransportSessionError, const std::string&), (override));
   MOCK_METHOD(void, OnIncomingBidirectionalStreamAvailable, (), (override));
diff --git a/quiche/quic/tools/quic_backend_response.h b/quiche/quic/tools/quic_backend_response.h
index 3ee4bf4..8e52e2e 100644
--- a/quiche/quic/tools/quic_backend_response.h
+++ b/quiche/quic/tools/quic_backend_response.h
@@ -7,6 +7,7 @@
 
 #include "absl/strings/string_view.h"
 #include "quiche/quic/tools/quic_url.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
 namespace quic {
diff --git a/quiche/quic/tools/quic_client_interop_test_bin.cc b/quiche/quic/tools/quic_client_interop_test_bin.cc
index 9a29afe..7d204bb 100644
--- a/quiche/quic/tools/quic_client_interop_test_bin.cc
+++ b/quiche/quic/tools/quic_client_interop_test_bin.cc
@@ -20,6 +20,7 @@
 #include "quiche/quic/tools/quic_url.h"
 #include "quiche/common/platform/api/quiche_command_line_flags.h"
 #include "quiche/common/platform/api/quiche_system_event_loop.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, host, "",
                                 "The IP or hostname to connect to.");
@@ -113,8 +114,8 @@
                       bool test_version_negotiation, bool attempt_rebind,
                       bool attempt_multi_packet_chlo, bool attempt_key_update);
 
-  // Constructs a SpdyHeaderBlock containing the pseudo-headers needed to make a
-  // GET request to "/" on the hostname |authority|.
+  // Constructs a Http2HeaderBlock containing the pseudo-headers needed to make
+  // a GET request to "/" on the hostname |authority|.
   spdy::Http2HeaderBlock ConstructHeaderBlock(const std::string& authority);
 
   // Sends an HTTP request represented by |header_block| using |client|.
diff --git a/quiche/quic/tools/quic_memory_cache_backend.h b/quiche/quic/tools/quic_memory_cache_backend.h
index 1738e3c..7dfd372 100644
--- a/quiche/quic/tools/quic_memory_cache_backend.h
+++ b/quiche/quic/tools/quic_memory_cache_backend.h
@@ -17,6 +17,7 @@
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
 #include "quiche/quic/tools/quic_url.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
diff --git a/quiche/quic/tools/quic_simple_server_backend.h b/quiche/quic/tools/quic_simple_server_backend.h
index c603468..bbb0d93 100644
--- a/quiche/quic/tools/quic_simple_server_backend.h
+++ b/quiche/quic/tools/quic_simple_server_backend.h
@@ -14,7 +14,7 @@
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/quic/tools/quic_backend_response.h"
-#include "quiche/spdy/core/spdy_header_block.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/tools/quic_simple_server_session.h b/quiche/quic/tools/quic_simple_server_session.h
index 0530ce2..f9490bd 100644
--- a/quiche/quic/tools/quic_simple_server_session.h
+++ b/quiche/quic/tools/quic_simple_server_session.h
@@ -23,6 +23,7 @@
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
 #include "quiche/quic/tools/quic_simple_server_stream.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/tools/quic_simple_server_stream.h b/quiche/quic/tools/quic_simple_server_stream.h
index fc94819..6305240 100644
--- a/quiche/quic/tools/quic_simple_server_stream.h
+++ b/quiche/quic/tools/quic_simple_server_stream.h
@@ -14,6 +14,7 @@
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
diff --git a/quiche/quic/tools/quic_simple_server_stream_test.cc b/quiche/quic/tools/quic_simple_server_stream_test.cc
index 5d9ff15..f9aef38 100644
--- a/quiche/quic/tools/quic_simple_server_stream_test.cc
+++ b/quiche/quic/tools/quic_simple_server_stream_test.cc
@@ -33,7 +33,6 @@
 #include "quiche/quic/tools/quic_simple_server_backend.h"
 #include "quiche/quic/tools/quic_simple_server_session.h"
 #include "quiche/common/simple_buffer_allocator.h"
-#include "quiche/spdy/core/spdy_header_block.h"
 
 using testing::_;
 using testing::AnyNumber;
diff --git a/quiche/quic/tools/quic_spdy_client_base.h b/quiche/quic/tools/quic_spdy_client_base.h
index a6c4a4a..aad229a 100644
--- a/quiche/quic/tools/quic_spdy_client_base.h
+++ b/quiche/quic/tools/quic_spdy_client_base.h
@@ -18,6 +18,7 @@
 #include "quiche/quic/core/quic_config.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/tools/quic_client_base.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/tools/quic_toy_client.cc b/quiche/quic/tools/quic_toy_client.cc
index 790e263..ea7f87e 100644
--- a/quiche/quic/tools/quic_toy_client.cc
+++ b/quiche/quic/tools/quic_toy_client.cc
@@ -64,6 +64,7 @@
 #include "quiche/quic/tools/quic_url.h"
 #include "quiche/common/platform/api/quiche_command_line_flags.h"
 #include "quiche/common/quiche_text_utils.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace {
 
diff --git a/quiche/quic/tools/web_transport_test_visitors.h b/quiche/quic/tools/web_transport_test_visitors.h
index e5b7fef..c7630e4 100644
--- a/quiche/quic/tools/web_transport_test_visitors.h
+++ b/quiche/quic/tools/web_transport_test_visitors.h
@@ -13,6 +13,7 @@
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/common/quiche_circular_deque.h"
 #include "quiche/common/simple_buffer_allocator.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -175,7 +176,7 @@
   EchoWebTransportSessionVisitor(WebTransportSession* session)
       : session_(session) {}
 
-  void OnSessionReady(const spdy::SpdyHeaderBlock&) override {
+  void OnSessionReady(const spdy::Http2HeaderBlock&) override {
     if (session_->CanOpenNextOutgoingBidirectionalStream()) {
       OnCanCreateNewOutgoingBidirectionalStream();
     }