diff --git a/quic/tools/quic_backend_response.cc b/quic/tools/quic_backend_response.cc
index 7900683..defa9bf 100644
--- a/quic/tools/quic_backend_response.cc
+++ b/quic/tools/quic_backend_response.cc
@@ -8,7 +8,7 @@
 
 QuicBackendResponse::ServerPushInfo::ServerPushInfo(
     QuicUrl request_url,
-    spdy::SpdyHeaderBlock headers,
+    spdy::Http2HeaderBlock headers,
     spdy::SpdyPriority priority,
     std::string body)
     : request_url(request_url),
diff --git a/quic/tools/quic_backend_response.h b/quic/tools/quic_backend_response.h
index 379bec8..9209038 100644
--- a/quic/tools/quic_backend_response.h
+++ b/quic/tools/quic_backend_response.h
@@ -19,13 +19,13 @@
   // comprising a response for the push request.
   struct ServerPushInfo {
     ServerPushInfo(QuicUrl request_url,
-                   spdy::SpdyHeaderBlock headers,
+                   spdy::Http2HeaderBlock headers,
                    spdy::SpdyPriority priority,
                    std::string body);
     ServerPushInfo(const ServerPushInfo& other);
 
     QuicUrl request_url;
-    spdy::SpdyHeaderBlock headers;
+    spdy::Http2HeaderBlock headers;
     spdy::SpdyPriority priority;
     std::string body;
   };
@@ -51,18 +51,18 @@
   ~QuicBackendResponse();
 
   SpecialResponseType response_type() const { return response_type_; }
-  const spdy::SpdyHeaderBlock& headers() const { return headers_; }
-  const spdy::SpdyHeaderBlock& trailers() const { return trailers_; }
+  const spdy::Http2HeaderBlock& headers() const { return headers_; }
+  const spdy::Http2HeaderBlock& trailers() const { return trailers_; }
   const absl::string_view body() const { return absl::string_view(body_); }
 
   void set_response_type(SpecialResponseType response_type) {
     response_type_ = response_type;
   }
 
-  void set_headers(spdy::SpdyHeaderBlock headers) {
+  void set_headers(spdy::Http2HeaderBlock headers) {
     headers_ = std::move(headers);
   }
-  void set_trailers(spdy::SpdyHeaderBlock trailers) {
+  void set_trailers(spdy::Http2HeaderBlock trailers) {
     trailers_ = std::move(trailers);
   }
   void set_body(absl::string_view body) {
@@ -71,8 +71,8 @@
 
  private:
   SpecialResponseType response_type_;
-  spdy::SpdyHeaderBlock headers_;
-  spdy::SpdyHeaderBlock trailers_;
+  spdy::Http2HeaderBlock headers_;
+  spdy::Http2HeaderBlock trailers_;
   std::string body_;
 };
 
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index 6f9f685..e16afe6 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -116,11 +116,11 @@
 
   // Constructs a SpdyHeaderBlock containing the pseudo-headers needed to make a
   // GET request to "/" on the hostname |authority|.
-  spdy::SpdyHeaderBlock ConstructHeaderBlock(const std::string& authority);
+  spdy::Http2HeaderBlock ConstructHeaderBlock(const std::string& authority);
 
   // Sends an HTTP request represented by |header_block| using |client|.
   void SendRequest(QuicClient* client,
-                   const spdy::SpdyHeaderBlock& header_block);
+                   const spdy::Http2HeaderBlock& header_block);
 
   void OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
     switch (frame.close_type) {
@@ -170,7 +170,7 @@
 
   bool zero_rtt_attempt = !client->session()->OneRttKeysAvailable();
 
-  spdy::SpdyHeaderBlock header_block = ConstructHeaderBlock(authority);
+  spdy::Http2HeaderBlock header_block = ConstructHeaderBlock(authority);
   SendRequest(client, header_block);
 
   if (!client->session()->OneRttKeysAvailable()) {
@@ -262,7 +262,7 @@
     InsertFeature(Feature::kQuantum);
   }
 
-  spdy::SpdyHeaderBlock header_block = ConstructHeaderBlock(authority);
+  spdy::Http2HeaderBlock header_block = ConstructHeaderBlock(authority);
   SendRequest(client.get(), header_block);
 
   if (!client->connected()) {
@@ -330,10 +330,10 @@
   AttemptResumption(client.get(), authority);
 }
 
-spdy::SpdyHeaderBlock QuicClientInteropRunner::ConstructHeaderBlock(
+spdy::Http2HeaderBlock QuicClientInteropRunner::ConstructHeaderBlock(
     const std::string& authority) {
   // Construct and send a request.
-  spdy::SpdyHeaderBlock header_block;
+  spdy::Http2HeaderBlock header_block;
   header_block[":method"] = "GET";
   header_block[":scheme"] = "https";
   header_block[":authority"] = authority;
@@ -343,7 +343,7 @@
 
 void QuicClientInteropRunner::SendRequest(
     QuicClient* client,
-    const spdy::SpdyHeaderBlock& header_block) {
+    const spdy::Http2HeaderBlock& header_block) {
   client->set_store_response(true);
   client->SendRequestAndWaitForResponse(header_block, "", /*fin=*/true);
 
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 5efe0e6..497cdfd 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -14,8 +14,8 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
+using spdy::Http2HeaderBlock;
 using spdy::kV3LowestPriority;
-using spdy::SpdyHeaderBlock;
 
 namespace quic {
 
@@ -168,7 +168,7 @@
                                                absl::string_view path,
                                                int response_code,
                                                absl::string_view body) {
-  SpdyHeaderBlock response_headers;
+  Http2HeaderBlock response_headers;
   response_headers[":status"] =
       quiche::QuicheTextUtils::Uint64ToString(response_code);
   response_headers["content-length"] =
@@ -193,18 +193,18 @@
 
 void QuicMemoryCacheBackend::AddResponse(absl::string_view host,
                                          absl::string_view path,
-                                         SpdyHeaderBlock response_headers,
+                                         Http2HeaderBlock response_headers,
                                          absl::string_view response_body) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
                   std::move(response_headers), response_body,
-                  SpdyHeaderBlock());
+                  Http2HeaderBlock());
 }
 
 void QuicMemoryCacheBackend::AddResponse(absl::string_view host,
                                          absl::string_view path,
-                                         SpdyHeaderBlock response_headers,
+                                         Http2HeaderBlock response_headers,
                                          absl::string_view response_body,
-                                         SpdyHeaderBlock response_trailers) {
+                                         Http2HeaderBlock response_trailers) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
                   std::move(response_headers), response_body,
                   std::move(response_trailers));
@@ -214,18 +214,18 @@
     absl::string_view host,
     absl::string_view path,
     SpecialResponseType response_type) {
-  AddResponseImpl(host, path, response_type, SpdyHeaderBlock(), "",
-                  SpdyHeaderBlock());
+  AddResponseImpl(host, path, response_type, Http2HeaderBlock(), "",
+                  Http2HeaderBlock());
 }
 
 void QuicMemoryCacheBackend::AddSpecialResponse(
     absl::string_view host,
     absl::string_view path,
-    spdy::SpdyHeaderBlock response_headers,
+    spdy::Http2HeaderBlock response_headers,
     absl::string_view response_body,
     SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, std::move(response_headers),
-                  response_body, SpdyHeaderBlock());
+                  response_body, Http2HeaderBlock());
 }
 
 QuicMemoryCacheBackend::QuicMemoryCacheBackend() : cache_initialized_(false) {}
@@ -290,7 +290,7 @@
 void QuicMemoryCacheBackend::GenerateDynamicResponses() {
   QuicWriterMutexLock lock(&response_mutex_);
   // Add a generate bytes response.
-  spdy::SpdyHeaderBlock response_headers;
+  spdy::Http2HeaderBlock response_headers;
   response_headers[":status"] = "200";
   generate_bytes_response_ = std::make_unique<QuicBackendResponse>();
   generate_bytes_response_->set_headers(std::move(response_headers));
@@ -303,7 +303,7 @@
 }
 
 void QuicMemoryCacheBackend::FetchResponseFromBackend(
-    const SpdyHeaderBlock& request_headers,
+    const Http2HeaderBlock& request_headers,
     const std::string& /*request_body*/,
     QuicSimpleServerBackend::RequestHandler* quic_stream) {
   const QuicBackendResponse* quic_response = nullptr;
@@ -352,9 +352,9 @@
     absl::string_view host,
     absl::string_view path,
     SpecialResponseType response_type,
-    SpdyHeaderBlock response_headers,
+    Http2HeaderBlock response_headers,
     absl::string_view response_body,
-    SpdyHeaderBlock response_trailers) {
+    Http2HeaderBlock response_trailers) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
diff --git a/quic/tools/quic_memory_cache_backend.h b/quic/tools/quic_memory_cache_backend.h
index ecf87bc..e43bf60 100644
--- a/quic/tools/quic_memory_cache_backend.h
+++ b/quic/tools/quic_memory_cache_backend.h
@@ -48,7 +48,7 @@
 
     absl::string_view path() { return path_; }
 
-    const spdy::SpdyHeaderBlock& spdy_headers() { return spdy_headers_; }
+    const spdy::Http2HeaderBlock& 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::SpdyHeaderBlock spdy_headers_;
+    spdy::Http2HeaderBlock spdy_headers_;
     absl::string_view x_original_url_;
     std::vector<absl::string_view> push_urls_;
     std::string host_;
@@ -99,15 +99,15 @@
   // Add a response to the cache.
   void AddResponse(absl::string_view host,
                    absl::string_view path,
-                   spdy::SpdyHeaderBlock response_headers,
+                   spdy::Http2HeaderBlock 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::SpdyHeaderBlock response_headers,
+                   spdy::Http2HeaderBlock response_headers,
                    absl::string_view response_body,
-                   spdy::SpdyHeaderBlock response_trailers);
+                   spdy::Http2HeaderBlock response_trailers);
 
   // Simulate a special behavior at a particular path.
   void AddSpecialResponse(
@@ -118,7 +118,7 @@
   void AddSpecialResponse(
       absl::string_view host,
       absl::string_view path,
-      spdy::SpdyHeaderBlock response_headers,
+      spdy::Http2HeaderBlock response_headers,
       absl::string_view response_body,
       QuicBackendResponse::SpecialResponseType response_type);
 
@@ -139,7 +139,7 @@
   bool InitializeBackend(const std::string& cache_directory) override;
   bool IsBackendInitialized() const override;
   void FetchResponseFromBackend(
-      const spdy::SpdyHeaderBlock& request_headers,
+      const spdy::Http2HeaderBlock& request_headers,
       const std::string& request_body,
       QuicSimpleServerBackend::RequestHandler* quic_server_stream) override;
   void CloseBackendResponseStream(
@@ -149,9 +149,9 @@
   void AddResponseImpl(absl::string_view host,
                        absl::string_view path,
                        QuicBackendResponse::SpecialResponseType response_type,
-                       spdy::SpdyHeaderBlock response_headers,
+                       spdy::Http2HeaderBlock response_headers,
                        absl::string_view response_body,
-                       spdy::SpdyHeaderBlock response_trailers);
+                       spdy::Http2HeaderBlock response_trailers);
 
   std::string GetKey(absl::string_view host, absl::string_view path) const;
 
diff --git a/quic/tools/quic_memory_cache_backend_test.cc b/quic/tools/quic_memory_cache_backend_test.cc
index e4b8d8e..2bdd294 100644
--- a/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quic/tools/quic_memory_cache_backend_test.cc
@@ -23,7 +23,7 @@
  protected:
   void CreateRequest(std::string host,
                      std::string path,
-                     spdy::SpdyHeaderBlock* headers) {
+                     spdy::Http2HeaderBlock* headers) {
     (*headers)[":method"] = "GET";
     (*headers)[":path"] = path;
     (*headers)[":authority"] = host;
@@ -45,7 +45,7 @@
   std::string response_body("hello response");
   cache_.AddSimpleResponse("www.google.com", "/", 200, response_body);
 
-  spdy::SpdyHeaderBlock request_headers;
+  spdy::Http2HeaderBlock request_headers;
   CreateRequest("www.google.com", "/", &request_headers);
   const Response* response = cache_.GetResponse("www.google.com", "/");
   ASSERT_TRUE(response);
@@ -59,12 +59,12 @@
   const std::string kRequestPath = "/";
   const std::string kResponseBody("hello response");
 
-  spdy::SpdyHeaderBlock response_headers;
+  spdy::Http2HeaderBlock response_headers;
   response_headers[":status"] = "200";
   response_headers["content-length"] =
       quiche::QuicheTextUtils::Uint64ToString(kResponseBody.size());
 
-  spdy::SpdyHeaderBlock response_trailers;
+  spdy::Http2HeaderBlock response_trailers;
   response_trailers["key-1"] = "value-1";
   response_trailers["key-2"] = "value-2";
   response_trailers["key-3"] = "value-3";
@@ -148,7 +148,7 @@
   ASSERT_FALSE(response);
 
   // Add a default response.
-  spdy::SpdyHeaderBlock response_headers;
+  spdy::Http2HeaderBlock response_headers;
   response_headers[":status"] = "200";
   response_headers["content-length"] = "0";
   Response* default_response = new Response;
@@ -189,7 +189,7 @@
     QuicUrl resource_url(url);
     std::string body =
         quiche::QuicheStrCat("This is server push response body for ", path);
-    spdy::SpdyHeaderBlock response_headers;
+    spdy::Http2HeaderBlock response_headers;
     response_headers[":status"] = "200";
     response_headers["content-length"] =
         quiche::QuicheTextUtils::Uint64ToString(body.size());
@@ -228,7 +228,7 @@
     std::string url = scheme + "://" + request_host + path;
     QuicUrl resource_url(url);
     std::string body = "This is server push response body for " + path;
-    spdy::SpdyHeaderBlock response_headers;
+    spdy::Http2HeaderBlock response_headers;
     response_headers[":status"] = push_response_status[i];
     response_headers["content-length"] =
         quiche::QuicheTextUtils::Uint64ToString(body.size());
diff --git a/quic/tools/quic_simple_server_backend.h b/quic/tools/quic_simple_server_backend.h
index 3941784..fad3041 100644
--- a/quic/tools/quic_simple_server_backend.h
+++ b/quic/tools/quic_simple_server_backend.h
@@ -46,7 +46,7 @@
   // If the response has to be fetched over the network, the function
   // asynchronously calls |request_handler| with the HTTP response.
   virtual void FetchResponseFromBackend(
-      const spdy::SpdyHeaderBlock& request_headers,
+      const spdy::Http2HeaderBlock& request_headers,
       const std::string& request_body,
       RequestHandler* request_handler) = 0;
   // Clears the state of the backend  instance
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 0637109..72d6259 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -66,13 +66,13 @@
     const std::list<QuicBackendResponse::ServerPushInfo>& resources,
     QuicStreamId original_stream_id,
     const spdy::SpdyStreamPrecedence& original_precedence,
-    const spdy::SpdyHeaderBlock& original_request_headers) {
+    const spdy::Http2HeaderBlock& original_request_headers) {
   if (!server_push_enabled()) {
     return;
   }
 
   for (const QuicBackendResponse::ServerPushInfo& resource : resources) {
-    spdy::SpdyHeaderBlock headers = SynthesizePushRequestHeaders(
+    spdy::Http2HeaderBlock headers = SynthesizePushRequestHeaders(
         request_url, resource, original_request_headers);
     // TODO(b/136295430): Use sequential push IDs for IETF QUIC.
     auto new_highest_promised_stream_id =
@@ -171,13 +171,13 @@
   }
 }
 
-spdy::SpdyHeaderBlock QuicSimpleServerSession::SynthesizePushRequestHeaders(
+spdy::Http2HeaderBlock QuicSimpleServerSession::SynthesizePushRequestHeaders(
     std::string request_url,
     QuicBackendResponse::ServerPushInfo resource,
-    const spdy::SpdyHeaderBlock& original_request_headers) {
+    const spdy::Http2HeaderBlock& original_request_headers) {
   QuicUrl push_request_url = resource.request_url;
 
-  spdy::SpdyHeaderBlock spdy_headers = original_request_headers.Clone();
+  spdy::Http2HeaderBlock spdy_headers = original_request_headers.Clone();
   // :authority could be different from original request.
   spdy_headers[":authority"] = push_request_url.host();
   spdy_headers[":path"] = push_request_url.path();
@@ -196,7 +196,7 @@
 
 void QuicSimpleServerSession::SendPushPromise(QuicStreamId original_stream_id,
                                               QuicStreamId promised_stream_id,
-                                              spdy::SpdyHeaderBlock headers) {
+                                              spdy::Http2HeaderBlock headers) {
   QUIC_DLOG(INFO) << "stream " << original_stream_id
                   << " send PUSH_PROMISE for promised stream "
                   << promised_stream_id;
@@ -226,7 +226,7 @@
 
     promised_stream->SetPriority(promised_info.precedence);
 
-    spdy::SpdyHeaderBlock request_headers(
+    spdy::Http2HeaderBlock request_headers(
         std::move(promised_info.request_headers));
 
     promised_streams_.pop_front();
diff --git a/quic/tools/quic_simple_server_session.h b/quic/tools/quic_simple_server_session.h
index 9942c7d..6d1bc81 100644
--- a/quic/tools/quic_simple_server_session.h
+++ b/quic/tools/quic_simple_server_session.h
@@ -38,14 +38,14 @@
   // stream id with its priority and the headers sent out in PUSH_PROMISE.
   struct PromisedStreamInfo {
    public:
-    PromisedStreamInfo(spdy::SpdyHeaderBlock request_headers,
+    PromisedStreamInfo(spdy::Http2HeaderBlock request_headers,
                        QuicStreamId stream_id,
                        const spdy::SpdyStreamPrecedence& precedence)
         : request_headers(std::move(request_headers)),
           stream_id(stream_id),
           precedence(precedence),
           is_cancelled(false) {}
-    spdy::SpdyHeaderBlock request_headers;
+    spdy::Http2HeaderBlock request_headers;
     QuicStreamId stream_id;
     spdy::SpdyStreamPrecedence precedence;
     bool is_cancelled;
@@ -77,7 +77,7 @@
       const std::list<QuicBackendResponse::ServerPushInfo>& resources,
       QuicStreamId original_stream_id,
       const spdy::SpdyStreamPrecedence& original_precedence,
-      const spdy::SpdyHeaderBlock& original_request_headers);
+      const spdy::Http2HeaderBlock& original_request_headers);
 
   void OnCanCreateNewOutgoingStream(bool unidirectional) override;
 
@@ -113,15 +113,15 @@
   // :authority, :path, :method, :scheme, referer.
   // Copying the rest headers ensures they are the same as the original
   // request, especially cookies.
-  spdy::SpdyHeaderBlock SynthesizePushRequestHeaders(
+  spdy::Http2HeaderBlock SynthesizePushRequestHeaders(
       std::string request_url,
       QuicBackendResponse::ServerPushInfo resource,
-      const spdy::SpdyHeaderBlock& original_request_headers);
+      const spdy::Http2HeaderBlock& original_request_headers);
 
   // Send PUSH_PROMISE frame on headers stream.
   void SendPushPromise(QuicStreamId original_stream_id,
                        QuicStreamId promised_stream_id,
-                       spdy::SpdyHeaderBlock headers);
+                       spdy::Http2HeaderBlock headers);
 
   // Fetch response from cache for request headers enqueued into
   // promised_headers_and_streams_ and send them on dedicated stream until
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 4bc2cc5..8cd89f4 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -187,11 +187,11 @@
                                 crypto_config,
                                 compressed_certs_cache,
                                 quic_simple_server_backend) {}
-  // Methods taking non-copyable types like SpdyHeaderBlock by value cannot be
+  // Methods taking non-copyable types like Http2HeaderBlock by value cannot be
   // mocked directly.
   void WritePushPromise(QuicStreamId original_stream_id,
                         QuicStreamId promised_stream_id,
-                        spdy::SpdyHeaderBlock headers) override {
+                        spdy::Http2HeaderBlock headers) override {
     return WritePushPromiseMock(original_stream_id, promised_stream_id,
                                 headers);
   }
@@ -199,7 +199,7 @@
               WritePushPromiseMock,
               (QuicStreamId original_stream_id,
                QuicStreamId promised_stream_id,
-               const spdy::SpdyHeaderBlock& headers),
+               const spdy::Http2HeaderBlock& headers),
               ());
 
   MOCK_METHOD(void, SendBlocked, (QuicStreamId), (override));
@@ -676,7 +676,7 @@
     size_t body_size = 2 * kStreamFlowControlWindowSize;  // 64KB.
 
     std::string request_url = "mail.google.com/";
-    spdy::SpdyHeaderBlock request_headers;
+    spdy::Http2HeaderBlock request_headers;
     std::string resource_host = "www.google.com";
     std::string partial_push_resource_path = "/server_push_src";
     std::list<QuicBackendResponse::ServerPushInfo> push_resources;
@@ -708,7 +708,7 @@
 
       memory_cache_backend_.AddSimpleResponse(resource_host, path, 200, data);
       push_resources.push_back(QuicBackendResponse::ServerPushInfo(
-          resource_url, spdy::SpdyHeaderBlock(), QuicStream::kDefaultPriority,
+          resource_url, spdy::Http2HeaderBlock(), QuicStream::kDefaultPriority,
           body));
       // PUSH_PROMISED are sent for all the resources.
       EXPECT_CALL(*session_,
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index 1806fae..bbae2bc 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -19,7 +19,7 @@
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
@@ -109,7 +109,7 @@
 }
 
 void QuicSimpleServerStream::PushResponse(
-    SpdyHeaderBlock push_request_headers) {
+    Http2HeaderBlock push_request_headers) {
   if (QuicUtils::IsClientInitiatedStreamId(session()->transport_version(),
                                            id())) {
     QUIC_BUG << "Client initiated stream shouldn't be used as promised stream.";
@@ -208,7 +208,7 @@
   std::string request_url = request_headers_[":authority"].as_string() +
                             request_headers_[":path"].as_string();
   int response_code;
-  const SpdyHeaderBlock& response_headers = response->headers();
+  const Http2HeaderBlock& response_headers = response->headers();
   if (!ParseHeaderStatusCode(response_headers, &response_code)) {
     auto status = response_headers.find(":status");
     if (status == response_headers.end()) {
@@ -263,7 +263,7 @@
       SendNotFoundResponse();
       return;
     }
-    SpdyHeaderBlock headers = response->headers().Clone();
+    Http2HeaderBlock headers = response->headers().Clone();
     headers["content-length"] =
         quiche::QuicheTextUtils::Uint64ToString(generate_bytes_length_);
 
@@ -297,7 +297,7 @@
 
 void QuicSimpleServerStream::SendNotFoundResponse() {
   QUIC_DVLOG(1) << "Stream " << id() << " sending not found response.";
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   headers[":status"] = "404";
   headers["content-length"] =
       quiche::QuicheTextUtils::Uint64ToString(strlen(kNotFoundResponseBody));
@@ -310,7 +310,7 @@
 
 void QuicSimpleServerStream::SendErrorResponse(int resp_code) {
   QUIC_DVLOG(1) << "Stream " << id() << " sending error response.";
-  SpdyHeaderBlock headers;
+  Http2HeaderBlock headers;
   if (resp_code <= 0) {
     headers[":status"] = "500";
   } else {
@@ -322,7 +322,7 @@
 }
 
 void QuicSimpleServerStream::SendIncompleteResponse(
-    SpdyHeaderBlock response_headers,
+    Http2HeaderBlock response_headers,
     absl::string_view body) {
   QUIC_DLOG(INFO) << "Stream " << id() << " writing headers (fin = false) : "
                   << response_headers.DebugString();
@@ -336,16 +336,16 @@
 }
 
 void QuicSimpleServerStream::SendHeadersAndBody(
-    SpdyHeaderBlock response_headers,
+    Http2HeaderBlock response_headers,
     absl::string_view body) {
   SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
-                                SpdyHeaderBlock());
+                                Http2HeaderBlock());
 }
 
 void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
-    SpdyHeaderBlock response_headers,
+    Http2HeaderBlock response_headers,
     absl::string_view body,
-    SpdyHeaderBlock response_trailers) {
+    Http2HeaderBlock response_trailers) {
   // Send the headers, with a FIN if there's nothing else to send.
   bool send_fin = (body.empty() && response_trailers.empty());
   QUIC_DLOG(INFO) << "Stream " << id() << " writing headers (fin = " << send_fin
diff --git a/quic/tools/quic_simple_server_stream.h b/quic/tools/quic_simple_server_stream.h
index 254fe8d..6b8826c 100644
--- a/quic/tools/quic_simple_server_stream.h
+++ b/quic/tools/quic_simple_server_stream.h
@@ -47,7 +47,7 @@
   // Make this stream start from as if it just finished parsing an incoming
   // request whose headers are equivalent to |push_request_headers|.
   // Doing so will trigger this toy stream to fetch response and send it back.
-  virtual void PushResponse(spdy::SpdyHeaderBlock push_request_headers);
+  virtual void PushResponse(spdy::Http2HeaderBlock push_request_headers);
 
   // The response body of error responses.
   static const char* const kErrorResponseBody;
@@ -76,16 +76,16 @@
   void SendNotFoundResponse();
 
   // Sends the response header and body, but not the fin.
-  void SendIncompleteResponse(spdy::SpdyHeaderBlock response_headers,
+  void SendIncompleteResponse(spdy::Http2HeaderBlock response_headers,
                               absl::string_view body);
 
-  void SendHeadersAndBody(spdy::SpdyHeaderBlock response_headers,
+  void SendHeadersAndBody(spdy::Http2HeaderBlock response_headers,
                           absl::string_view body);
-  void SendHeadersAndBodyAndTrailers(spdy::SpdyHeaderBlock response_headers,
+  void SendHeadersAndBodyAndTrailers(spdy::Http2HeaderBlock response_headers,
                                      absl::string_view body,
-                                     spdy::SpdyHeaderBlock response_trailers);
+                                     spdy::Http2HeaderBlock response_trailers);
 
-  spdy::SpdyHeaderBlock* request_headers() { return &request_headers_; }
+  spdy::Http2HeaderBlock* request_headers() { return &request_headers_; }
 
   const std::string& body() { return body_; }
 
@@ -93,7 +93,7 @@
   void WriteGeneratedBytes();
 
   // The parsed headers received from the client.
-  spdy::SpdyHeaderBlock request_headers_;
+  spdy::Http2HeaderBlock request_headers_;
   int64_t content_length_;
   std::string body_;
 
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index c4d4572..90d1313 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -59,7 +59,7 @@
 
   MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
 
-  size_t WriteHeaders(spdy::SpdyHeaderBlock /*header_block*/,
+  size_t WriteHeaders(spdy::Http2HeaderBlock /*header_block*/,
                       bool fin,
                       QuicReferenceCountedPointer<QuicAckListenerInterface>
                       /*ack_listener*/) override {
@@ -71,7 +71,7 @@
   void DoSendResponse() { SendResponse(); }
   void DoSendErrorResponse() { SendErrorResponse(); }
 
-  spdy::SpdyHeaderBlock* mutable_headers() { return &request_headers_; }
+  spdy::Http2HeaderBlock* 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_; }
@@ -169,13 +169,13 @@
               MaybeSendStopSendingFrame,
               (QuicStreamId stream_id, QuicRstStreamErrorCode error),
               (override));
-  // Matchers cannot be used on non-copyable types like SpdyHeaderBlock.
+  // Matchers cannot be used on non-copyable types like Http2HeaderBlock.
   void PromisePushResources(
       const std::string& request_url,
       const std::list<QuicBackendResponse::ServerPushInfo>& resources,
       QuicStreamId original_stream_id,
       const spdy::SpdyStreamPrecedence& original_precedence,
-      const spdy::SpdyHeaderBlock& original_request_headers) override {
+      const spdy::Http2HeaderBlock& original_request_headers) override {
     original_request_headers_ = original_request_headers.Clone();
     PromisePushResourcesMock(request_url, resources, original_stream_id,
                              original_precedence, original_request_headers);
@@ -186,7 +186,7 @@
                const std::list<QuicBackendResponse::ServerPushInfo>&,
                QuicStreamId,
                const spdy::SpdyStreamPrecedence&,
-               const spdy::SpdyHeaderBlock&),
+               const spdy::Http2HeaderBlock&),
               ());
 
   using QuicSession::ActivateStream;
@@ -209,7 +209,7 @@
     return QuicConsumedData(write_length, state != NO_FIN);
   }
 
-  spdy::SpdyHeaderBlock original_request_headers_;
+  spdy::Http2HeaderBlock original_request_headers_;
 };
 
 class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
@@ -283,7 +283,7 @@
     return VersionUsesHttp3(connection_->transport_version());
   }
 
-  spdy::SpdyHeaderBlock response_headers_;
+  spdy::Http2HeaderBlock response_headers_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockQuicConnection>* connection_;
@@ -405,7 +405,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
   // Send an illegal response with response status not supported by HTTP/2.
-  spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
+  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -437,7 +437,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus2) {
   // Send an illegal response with response status not supported by HTTP/2.
-  spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
+  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -478,7 +478,7 @@
 
   // Send a push response with response status 404, which will be regarded as
   // invalid server push response.
-  spdy::SpdyHeaderBlock* request_headers = promised_stream->mutable_headers();
+  spdy::Http2HeaderBlock* request_headers = promised_stream->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -507,7 +507,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
   // Add a request and response with valid headers.
-  spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
+  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
   (*request_headers)[":authority"] = "www.google.com";
   (*request_headers)[":method"] = "GET";
@@ -548,14 +548,14 @@
   QuicByteCount header_length =
       HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer);
   QuicBackendResponse::ServerPushInfo push_info(
-      QuicUrl(host, "/bar"), spdy::SpdyHeaderBlock(),
+      QuicUrl(host, "/bar"), spdy::Http2HeaderBlock(),
       QuicStream::kDefaultPriority, "Push body");
   std::list<QuicBackendResponse::ServerPushInfo> push_resources;
   push_resources.push_back(push_info);
   memory_cache_backend_.AddSimpleResponseWithServerPushResources(
       host, request_path, 200, body, push_resources);
 
-  spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
+  spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = request_path;
   (*request_headers)[":authority"] = host;
   (*request_headers)[":method"] = "GET";
@@ -584,7 +584,7 @@
 
   // Calling PushResponse() on a client initialted stream is never supposed to
   // happen.
-  EXPECT_QUIC_BUG(stream_->PushResponse(spdy::SpdyHeaderBlock()),
+  EXPECT_QUIC_BUG(stream_->PushResponse(spdy::Http2HeaderBlock()),
                   "Client initiated stream"
                   " shouldn't be used as promised stream.");
 }
@@ -605,7 +605,7 @@
 
   const std::string kHost = "www.foo.com";
   const std::string kPath = "/bar";
-  spdy::SpdyHeaderBlock headers;
+  spdy::Http2HeaderBlock headers;
   headers[":path"] = kPath;
   headers[":authority"] = kHost;
   headers[":method"] = "GET";
@@ -656,7 +656,7 @@
 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
 
-  spdy::SpdyHeaderBlock request_headers;
+  spdy::Http2HeaderBlock 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));
 
@@ -674,7 +674,7 @@
 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
 
-  spdy::SpdyHeaderBlock request_headers;
+  spdy::Http2HeaderBlock 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));
 
@@ -690,7 +690,7 @@
 }
 
 TEST_P(QuicSimpleServerStreamTest, ValidMultipleContentLength) {
-  spdy::SpdyHeaderBlock request_headers;
+  spdy::Http2HeaderBlock 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));
 
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index 273d067..e96b19c 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -14,7 +14,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
-using spdy::SpdyHeaderBlock;
+using spdy::Http2HeaderBlock;
 
 namespace quic {
 
@@ -24,7 +24,7 @@
 }
 
 QuicSpdyClientBase::QuicDataToResend::QuicDataToResend(
-    std::unique_ptr<SpdyHeaderBlock> headers,
+    std::unique_ptr<Http2HeaderBlock> headers,
     absl::string_view body,
     bool fin)
     : headers_(std::move(headers)), body_(body), fin_(fin) {}
@@ -80,7 +80,7 @@
   QuicSpdyClientStream* client_stream =
       static_cast<QuicSpdyClientStream*>(stream);
 
-  const SpdyHeaderBlock& response_headers = client_stream->response_headers();
+  const Http2HeaderBlock& response_headers = client_stream->response_headers();
   if (response_listener_ != nullptr) {
     response_listener_->OnCompleteResponse(stream->id(), response_headers,
                                            client_stream->data());
@@ -113,12 +113,12 @@
       &push_promise_index_);
 }
 
-void QuicSpdyClientBase::SendRequest(const SpdyHeaderBlock& headers,
+void QuicSpdyClientBase::SendRequest(const Http2HeaderBlock& headers,
                                      absl::string_view body,
                                      bool fin) {
   if (GetQuicFlag(FLAGS_quic_client_convert_http_header_name_to_lowercase)) {
     QUIC_CODE_COUNT(quic_client_convert_http_header_name_to_lowercase);
-    SpdyHeaderBlock sanitized_headers;
+    Http2HeaderBlock sanitized_headers;
     for (const auto& p : headers) {
       sanitized_headers[quiche::QuicheTextUtils::ToLower(p.first)] = p.second;
     }
@@ -129,7 +129,7 @@
   }
 }
 
-void QuicSpdyClientBase::SendRequestInternal(SpdyHeaderBlock sanitized_headers,
+void QuicSpdyClientBase::SendRequestInternal(Http2HeaderBlock sanitized_headers,
                                              absl::string_view body,
                                              bool fin) {
   QuicClientPushPromiseIndex::TryHandle* handle;
@@ -153,7 +153,7 @@
 }
 
 void QuicSpdyClientBase::SendRequestAndWaitForResponse(
-    const SpdyHeaderBlock& headers,
+    const Http2HeaderBlock& headers,
     absl::string_view body,
     bool fin) {
   SendRequest(headers, body, fin);
@@ -164,7 +164,7 @@
 void QuicSpdyClientBase::SendRequestsAndWaitForResponse(
     const std::vector<std::string>& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
-    SpdyHeaderBlock headers;
+    Http2HeaderBlock headers;
     if (!SpdyUtils::PopulateHeaderBlockFromUrl(url_list[i], &headers)) {
       QUIC_BUG << "Unable to create request";
       continue;
@@ -232,19 +232,19 @@
   }
 }
 
-void QuicSpdyClientBase::AddPromiseDataToResend(const SpdyHeaderBlock& headers,
+void QuicSpdyClientBase::AddPromiseDataToResend(const Http2HeaderBlock& headers,
                                                 absl::string_view body,
                                                 bool fin) {
-  std::unique_ptr<SpdyHeaderBlock> new_headers(
-      new SpdyHeaderBlock(headers.Clone()));
+  std::unique_ptr<Http2HeaderBlock> new_headers(
+      new Http2HeaderBlock(headers.Clone()));
   push_promise_data_to_resend_.reset(
       new ClientQuicDataToResend(std::move(new_headers), body, fin, this));
 }
 
 bool QuicSpdyClientBase::CheckVary(
-    const SpdyHeaderBlock& /*client_request*/,
-    const SpdyHeaderBlock& /*promise_request*/,
-    const SpdyHeaderBlock& /*promise_response*/) {
+    const Http2HeaderBlock& /*client_request*/,
+    const Http2HeaderBlock& /*promise_request*/,
+    const Http2HeaderBlock& /*promise_response*/) {
   return true;
 }
 
@@ -274,7 +274,7 @@
   return preliminary_response_headers_;
 }
 
-const SpdyHeaderBlock& QuicSpdyClientBase::latest_response_header_block()
+const Http2HeaderBlock& QuicSpdyClientBase::latest_response_header_block()
     const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_header_block_;
diff --git a/quic/tools/quic_spdy_client_base.h b/quic/tools/quic_spdy_client_base.h
index ca59431..90dfe8a 100644
--- a/quic/tools/quic_spdy_client_base.h
+++ b/quic/tools/quic_spdy_client_base.h
@@ -36,7 +36,7 @@
     virtual ~ResponseListener() {}
     virtual void OnCompleteResponse(
         QuicStreamId id,
-        const spdy::SpdyHeaderBlock& response_headers,
+        const spdy::Http2HeaderBlock& response_headers,
         const std::string& response_body) = 0;
   };
 
@@ -46,7 +46,7 @@
   class QuicDataToResend {
    public:
     // |headers| may be null, since it's possible to send data without headers.
-    QuicDataToResend(std::unique_ptr<spdy::SpdyHeaderBlock> headers,
+    QuicDataToResend(std::unique_ptr<spdy::Http2HeaderBlock> headers,
                      absl::string_view body,
                      bool fin);
     QuicDataToResend(const QuicDataToResend&) = delete;
@@ -59,7 +59,7 @@
     virtual void Resend() = 0;
 
    protected:
-    std::unique_ptr<spdy::SpdyHeaderBlock> headers_;
+    std::unique_ptr<spdy::Http2HeaderBlock> headers_;
     absl::string_view body_;
     bool fin_;
   };
@@ -85,12 +85,12 @@
   void InitializeSession() override;
 
   // Sends an HTTP request and does not wait for response before returning.
-  void SendRequest(const spdy::SpdyHeaderBlock& headers,
+  void SendRequest(const spdy::Http2HeaderBlock& headers,
                    absl::string_view body,
                    bool fin);
 
   // Sends an HTTP request and waits for response before returning.
-  void SendRequestAndWaitForResponse(const spdy::SpdyHeaderBlock& headers,
+  void SendRequestAndWaitForResponse(const spdy::Http2HeaderBlock& headers,
                                      absl::string_view body,
                                      bool fin);
 
@@ -110,9 +110,9 @@
     return &push_promise_index_;
   }
 
-  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;
 
   // If the crypto handshake has not yet been confirmed, adds the data to the
@@ -126,7 +126,7 @@
   int latest_response_code() const;
   const std::string& latest_response_headers() const;
   const std::string& preliminary_response_headers() const;
-  const spdy::SpdyHeaderBlock& latest_response_header_block() const;
+  const spdy::Http2HeaderBlock& latest_response_header_block() const;
   const std::string& latest_response_body() const;
   const std::string& latest_response_trailers() const;
 
@@ -161,7 +161,7 @@
 
   void ResendSavedData() override;
 
-  void AddPromiseDataToResend(const spdy::SpdyHeaderBlock& headers,
+  void AddPromiseDataToResend(const spdy::Http2HeaderBlock& headers,
                               absl::string_view body,
                               bool fin);
   bool HasActiveRequests() override;
@@ -170,7 +170,7 @@
   // Specific QuicClient class for storing data to resend.
   class ClientQuicDataToResend : public QuicDataToResend {
    public:
-    ClientQuicDataToResend(std::unique_ptr<spdy::SpdyHeaderBlock> headers,
+    ClientQuicDataToResend(std::unique_ptr<spdy::Http2HeaderBlock> headers,
                            absl::string_view body,
                            bool fin,
                            QuicSpdyClientBase* client)
@@ -189,7 +189,7 @@
     QuicSpdyClientBase* client_;
   };
 
-  void SendRequestInternal(spdy::SpdyHeaderBlock sanitized_headers,
+  void SendRequestInternal(spdy::Http2HeaderBlock sanitized_headers,
                            absl::string_view body,
                            bool fin);
 
@@ -205,7 +205,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::SpdyHeaderBlock latest_response_header_block_;
+  spdy::Http2HeaderBlock latest_response_header_block_;
   // Body of most recent response.
   std::string latest_response_body_;
   // HTTP/2 trailers from most recent response.
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 06c4d17..c4b36db 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -325,7 +325,7 @@
   }
 
   // Construct a GET or POST request for supplied URL.
-  spdy::SpdyHeaderBlock header_block;
+  spdy::Http2HeaderBlock header_block;
   header_block[":method"] = body.empty() ? "GET" : "POST";
   header_block[":scheme"] = url.scheme();
   header_block[":authority"] = url.HostPort();