diff --git a/quiche/quic/tools/connect_server_backend.cc b/quiche/quic/tools/connect_server_backend.cc
index ba17bea..c0a0771 100644
--- a/quiche/quic/tools/connect_server_backend.cc
+++ b/quiche/quic/tools/connect_server_backend.cc
@@ -15,9 +15,9 @@
 #include "quiche/quic/tools/connect_tunnel.h"
 #include "quiche/quic/tools/connect_udp_tunnel.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -25,7 +25,7 @@
 
 void SendErrorResponse(QuicSimpleServerBackend::RequestHandler* request_handler,
                        absl::string_view error_code) {
-  spdy::Http2HeaderBlock headers;
+  quiche::HttpHeaderBlock headers;
   headers[":status"] = error_code;
   QuicBackendResponse response;
   response.set_headers(std::move(headers));
@@ -69,7 +69,7 @@
 }
 
 void ConnectServerBackend::FetchResponseFromBackend(
-    const spdy::Http2HeaderBlock& request_headers,
+    const quiche::HttpHeaderBlock& request_headers,
     const std::string& request_body, RequestHandler* request_handler) {
   // Not a CONNECT request, so send to `non_connect_backend_`.
   non_connect_backend_->FetchResponseFromBackend(request_headers, request_body,
@@ -77,7 +77,7 @@
 }
 
 void ConnectServerBackend::HandleConnectHeaders(
-    const spdy::Http2HeaderBlock& request_headers,
+    const quiche::HttpHeaderBlock& request_headers,
     RequestHandler* request_handler) {
   QUICHE_DCHECK(request_headers.contains(":method") &&
                 request_headers.find(":method")->second == "CONNECT");
diff --git a/quiche/quic/tools/connect_server_backend.h b/quiche/quic/tools/connect_server_backend.h
index 4aa8967..9eda5ed 100644
--- a/quiche/quic/tools/connect_server_backend.h
+++ b/quiche/quic/tools/connect_server_backend.h
@@ -42,10 +42,10 @@
   bool InitializeBackend(const std::string& backend_url) override;
   bool IsBackendInitialized() const override;
   void SetSocketFactory(SocketFactory* socket_factory) override;
-  void FetchResponseFromBackend(const spdy::Http2HeaderBlock& request_headers,
+  void FetchResponseFromBackend(const quiche::HttpHeaderBlock& request_headers,
                                 const std::string& request_body,
                                 RequestHandler* request_handler) override;
-  void HandleConnectHeaders(const spdy::Http2HeaderBlock& request_headers,
+  void HandleConnectHeaders(const quiche::HttpHeaderBlock& request_headers,
                             RequestHandler* request_handler) override;
   void HandleConnectData(absl::string_view data, bool data_complete,
                          RequestHandler* request_handler) override;
diff --git a/quiche/quic/tools/connect_tunnel.cc b/quiche/quic/tools/connect_tunnel.cc
index 22f6c3b..11f2eff 100644
--- a/quiche/quic/tools/connect_tunnel.cc
+++ b/quiche/quic/tools/connect_tunnel.cc
@@ -23,9 +23,9 @@
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_name_lookup.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -35,7 +35,7 @@
 constexpr size_t kReadSize = 4 * 1024;
 
 std::optional<QuicServerId> ValidateHeadersAndGetAuthority(
-    const spdy::Http2HeaderBlock& request_headers) {
+    const quiche::HttpHeaderBlock& request_headers) {
   QUICHE_DCHECK(request_headers.contains(":method"));
   QUICHE_DCHECK(request_headers.find(":method")->second == "CONNECT");
   QUICHE_DCHECK(!request_headers.contains(":protocol"));
@@ -108,7 +108,7 @@
   QUICHE_DCHECK(!receive_started_);
 }
 
-void ConnectTunnel::OpenTunnel(const spdy::Http2HeaderBlock& request_headers) {
+void ConnectTunnel::OpenTunnel(const quiche::HttpHeaderBlock& request_headers) {
   QUICHE_DCHECK(!IsConnectedToDestination());
 
   std::optional<QuicServerId> authority =
@@ -266,7 +266,7 @@
   QUICHE_DCHECK(IsConnectedToDestination());
   QUICHE_DCHECK(client_stream_request_handler_);
 
-  spdy::Http2HeaderBlock response_headers;
+  quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
 
   QuicBackendResponse response;
diff --git a/quiche/quic/tools/connect_tunnel.h b/quiche/quic/tools/connect_tunnel.h
index 259f125..ecde8b7 100644
--- a/quiche/quic/tools/connect_tunnel.h
+++ b/quiche/quic/tools/connect_tunnel.h
@@ -19,8 +19,8 @@
 #include "quiche/quic/core/quic_server_id.h"
 #include "quiche/quic/core/socket_factory.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -41,7 +41,7 @@
   // appropriate success/error response to the request stream. `request_headers`
   // must represent headers from a CONNECT request, that is ":method"="CONNECT"
   // and no ":protocol".
-  void OpenTunnel(const spdy::Http2HeaderBlock& request_headers);
+  void OpenTunnel(const quiche::HttpHeaderBlock& request_headers);
 
   // Returns true iff the connection to the destination server is currently open
   bool IsConnectedToDestination() const;
diff --git a/quiche/quic/tools/connect_tunnel_test.cc b/quiche/quic/tools/connect_tunnel_test.cc
index 9387502..eca60a7 100644
--- a/quiche/quic/tools/connect_tunnel_test.cc
+++ b/quiche/quic/tools/connect_tunnel_test.cc
@@ -24,9 +24,9 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic::test {
 namespace {
@@ -140,7 +140,7 @@
     tunnel_.ReceiveComplete(absl::CancelledError());
   }));
 
-  spdy::Http2HeaderBlock expected_response_headers;
+  quiche::HttpHeaderBlock expected_response_headers;
   expected_response_headers[":status"] = "200";
   QuicBackendResponse expected_response;
   expected_response.set_headers(std::move(expected_response_headers));
@@ -154,7 +154,7 @@
                         Property(&QuicBackendResponse::trailers, IsEmpty()),
                         Property(&QuicBackendResponse::body, IsEmpty()))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat(kAcceptableDestination, ":", kAcceptablePort);
@@ -172,7 +172,7 @@
     tunnel_.ReceiveComplete(absl::CancelledError());
   }));
 
-  spdy::Http2HeaderBlock expected_response_headers;
+  quiche::HttpHeaderBlock expected_response_headers;
   expected_response_headers[":status"] = "200";
   QuicBackendResponse expected_response;
   expected_response.set_headers(std::move(expected_response_headers));
@@ -186,7 +186,7 @@
                         Property(&QuicBackendResponse::trailers, IsEmpty()),
                         Property(&QuicBackendResponse::body, IsEmpty()))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat(TestLoopback4().ToString(), ":", kAcceptablePort);
@@ -204,7 +204,7 @@
     tunnel_.ReceiveComplete(absl::CancelledError());
   }));
 
-  spdy::Http2HeaderBlock expected_response_headers;
+  quiche::HttpHeaderBlock expected_response_headers;
   expected_response_headers[":status"] = "200";
   QuicBackendResponse expected_response;
   expected_response.set_headers(std::move(expected_response_headers));
@@ -218,7 +218,7 @@
                         Property(&QuicBackendResponse::trailers, IsEmpty()),
                         Property(&QuicBackendResponse::body, IsEmpty()))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat("[", TestLoopback6().ToString(), "]:", kAcceptablePort);
@@ -235,7 +235,7 @@
                   &QuicResetStreamError::ietf_application_code,
                   static_cast<uint64_t>(QuicHttp3ErrorCode::MESSAGE_ERROR))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   // No ":authority" header.
 
@@ -251,7 +251,7 @@
           &QuicResetStreamError::ietf_application_code,
           static_cast<uint64_t>(QuicHttp3ErrorCode::REQUEST_REJECTED))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] = "unacceptable.test:100";
 
@@ -273,7 +273,7 @@
 
   EXPECT_CALL(request_handler_, SendStreamData(kData, /*close_stream=*/false));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat(kAcceptableDestination, ":", kAcceptablePort);
@@ -299,7 +299,7 @@
 
   EXPECT_CALL(request_handler_, OnResponseBackendComplete(_));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat(kAcceptableDestination, ":", kAcceptablePort);
@@ -317,7 +317,7 @@
   EXPECT_CALL(request_handler_, OnResponseBackendComplete(_));
   EXPECT_CALL(request_handler_, SendStreamData("", /*close_stream=*/true));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat(kAcceptableDestination, ":", kAcceptablePort);
@@ -343,7 +343,7 @@
                   &QuicResetStreamError::ietf_application_code,
                   static_cast<uint64_t>(QuicHttp3ErrorCode::CONNECT_ERROR))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":authority"] =
       absl::StrCat(kAcceptableDestination, ":", kAcceptablePort);
diff --git a/quiche/quic/tools/connect_udp_tunnel.cc b/quiche/quic/tools/connect_udp_tunnel.cc
index a4d215c..85d0760 100644
--- a/quiche/quic/tools/connect_udp_tunnel.cc
+++ b/quiche/quic/tools/connect_udp_tunnel.cc
@@ -26,13 +26,13 @@
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_name_lookup.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/masque/connect_udp_datagram_payload.h"
 #include "quiche/common/platform/api/quiche_googleurl.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/common/platform/api/quiche_url_utils.h"
 #include "quiche/common/structured_headers.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -113,7 +113,7 @@
 
 // Validate header expectations from RFC 9298, section 3.4.
 std::optional<QuicServerId> ValidateHeadersAndGetTarget(
-    const spdy::Http2HeaderBlock& request_headers) {
+    const quiche::HttpHeaderBlock& request_headers) {
   QUICHE_DCHECK(request_headers.contains(":method"));
   QUICHE_DCHECK(request_headers.find(":method")->second == "CONNECT");
   QUICHE_DCHECK(request_headers.contains(":protocol"));
@@ -185,7 +185,7 @@
 }
 
 void ConnectUdpTunnel::OpenTunnel(
-    const spdy::Http2HeaderBlock& request_headers) {
+    const quiche::HttpHeaderBlock& request_headers) {
   QUICHE_DCHECK(!IsTunnelOpenToTarget());
 
   std::optional<QuicServerId> target =
@@ -345,7 +345,7 @@
   QUICHE_DCHECK(IsTunnelOpenToTarget());
   QUICHE_DCHECK(client_stream_request_handler_);
 
-  spdy::Http2HeaderBlock response_headers;
+  quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
 
   std::optional<std::string> capsule_protocol_value =
@@ -380,7 +380,7 @@
   QUICHE_DCHECK(status_num < 200 || status_num >= 300);
 #endif  // !NDEBUG
 
-  spdy::Http2HeaderBlock headers;
+  quiche::HttpHeaderBlock headers;
   headers[":status"] = status;
 
   structured_headers::Item proxy_status_item(server_label_);
diff --git a/quiche/quic/tools/connect_udp_tunnel.h b/quiche/quic/tools/connect_udp_tunnel.h
index 1e800a7..71e13dc 100644
--- a/quiche/quic/tools/connect_udp_tunnel.h
+++ b/quiche/quic/tools/connect_udp_tunnel.h
@@ -21,8 +21,8 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/socket_factory.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -46,7 +46,7 @@
   // success/error response to the request stream. `request_headers` must
   // represent headers from a CONNECT-UDP request, that is ":method"="CONNECT"
   // and ":protocol"="connect-udp".
-  void OpenTunnel(const spdy::Http2HeaderBlock& request_headers);
+  void OpenTunnel(const quiche::HttpHeaderBlock& request_headers);
 
   // Returns true iff the tunnel to the target server is currently open
   bool IsTunnelOpenToTarget() const;
diff --git a/quiche/quic/tools/connect_udp_tunnel_test.cc b/quiche/quic/tools/connect_udp_tunnel_test.cc
index 45cb2ff..5a2faf2 100644
--- a/quiche/quic/tools/connect_udp_tunnel_test.cc
+++ b/quiche/quic/tools/connect_udp_tunnel_test.cc
@@ -173,7 +173,7 @@
                 Property(&QuicBackendResponse::trailers, IsEmpty()),
                 Property(&QuicBackendResponse::body, IsEmpty()))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
@@ -205,7 +205,7 @@
                 Property(&QuicBackendResponse::trailers, IsEmpty()),
                 Property(&QuicBackendResponse::body, IsEmpty()))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
@@ -245,7 +245,7 @@
        {"target_port", absl::StrCat(kAcceptablePort)}},
       &path));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
@@ -264,7 +264,7 @@
                   &QuicResetStreamError::ietf_application_code,
                   static_cast<uint64_t>(QuicHttp3ErrorCode::MESSAGE_ERROR))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
@@ -288,7 +288,7 @@
                                     HasSubstr("destination_ip_prohibited")))),
                   Property(&QuicBackendResponse::trailers, IsEmpty()))));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
@@ -317,7 +317,7 @@
           quiche::ConnectUdpDatagramUdpPacketPayload(kData).Serialize()))
       .WillOnce(Return(MESSAGE_STATUS_SUCCESS));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
@@ -346,7 +346,7 @@
 
   EXPECT_CALL(request_handler_, OnResponseBackendComplete(_));
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   request_headers[":method"] = "CONNECT";
   request_headers[":protocol"] = "connect-udp";
   request_headers[":authority"] = "proxy.test";
diff --git a/quiche/quic/tools/quic_backend_response.h b/quiche/quic/tools/quic_backend_response.h
index 6223e48..5564a6d 100644
--- a/quiche/quic/tools/quic_backend_response.h
+++ b/quiche/quic/tools/quic_backend_response.h
@@ -7,7 +7,7 @@
 
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/quic_time.h"
-#include "quiche/spdy/core/http2_header_block.h"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic {
 
@@ -35,16 +35,16 @@
 
   ~QuicBackendResponse();
 
-  const std::vector<spdy::Http2HeaderBlock>& early_hints() const {
+  const std::vector<quiche::HttpHeaderBlock>& early_hints() const {
     return early_hints_;
   }
   SpecialResponseType response_type() const { return response_type_; }
-  const spdy::Http2HeaderBlock& headers() const { return headers_; }
-  const spdy::Http2HeaderBlock& trailers() const { return trailers_; }
+  const quiche::HttpHeaderBlock& headers() const { return headers_; }
+  const quiche::HttpHeaderBlock& trailers() const { return trailers_; }
   const absl::string_view body() const { return absl::string_view(body_); }
 
-  void AddEarlyHints(const spdy::Http2HeaderBlock& headers) {
-    spdy::Http2HeaderBlock hints = headers.Clone();
+  void AddEarlyHints(const quiche::HttpHeaderBlock& headers) {
+    quiche::HttpHeaderBlock hints = headers.Clone();
     hints[":status"] = "103";
     early_hints_.push_back(std::move(hints));
   }
@@ -53,10 +53,10 @@
     response_type_ = response_type;
   }
 
-  void set_headers(spdy::Http2HeaderBlock headers) {
+  void set_headers(quiche::HttpHeaderBlock headers) {
     headers_ = std::move(headers);
   }
-  void set_trailers(spdy::Http2HeaderBlock trailers) {
+  void set_trailers(quiche::HttpHeaderBlock trailers) {
     trailers_ = std::move(trailers);
   }
   void set_body(absl::string_view body) {
@@ -69,10 +69,10 @@
   QuicTime::Delta delay() const { return delay_; }
 
  private:
-  std::vector<spdy::Http2HeaderBlock> early_hints_;
+  std::vector<quiche::HttpHeaderBlock> early_hints_;
   SpecialResponseType response_type_;
-  spdy::Http2HeaderBlock headers_;
-  spdy::Http2HeaderBlock trailers_;
+  quiche::HttpHeaderBlock headers_;
+  quiche::HttpHeaderBlock trailers_;
   std::string body_;
   QuicTime::Delta delay_;
 };
diff --git a/quiche/quic/tools/quic_client_interop_test_bin.cc b/quiche/quic/tools/quic_client_interop_test_bin.cc
index 4cb07e4..17b51f5 100644
--- a/quiche/quic/tools/quic_client_interop_test_bin.cc
+++ b/quiche/quic/tools/quic_client_interop_test_bin.cc
@@ -22,9 +22,9 @@
 #include "quiche/quic/tools/quic_default_client.h"
 #include "quiche/quic/tools/quic_name_lookup.h"
 #include "quiche/quic/tools/quic_url.h"
+#include "quiche/common/http/http_header_block.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.");
@@ -121,11 +121,11 @@
 
   // 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);
+  quiche::HttpHeaderBlock ConstructHeaderBlock(const std::string& authority);
 
   // Sends an HTTP request represented by |header_block| using |client|.
   void SendRequest(QuicDefaultClient* client,
-                   const spdy::Http2HeaderBlock& header_block);
+                   const quiche::HttpHeaderBlock& header_block);
 
   void OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
     switch (frame.close_type) {
@@ -175,7 +175,7 @@
 
   bool zero_rtt_attempt = !client->session()->OneRttKeysAvailable();
 
-  spdy::Http2HeaderBlock header_block = ConstructHeaderBlock(authority);
+  quiche::HttpHeaderBlock header_block = ConstructHeaderBlock(authority);
   SendRequest(client, header_block);
 
   if (!client->session()->OneRttKeysAvailable()) {
@@ -264,7 +264,7 @@
     InsertFeature(Feature::kQuantum);
   }
 
-  spdy::Http2HeaderBlock header_block = ConstructHeaderBlock(authority);
+  quiche::HttpHeaderBlock header_block = ConstructHeaderBlock(authority);
   SendRequest(client.get(), header_block);
 
   if (!client->connected()) {
@@ -332,10 +332,10 @@
   AttemptResumption(client.get(), authority);
 }
 
-spdy::Http2HeaderBlock QuicClientInteropRunner::ConstructHeaderBlock(
+quiche::HttpHeaderBlock QuicClientInteropRunner::ConstructHeaderBlock(
     const std::string& authority) {
   // Construct and send a request.
-  spdy::Http2HeaderBlock header_block;
+  quiche::HttpHeaderBlock header_block;
   header_block[":method"] = "GET";
   header_block[":scheme"] = "https";
   header_block[":authority"] = authority;
@@ -344,7 +344,7 @@
 }
 
 void QuicClientInteropRunner::SendRequest(
-    QuicDefaultClient* client, const spdy::Http2HeaderBlock& header_block) {
+    QuicDefaultClient* client, const quiche::HttpHeaderBlock& header_block) {
   client->set_store_response(true);
   client->SendRequestAndWaitForResponse(header_block, "", /*fin=*/true);
 
diff --git a/quiche/quic/tools/quic_memory_cache_backend.cc b/quiche/quic/tools/quic_memory_cache_backend.cc
index 5a3e168..2993384 100644
--- a/quiche/quic/tools/quic_memory_cache_backend.cc
+++ b/quiche/quic/tools/quic_memory_cache_backend.cc
@@ -21,7 +21,7 @@
 #include "quiche/common/platform/api/quiche_file_utils.h"
 #include "quiche/common/quiche_text_utils.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 using spdy::kV3LowestPriority;
 
 namespace quic {
@@ -159,7 +159,7 @@
                                                absl::string_view path,
                                                int response_code,
                                                absl::string_view body) {
-  Http2HeaderBlock response_headers;
+  HttpHeaderBlock response_headers;
   response_headers[":status"] = absl::StrCat(response_code);
   response_headers["content-length"] = absl::StrCat(body.length());
   AddResponse(host, path, std::move(response_headers), body);
@@ -172,22 +172,22 @@
 
 void QuicMemoryCacheBackend::AddResponse(absl::string_view host,
                                          absl::string_view path,
-                                         Http2HeaderBlock response_headers,
+                                         HttpHeaderBlock response_headers,
                                          absl::string_view response_body) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
-                  std::move(response_headers), response_body,
-                  Http2HeaderBlock(), std::vector<spdy::Http2HeaderBlock>());
+                  std::move(response_headers), response_body, HttpHeaderBlock(),
+                  std::vector<quiche::HttpHeaderBlock>());
 }
 
 void QuicMemoryCacheBackend::AddResponse(absl::string_view host,
                                          absl::string_view path,
-                                         Http2HeaderBlock response_headers,
+                                         HttpHeaderBlock response_headers,
                                          absl::string_view response_body,
-                                         Http2HeaderBlock response_trailers) {
+                                         HttpHeaderBlock response_trailers) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
                   std::move(response_headers), response_body,
                   std::move(response_trailers),
-                  std::vector<spdy::Http2HeaderBlock>());
+                  std::vector<quiche::HttpHeaderBlock>());
 }
 
 bool QuicMemoryCacheBackend::SetResponseDelay(absl::string_view host,
@@ -203,27 +203,27 @@
 
 void QuicMemoryCacheBackend::AddResponseWithEarlyHints(
     absl::string_view host, absl::string_view path,
-    spdy::Http2HeaderBlock response_headers, absl::string_view response_body,
-    const std::vector<spdy::Http2HeaderBlock>& early_hints) {
+    quiche::HttpHeaderBlock response_headers, absl::string_view response_body,
+    const std::vector<quiche::HttpHeaderBlock>& early_hints) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
-                  std::move(response_headers), response_body,
-                  Http2HeaderBlock(), early_hints);
+                  std::move(response_headers), response_body, HttpHeaderBlock(),
+                  early_hints);
 }
 
 void QuicMemoryCacheBackend::AddSpecialResponse(
     absl::string_view host, absl::string_view path,
     SpecialResponseType response_type) {
-  AddResponseImpl(host, path, response_type, Http2HeaderBlock(), "",
-                  Http2HeaderBlock(), std::vector<spdy::Http2HeaderBlock>());
+  AddResponseImpl(host, path, response_type, HttpHeaderBlock(), "",
+                  HttpHeaderBlock(), std::vector<quiche::HttpHeaderBlock>());
 }
 
 void QuicMemoryCacheBackend::AddSpecialResponse(
     absl::string_view host, absl::string_view path,
-    spdy::Http2HeaderBlock response_headers, absl::string_view response_body,
+    quiche::HttpHeaderBlock response_headers, absl::string_view response_body,
     SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, std::move(response_headers),
-                  response_body, Http2HeaderBlock(),
-                  std::vector<spdy::Http2HeaderBlock>());
+                  response_body, HttpHeaderBlock(),
+                  std::vector<quiche::HttpHeaderBlock>());
 }
 
 QuicMemoryCacheBackend::QuicMemoryCacheBackend() : cache_initialized_(false) {}
@@ -273,7 +273,7 @@
 void QuicMemoryCacheBackend::GenerateDynamicResponses() {
   QuicWriterMutexLock lock(&response_mutex_);
   // Add a generate bytes response.
-  spdy::Http2HeaderBlock response_headers;
+  quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
   generate_bytes_response_ = std::make_unique<QuicBackendResponse>();
   generate_bytes_response_->set_headers(std::move(response_headers));
@@ -290,8 +290,7 @@
 }
 
 void QuicMemoryCacheBackend::FetchResponseFromBackend(
-    const Http2HeaderBlock& request_headers,
-    const std::string& /*request_body*/,
+    const HttpHeaderBlock& request_headers, const std::string& /*request_body*/,
     QuicSimpleServerBackend::RequestHandler* quic_stream) {
   const QuicBackendResponse* quic_response = nullptr;
   // Find response in cache. If not found, send error response.
@@ -320,7 +319,7 @@
 
 QuicMemoryCacheBackend::WebTransportResponse
 QuicMemoryCacheBackend::ProcessWebTransportRequest(
-    const spdy::Http2HeaderBlock& request_headers,
+    const quiche::HttpHeaderBlock& request_headers,
     WebTransportSession* session) {
   if (!SupportsWebTransport()) {
     return QuicSimpleServerBackend::ProcessWebTransportRequest(request_headers,
@@ -356,9 +355,9 @@
 
 void QuicMemoryCacheBackend::AddResponseImpl(
     absl::string_view host, absl::string_view path,
-    SpecialResponseType response_type, Http2HeaderBlock response_headers,
-    absl::string_view response_body, Http2HeaderBlock response_trailers,
-    const std::vector<spdy::Http2HeaderBlock>& early_hints) {
+    SpecialResponseType response_type, HttpHeaderBlock response_headers,
+    absl::string_view response_body, HttpHeaderBlock response_trailers,
+    const std::vector<quiche::HttpHeaderBlock>& early_hints) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   QUICHE_DCHECK(!host.empty())
diff --git a/quiche/quic/tools/quic_memory_cache_backend.h b/quiche/quic/tools/quic_memory_cache_backend.h
index 930ef58..ed47d1d 100644
--- a/quiche/quic/tools/quic_memory_cache_backend.h
+++ b/quiche/quic/tools/quic_memory_cache_backend.h
@@ -16,7 +16,7 @@
 #include "quiche/quic/platform/api/quic_mutex.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/common/http/http_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -48,7 +48,7 @@
 
     absl::string_view path() { return path_; }
 
-    const spdy::Http2HeaderBlock& spdy_headers() { return spdy_headers_; }
+    const quiche::HttpHeaderBlock& spdy_headers() { return spdy_headers_; }
 
     absl::string_view body() { return body_; }
 
@@ -61,7 +61,7 @@
     std::string file_name_;
     std::string file_contents_;
     absl::string_view body_;
-    spdy::Http2HeaderBlock spdy_headers_;
+    quiche::HttpHeaderBlock spdy_headers_;
     absl::string_view x_original_url_;
     std::vector<absl::string_view> push_urls_;
     std::string host_;
@@ -85,20 +85,20 @@
 
   // Add a response to the cache.
   void AddResponse(absl::string_view host, absl::string_view path,
-                   spdy::Http2HeaderBlock response_headers,
+                   quiche::HttpHeaderBlock response_headers,
                    absl::string_view response_body);
 
   // Add a response, with trailers, to the cache.
   void AddResponse(absl::string_view host, absl::string_view path,
-                   spdy::Http2HeaderBlock response_headers,
+                   quiche::HttpHeaderBlock response_headers,
                    absl::string_view response_body,
-                   spdy::Http2HeaderBlock response_trailers);
+                   quiche::HttpHeaderBlock response_trailers);
 
   // Add a response, with 103 Early Hints, to the cache.
   void AddResponseWithEarlyHints(
       absl::string_view host, absl::string_view path,
-      spdy::Http2HeaderBlock response_headers, absl::string_view response_body,
-      const std::vector<spdy::Http2HeaderBlock>& early_hints);
+      quiche::HttpHeaderBlock response_headers, absl::string_view response_body,
+      const std::vector<quiche::HttpHeaderBlock>& early_hints);
 
   // Simulate a special behavior at a particular path.
   void AddSpecialResponse(
@@ -107,7 +107,7 @@
 
   void AddSpecialResponse(
       absl::string_view host, absl::string_view path,
-      spdy::Http2HeaderBlock response_headers, absl::string_view response_body,
+      quiche::HttpHeaderBlock response_headers, absl::string_view response_body,
       QuicBackendResponse::SpecialResponseType response_type);
 
   // Finds a response with the given host and path, and assign it a simulated
@@ -131,23 +131,23 @@
   bool InitializeBackend(const std::string& cache_directory) override;
   bool IsBackendInitialized() const override;
   void FetchResponseFromBackend(
-      const spdy::Http2HeaderBlock& request_headers,
+      const quiche::HttpHeaderBlock& request_headers,
       const std::string& request_body,
       QuicSimpleServerBackend::RequestHandler* quic_stream) override;
   void CloseBackendResponseStream(
       QuicSimpleServerBackend::RequestHandler* quic_stream) override;
   WebTransportResponse ProcessWebTransportRequest(
-      const spdy::Http2HeaderBlock& request_headers,
+      const quiche::HttpHeaderBlock& request_headers,
       WebTransportSession* session) override;
   bool SupportsWebTransport() override { return enable_webtransport_; }
 
  private:
   void AddResponseImpl(absl::string_view host, absl::string_view path,
                        QuicBackendResponse::SpecialResponseType response_type,
-                       spdy::Http2HeaderBlock response_headers,
+                       quiche::HttpHeaderBlock response_headers,
                        absl::string_view response_body,
-                       spdy::Http2HeaderBlock response_trailers,
-                       const std::vector<spdy::Http2HeaderBlock>& early_hints);
+                       quiche::HttpHeaderBlock response_trailers,
+                       const std::vector<quiche::HttpHeaderBlock>& early_hints);
 
   std::string GetKey(absl::string_view host, absl::string_view path) const;
 
diff --git a/quiche/quic/tools/quic_memory_cache_backend_test.cc b/quiche/quic/tools/quic_memory_cache_backend_test.cc
index 6f16ee3..3daa293 100644
--- a/quiche/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quiche/quic/tools/quic_memory_cache_backend_test.cc
@@ -25,7 +25,7 @@
 class QuicMemoryCacheBackendTest : public QuicTest {
  protected:
   void CreateRequest(std::string host, std::string path,
-                     spdy::Http2HeaderBlock* headers) {
+                     quiche::HttpHeaderBlock* headers) {
     (*headers)[":method"] = "GET";
     (*headers)[":path"] = path;
     (*headers)[":authority"] = host;
@@ -49,7 +49,7 @@
   std::string response_body("hello response");
   cache_.AddSimpleResponse("www.google.com", "/", 200, response_body);
 
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   CreateRequest("www.google.com", "/", &request_headers);
   const Response* response = cache_.GetResponse("www.google.com", "/");
   ASSERT_TRUE(response);
@@ -63,11 +63,11 @@
   const std::string kRequestPath = "/";
   const std::string kResponseBody("hello response");
 
-  spdy::Http2HeaderBlock response_headers;
+  quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
   response_headers["content-length"] = absl::StrCat(kResponseBody.size());
 
-  spdy::Http2HeaderBlock response_trailers;
+  quiche::HttpHeaderBlock response_trailers;
   response_trailers["key-1"] = "value-1";
   response_trailers["key-2"] = "value-2";
   response_trailers["key-3"] = "value-3";
@@ -157,7 +157,7 @@
   ASSERT_FALSE(response);
 
   // Add a default response.
-  spdy::Http2HeaderBlock response_headers;
+  quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
   response_headers["content-length"] = "0";
   Response* default_response = new Response;
diff --git a/quiche/quic/tools/quic_simple_client_session.cc b/quiche/quic/tools/quic_simple_client_session.cc
index 5dae254..669ed0f 100644
--- a/quiche/quic/tools/quic_simple_client_session.cc
+++ b/quiche/quic/tools/quic_simple_client_session.cc
@@ -8,7 +8,7 @@
 #include <utility>
 
 #include "quiche/quic/core/quic_path_validator.h"
-#include "quiche/spdy/core/http2_header_block.h"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic {
 
@@ -39,9 +39,10 @@
   auto stream = std::make_unique<QuicSimpleClientStream>(
       GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
       drop_response_body_);
-  stream->set_on_interim_headers([this](const spdy::Http2HeaderBlock& headers) {
-    on_interim_headers_(headers);
-  });
+  stream->set_on_interim_headers(
+      [this](const quiche::HttpHeaderBlock& headers) {
+        on_interim_headers_(headers);
+      });
   return stream;
 }
 
diff --git a/quiche/quic/tools/quic_simple_client_session.h b/quiche/quic/tools/quic_simple_client_session.h
index 424051c..1e9c524 100644
--- a/quiche/quic/tools/quic_simple_client_session.h
+++ b/quiche/quic/tools/quic_simple_client_session.h
@@ -11,8 +11,8 @@
 #include "quiche/quic/core/http/quic_spdy_client_session.h"
 #include "quiche/quic/tools/quic_client_base.h"
 #include "quiche/quic/tools/quic_simple_client_stream.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/quiche_callbacks.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -46,13 +46,13 @@
   bool drop_response_body() const { return drop_response_body_; }
 
   void set_on_interim_headers(
-      quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+      quiche::MultiUseCallback<void(const quiche::HttpHeaderBlock&)>
           on_interim_headers) {
     on_interim_headers_ = std::move(on_interim_headers);
   }
 
  private:
-  quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+  quiche::MultiUseCallback<void(const quiche::HttpHeaderBlock&)>
       on_interim_headers_;
   QuicClientBase::NetworkHelper* network_helper_;
   const bool drop_response_body_;
diff --git a/quiche/quic/tools/quic_simple_client_stream.h b/quiche/quic/tools/quic_simple_client_stream.h
index db7588b..9645240 100644
--- a/quiche/quic/tools/quic_simple_client_stream.h
+++ b/quiche/quic/tools/quic_simple_client_stream.h
@@ -22,7 +22,7 @@
   void OnBodyAvailable() override;
 
   void set_on_interim_headers(
-      quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+      quiche::MultiUseCallback<void(const quiche::HttpHeaderBlock&)>
           on_interim_headers) {
     on_interim_headers_ = std::move(on_interim_headers);
   }
@@ -31,7 +31,7 @@
   bool ParseAndValidateStatusCode() override;
 
  private:
-  quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+  quiche::MultiUseCallback<void(const quiche::HttpHeaderBlock&)>
       on_interim_headers_;
   const bool drop_response_body_;
 };
diff --git a/quiche/quic/tools/quic_simple_server_backend.h b/quiche/quic/tools/quic_simple_server_backend.h
index a142dd8..4d28b32 100644
--- a/quiche/quic/tools/quic_simple_server_backend.h
+++ b/quiche/quic/tools/quic_simple_server_backend.h
@@ -15,7 +15,7 @@
 #include "quiche/quic/core/socket_factory.h"
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/tools/quic_backend_response.h"
-#include "quiche/spdy/core/http2_header_block.h"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic {
 
@@ -50,7 +50,7 @@
   };
 
   struct WebTransportResponse {
-    spdy::Http2HeaderBlock response_headers;
+    quiche::HttpHeaderBlock response_headers;
     std::unique_ptr<WebTransportVisitor> visitor;
   };
 
@@ -73,7 +73,7 @@
   //
   // Not called for requests using the CONNECT method.
   virtual void FetchResponseFromBackend(
-      const spdy::Http2HeaderBlock& request_headers,
+      const quiche::HttpHeaderBlock& request_headers,
       const std::string& request_body, RequestHandler* request_handler) = 0;
 
   // Handles headers for requests using the CONNECT method. Called immediately
@@ -84,9 +84,9 @@
   // If not overridden by backend, sends an error appropriate for a server that
   // does not handle CONNECT requests.
   virtual void HandleConnectHeaders(
-      const spdy::Http2HeaderBlock& /*request_headers*/,
+      const quiche::HttpHeaderBlock& /*request_headers*/,
       RequestHandler* request_handler) {
-    spdy::Http2HeaderBlock headers;
+    quiche::HttpHeaderBlock headers;
     headers[":status"] = "405";
     QuicBackendResponse response;
     response.set_headers(std::move(headers));
@@ -108,7 +108,7 @@
   virtual void CloseBackendResponseStream(RequestHandler* request_handler) = 0;
 
   virtual WebTransportResponse ProcessWebTransportRequest(
-      const spdy::Http2HeaderBlock& /*request_headers*/,
+      const quiche::HttpHeaderBlock& /*request_headers*/,
       WebTransportSession* /*session*/) {
     WebTransportResponse response;
     response.response_headers[":status"] = "400";
diff --git a/quiche/quic/tools/quic_simple_server_session.h b/quiche/quic/tools/quic_simple_server_session.h
index 14516f5..476f074 100644
--- a/quiche/quic/tools/quic_simple_server_session.h
+++ b/quiche/quic/tools/quic_simple_server_session.h
@@ -23,7 +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"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic {
 
diff --git a/quiche/quic/tools/quic_simple_server_stream.cc b/quiche/quic/tools/quic_simple_server_stream.cc
index b71b448..d8bfa58 100644
--- a/quiche/quic/tools/quic_simple_server_stream.cc
+++ b/quiche/quic/tools/quic_simple_server_stream.cc
@@ -25,7 +25,7 @@
 #include "quiche/quic/tools/quic_simple_server_session.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic {
 
@@ -310,7 +310,7 @@
   std::string request_url = request_headers_[":authority"].as_string() +
                             request_headers_[":path"].as_string();
   int response_code;
-  const Http2HeaderBlock& response_headers = response->headers();
+  const HttpHeaderBlock& response_headers = response->headers();
   if (!ParseHeaderStatusCode(response_headers, &response_code)) {
     auto status = response_headers.find(":status");
     if (status == response_headers.end()) {
@@ -341,7 +341,7 @@
       SendNotFoundResponse();
       return;
     }
-    Http2HeaderBlock headers = response->headers().Clone();
+    HttpHeaderBlock headers = response->headers().Clone();
     headers["content-length"] = absl::StrCat(generate_bytes_length_);
 
     WriteHeaders(std::move(headers), false, nullptr);
@@ -366,7 +366,7 @@
   if (close_stream) {
     SendHeadersAndBodyAndTrailers(
         /*response_headers=*/std::nullopt, data,
-        /*response_trailers=*/spdy::Http2HeaderBlock());
+        /*response_trailers=*/quiche::HttpHeaderBlock());
   } else {
     SendIncompleteResponse(/*response_headers=*/std::nullopt, data);
   }
@@ -397,7 +397,7 @@
 
 void QuicSimpleServerStream::SendNotFoundResponse() {
   QUIC_DVLOG(1) << "Stream " << id() << " sending not found response.";
-  Http2HeaderBlock headers;
+  HttpHeaderBlock headers;
   headers[":status"] = "404";
   headers["content-length"] = absl::StrCat(strlen(kNotFoundResponseBody));
   SendHeadersAndBody(std::move(headers), kNotFoundResponseBody);
@@ -410,7 +410,7 @@
   if (!reading_stopped()) {
     StopReading();
   }
-  Http2HeaderBlock headers;
+  HttpHeaderBlock headers;
   if (resp_code <= 0) {
     headers[":status"] = "500";
   } else {
@@ -421,7 +421,7 @@
 }
 
 void QuicSimpleServerStream::SendIncompleteResponse(
-    std::optional<Http2HeaderBlock> response_headers, absl::string_view body) {
+    std::optional<HttpHeaderBlock> response_headers, absl::string_view body) {
   // Headers should be sent iff not sent in a previous response.
   QUICHE_DCHECK_NE(response_headers.has_value(), response_sent_);
 
@@ -445,14 +445,14 @@
 }
 
 void QuicSimpleServerStream::SendHeadersAndBody(
-    Http2HeaderBlock response_headers, absl::string_view body) {
+    HttpHeaderBlock response_headers, absl::string_view body) {
   SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
-                                Http2HeaderBlock());
+                                HttpHeaderBlock());
 }
 
 void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
-    std::optional<Http2HeaderBlock> response_headers, absl::string_view body,
-    Http2HeaderBlock response_trailers) {
+    std::optional<HttpHeaderBlock> response_headers, absl::string_view body,
+    HttpHeaderBlock response_trailers) {
   // Headers should be sent iff not sent in a previous response.
   QUICHE_DCHECK_NE(response_headers.has_value(), response_sent_);
 
diff --git a/quiche/quic/tools/quic_simple_server_stream.h b/quiche/quic/tools/quic_simple_server_stream.h
index 998429a..3e9a691 100644
--- a/quiche/quic/tools/quic_simple_server_stream.h
+++ b/quiche/quic/tools/quic_simple_server_stream.h
@@ -14,7 +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/common/http/http_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -79,16 +79,16 @@
   // Sends the response header (if not `std::nullopt`) and body, but not the
   // fin.
   void SendIncompleteResponse(
-      std::optional<spdy::Http2HeaderBlock> response_headers,
+      std::optional<quiche::HttpHeaderBlock> response_headers,
       absl::string_view body);
 
-  void SendHeadersAndBody(spdy::Http2HeaderBlock response_headers,
+  void SendHeadersAndBody(quiche::HttpHeaderBlock response_headers,
                           absl::string_view body);
   void SendHeadersAndBodyAndTrailers(
-      std::optional<spdy::Http2HeaderBlock> response_headers,
-      absl::string_view body, spdy::Http2HeaderBlock response_trailers);
+      std::optional<quiche::HttpHeaderBlock> response_headers,
+      absl::string_view body, quiche::HttpHeaderBlock response_trailers);
 
-  spdy::Http2HeaderBlock* request_headers() { return &request_headers_; }
+  quiche::HttpHeaderBlock* request_headers() { return &request_headers_; }
 
   // Returns true iff the request (per saved `request_headers_`) is a CONNECT or
   // Extended CONNECT request.
@@ -107,7 +107,7 @@
   bool response_sent() const { return response_sent_; }
   void set_response_sent() { response_sent_ = true; }
   // The parsed headers received from the client.
-  spdy::Http2HeaderBlock request_headers_;
+  quiche::HttpHeaderBlock request_headers_;
   int64_t content_length_;
   std::string body_;
 
diff --git a/quiche/quic/tools/quic_simple_server_stream_test.cc b/quiche/quic/tools/quic_simple_server_stream_test.cc
index e34b709..81cf057 100644
--- a/quiche/quic/tools/quic_simple_server_stream_test.cc
+++ b/quiche/quic/tools/quic_simple_server_stream_test.cc
@@ -75,7 +75,7 @@
               (override));
 
   size_t WriteHeaders(
-      spdy::Http2HeaderBlock header_block, bool fin,
+      quiche::HttpHeaderBlock header_block, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
       /*ack_listener*/) override {
     if (header_block[":status"] == "103") {
@@ -90,7 +90,7 @@
   void DoSendResponse() { SendResponse(); }
   void DoSendErrorResponse() { QuicSimpleServerStream::SendErrorResponse(); }
 
-  spdy::Http2HeaderBlock* mutable_headers() { return &request_headers_; }
+  quiche::HttpHeaderBlock* mutable_headers() { return &request_headers_; }
   void set_body(std::string body) { body_ = std::move(body); }
   const std::string& body() const { return body_; }
   int content_length() const { return content_length_; }
@@ -204,7 +204,7 @@
     return QuicConsumedData(write_length, state != NO_FIN);
   }
 
-  spdy::Http2HeaderBlock original_request_headers_;
+  quiche::HttpHeaderBlock original_request_headers_;
 };
 
 class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
@@ -282,7 +282,7 @@
   }
 
   quic::simulator::Simulator simulator_;
-  spdy::Http2HeaderBlock response_headers_;
+  quiche::HttpHeaderBlock response_headers_;
   MockQuicConnectionHelper helper_;
   StrictMock<MockQuicConnection>* connection_;
   StrictMock<MockQuicSessionVisitor> session_owner_;
@@ -399,7 +399,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
   // Send an illegal response with response status not supported by HTTP/2.
-  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
+  quiche::HttpHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -430,7 +430,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus2) {
   // Send an illegal response with response status not supported by HTTP/2.
-  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
+  quiche::HttpHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -462,7 +462,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
   // Add a request and response with valid headers.
-  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
+  quiche::HttpHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -496,18 +496,18 @@
   std::string body = "Yummm";
 
   // Add a request and response with early hints.
-  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
+  quiche::HttpHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = request_path;
   (*request_headers)[":authority"] = host;
   (*request_headers)[":method"] = "GET";
 
   quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
       body.length(), quiche::SimpleBufferAllocator::Get());
-  std::vector<spdy::Http2HeaderBlock> early_hints;
+  std::vector<quiche::HttpHeaderBlock> early_hints;
   // Add two Early Hints.
   const size_t kNumEarlyHintsResponses = 2;
   for (size_t i = 0; i < kNumEarlyHintsResponses; ++i) {
-    spdy::Http2HeaderBlock hints;
+    quiche::HttpHeaderBlock hints;
     hints["link"] = "</image.png>; rel=preload; as=image";
     early_hints.push_back(std::move(hints));
   }
@@ -545,7 +545,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithDelay) {
   // Add a request and response with valid headers.
-  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
+  quiche::HttpHeaderBlock* request_headers = stream_->mutable_headers();
   std::string host = "www.google.com";
   std::string path = "/bar";
   (*request_headers)[":path"] = path;
@@ -605,7 +605,7 @@
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   header_list_.OnHeader("content-length", absl::string_view("11\00012", 5));
 
@@ -626,7 +626,7 @@
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   header_list_.OnHeader("content-length", absl::string_view("\00012", 3));
 
@@ -647,7 +647,7 @@
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLengthII) {
-  spdy::Http2HeaderBlock request_headers;
+  quiche::HttpHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   header_list_.OnHeader("content-length", absl::string_view("11\00011", 5));
 
@@ -755,11 +755,11 @@
   }
   bool IsBackendInitialized() const override { return true; }
   MOCK_METHOD(void, FetchResponseFromBackend,
-              (const spdy::Http2HeaderBlock&, const std::string&,
+              (const quiche::HttpHeaderBlock&, const std::string&,
                RequestHandler*),
               (override));
   MOCK_METHOD(void, HandleConnectHeaders,
-              (const spdy::Http2HeaderBlock&, RequestHandler*), (override));
+              (const quiche::HttpHeaderBlock&, RequestHandler*), (override));
   MOCK_METHOD(void, HandleConnectData,
               (absl::string_view, bool, RequestHandler*), (override));
   void CloseBackendResponseStream(
@@ -782,7 +782,7 @@
   ReplaceBackend(std::move(test_backend));
 
   constexpr absl::string_view kRequestBody = "\x11\x11";
-  spdy::Http2HeaderBlock response_headers;
+  quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
   QuicBackendResponse headers_response;
   headers_response.set_headers(response_headers.Clone());
diff --git a/quiche/quic/tools/quic_spdy_client_base.cc b/quiche/quic/tools/quic_spdy_client_base.cc
index be16653..f065a7d 100644
--- a/quiche/quic/tools/quic_spdy_client_base.cc
+++ b/quiche/quic/tools/quic_spdy_client_base.cc
@@ -21,7 +21,7 @@
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/common/quiche_text_utils.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic {
 
@@ -64,7 +64,7 @@
   QuicSpdyClientStream* client_stream =
       static_cast<QuicSpdyClientStream*>(stream);
 
-  const Http2HeaderBlock& response_headers = client_stream->response_headers();
+  const HttpHeaderBlock& response_headers = client_stream->response_headers();
   if (response_listener_ != nullptr) {
     response_listener_->OnCompleteResponse(stream->id(), response_headers,
                                            client_stream->data());
@@ -79,7 +79,7 @@
       QUIC_LOG(ERROR) << "Invalid :status response header: " << status->second;
     }
     latest_response_headers_ = response_headers.DebugString();
-    for (const Http2HeaderBlock& headers :
+    for (const HttpHeaderBlock& headers :
          client_stream->preliminary_headers()) {
       absl::StrAppend(&preliminary_response_headers_, headers.DebugString());
     }
@@ -99,11 +99,11 @@
       *config(), supported_versions, connection, server_id(), crypto_config());
 }
 
-void QuicSpdyClientBase::SendRequest(const Http2HeaderBlock& headers,
+void QuicSpdyClientBase::SendRequest(const HttpHeaderBlock& headers,
                                      absl::string_view body, bool fin) {
   if (GetQuicFlag(quic_client_convert_http_header_name_to_lowercase)) {
     QUIC_CODE_COUNT(quic_client_convert_http_header_name_to_lowercase);
-    Http2HeaderBlock sanitized_headers;
+    HttpHeaderBlock sanitized_headers;
     for (const auto& p : headers) {
       sanitized_headers[quiche::QuicheTextUtils::ToLower(p.first)] = p.second;
     }
@@ -114,7 +114,7 @@
   }
 }
 
-void QuicSpdyClientBase::SendRequestInternal(Http2HeaderBlock sanitized_headers,
+void QuicSpdyClientBase::SendRequestInternal(HttpHeaderBlock sanitized_headers,
                                              absl::string_view body, bool fin) {
   QuicSpdyClientStream* stream = CreateClientStream();
   if (stream == nullptr) {
@@ -125,7 +125,7 @@
 }
 
 void QuicSpdyClientBase::SendRequestAndWaitForResponse(
-    const Http2HeaderBlock& headers, absl::string_view body, bool fin) {
+    const HttpHeaderBlock& headers, absl::string_view body, bool fin) {
   SendRequest(headers, body, fin);
   while (WaitForEvents()) {
   }
@@ -134,7 +134,7 @@
 void QuicSpdyClientBase::SendRequestsAndWaitForResponse(
     const std::vector<std::string>& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
-    Http2HeaderBlock headers;
+    HttpHeaderBlock headers;
     if (!SpdyUtils::PopulateHeaderBlockFromUrl(url_list[i], &headers)) {
       QUIC_BUG(quic_bug_10949_2) << "Unable to create request";
       continue;
@@ -203,7 +203,7 @@
   return preliminary_response_headers_;
 }
 
-const Http2HeaderBlock& QuicSpdyClientBase::latest_response_header_block()
+const HttpHeaderBlock& QuicSpdyClientBase::latest_response_header_block()
     const {
   QUIC_BUG_IF(quic_bug_10949_6, !store_response_) << "Response not stored!";
   return latest_response_header_block_;
diff --git a/quiche/quic/tools/quic_spdy_client_base.h b/quiche/quic/tools/quic_spdy_client_base.h
index a6ef509..f65758f 100644
--- a/quiche/quic/tools/quic_spdy_client_base.h
+++ b/quiche/quic/tools/quic_spdy_client_base.h
@@ -17,7 +17,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"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic {
 
@@ -34,7 +34,7 @@
     ResponseListener() {}
     virtual ~ResponseListener() {}
     virtual void OnCompleteResponse(
-        QuicStreamId id, const spdy::Http2HeaderBlock& response_headers,
+        QuicStreamId id, const quiche::HttpHeaderBlock& response_headers,
         absl::string_view response_body) = 0;
   };
 
@@ -59,11 +59,11 @@
   void InitializeSession() override;
 
   // Sends an HTTP request and does not wait for response before returning.
-  void SendRequest(const spdy::Http2HeaderBlock& headers,
+  void SendRequest(const quiche::HttpHeaderBlock& headers,
                    absl::string_view body, bool fin);
 
   // Sends an HTTP request and waits for response before returning.
-  void SendRequestAndWaitForResponse(const spdy::Http2HeaderBlock& headers,
+  void SendRequestAndWaitForResponse(const quiche::HttpHeaderBlock& headers,
                                      absl::string_view body, bool fin);
 
   // Sends a request simple GET for each URL in |url_list|, and then waits for
@@ -83,7 +83,7 @@
   int latest_response_code() const;
   const std::string& latest_response_headers() const;
   const std::string& preliminary_response_headers() const;
-  const spdy::Http2HeaderBlock& latest_response_header_block() const;
+  const quiche::HttpHeaderBlock& latest_response_header_block() const;
   const std::string& latest_response_body() const;
   const std::string& latest_response_trailers() const;
 
@@ -136,7 +136,7 @@
   bool HasActiveRequests() override;
 
  private:
-  void SendRequestInternal(spdy::Http2HeaderBlock sanitized_headers,
+  void SendRequestInternal(quiche::HttpHeaderBlock sanitized_headers,
                            absl::string_view body, bool fin);
 
   // If true, store the latest response code, headers, and body.
@@ -148,7 +148,7 @@
   // preliminary 100 Continue HTTP/2 headers from most recent response, if any.
   std::string preliminary_response_headers_;
   // HTTP/2 headers from most recent response.
-  spdy::Http2HeaderBlock latest_response_header_block_;
+  quiche::HttpHeaderBlock latest_response_header_block_;
   // Body of most recent response.
   std::string latest_response_body_;
   // HTTP/2 trailers from most recent response.
diff --git a/quiche/quic/tools/quic_toy_client.cc b/quiche/quic/tools/quic_toy_client.cc
index 2fae8e5..79aafb7 100644
--- a/quiche/quic/tools/quic_toy_client.cc
+++ b/quiche/quic/tools/quic_toy_client.cc
@@ -62,10 +62,10 @@
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/tools/fake_proof_verifier.h"
 #include "quiche/quic/tools/quic_url.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/platform/api/quiche_command_line_flags.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_text_utils.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace {
 
@@ -437,7 +437,7 @@
   }
 
   // Construct a GET or POST request for supplied URL.
-  spdy::Http2HeaderBlock header_block;
+  quiche::HttpHeaderBlock header_block;
   header_block[":method"] = body.empty() ? "GET" : "POST";
   header_block[":scheme"] = url.scheme();
   header_block[":authority"] = url.HostPort();
diff --git a/quiche/quic/tools/web_transport_only_backend.h b/quiche/quic/tools/web_transport_only_backend.h
index cd37672..b2fd036 100644
--- a/quiche/quic/tools/web_transport_only_backend.h
+++ b/quiche/quic/tools/web_transport_only_backend.h
@@ -13,9 +13,9 @@
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
+#include "quiche/common/http/http_header_block.h"
 #include "quiche/common/quiche_callbacks.h"
 #include "quiche/web_transport/web_transport.h"
-#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -33,13 +33,13 @@
   // QuicSimpleServerBackend implementation.
   bool InitializeBackend(const std::string&) override { return true; }
   bool IsBackendInitialized() const override { return true; }
-  void FetchResponseFromBackend(const spdy::Http2HeaderBlock&,
+  void FetchResponseFromBackend(const quiche::HttpHeaderBlock&,
                                 const std::string&,
                                 RequestHandler* request_handler) override;
   void CloseBackendResponseStream(RequestHandler*) override {}
   bool SupportsWebTransport() override { return true; }
   WebTransportResponse ProcessWebTransportRequest(
-      const spdy::Http2HeaderBlock& request_headers,
+      const quiche::HttpHeaderBlock& request_headers,
       WebTransportSession* session) override;
 
  private: