@fails-components/webtransport-transport-http3-quiche 1.1.2 → 1.1.4

package/CMakeLists.txt

@@ -228,9 +228,26 @@ third_party/quiche/quiche/http2/adapter/oghttp2_util.cc
 third_party/quiche/quiche/http2/adapter/oghttp2_util.h
 third_party/quiche/quiche/http2/adapter/window_manager.cc
 third_party/quiche/quiche/http2/adapter/window_manager.h
+third_party/quiche/quiche/http2/core/http2_frame_decoder_adapter.cc
+third_party/quiche/quiche/http2/core/http2_frame_decoder_adapter.h
 third_party/quiche/quiche/http2/core/http2_trace_logging.cc
 third_party/quiche/quiche/http2/core/http2_trace_logging.h
 third_party/quiche/quiche/http2/core/priority_write_scheduler.h
+third_party/quiche/quiche/http2/core/spdy_alt_svc_wire_format.cc
+third_party/quiche/quiche/http2/core/spdy_alt_svc_wire_format.h
+third_party/quiche/quiche/http2/core/spdy_bitmasks.h
+third_party/quiche/quiche/http2/core/spdy_frame_builder.cc
+third_party/quiche/quiche/http2/core/spdy_frame_builder.h
+third_party/quiche/quiche/http2/core/spdy_framer.cc
+third_party/quiche/quiche/http2/core/spdy_framer.h
+third_party/quiche/quiche/http2/core/spdy_protocol.cc
+third_party/quiche/quiche/http2/core/spdy_protocol.h
+third_party/quiche/quiche/http2/core/recording_headers_handler.cc
+third_party/quiche/quiche/http2/core/recording_headers_handler.h
+third_party/quiche/quiche/http2/core/spdy_headers_handler_interface.h
+third_party/quiche/quiche/http2/core/spdy_no_op_visitor.cc
+third_party/quiche/quiche/http2/core/spdy_no_op_visitor.h
+third_party/quiche/quiche/http2/core/zero_copy_output_buffer.h
 third_party/quiche/quiche/http2/decoder/decode_buffer.cc
 third_party/quiche/quiche/http2/decoder/decode_buffer.h
 third_party/quiche/quiche/http2/decoder/decode_http2_structures.cc
@@ -299,6 +316,20 @@ third_party/quiche/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.cc
 third_party/quiche/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.h
 third_party/quiche/quiche/http2/hpack/decoder/hpack_whole_entry_listener.cc
 third_party/quiche/quiche/http2/hpack/decoder/hpack_whole_entry_listener.h
+third_party/quiche/quiche/http2/hpack/hpack_constants.cc
+third_party/quiche/quiche/http2/hpack/hpack_constants.h
+third_party/quiche/quiche/http2/hpack/hpack_decoder_adapter.cc
+third_party/quiche/quiche/http2/hpack/hpack_decoder_adapter.h
+third_party/quiche/quiche/http2/hpack/hpack_encoder.cc
+third_party/quiche/quiche/http2/hpack/hpack_encoder.h
+third_party/quiche/quiche/http2/hpack/hpack_entry.cc
+third_party/quiche/quiche/http2/hpack/hpack_entry.h
+third_party/quiche/quiche/http2/hpack/hpack_header_table.cc
+third_party/quiche/quiche/http2/hpack/hpack_header_table.h
+third_party/quiche/quiche/http2/hpack/hpack_output_stream.cc
+third_party/quiche/quiche/http2/hpack/hpack_output_stream.h
+third_party/quiche/quiche/http2/hpack/hpack_static_table.cc
+third_party/quiche/quiche/http2/hpack/hpack_static_table.h
 third_party/quiche/quiche/http2/hpack/hpack_static_table_entries.inc
 third_party/quiche/quiche/http2/hpack/http2_hpack_constants.cc
 third_party/quiche/quiche/http2/hpack/http2_hpack_constants.h
@@ -348,6 +379,8 @@ third_party/quiche/quiche/quic/core/congestion_control/hybrid_slow_start.h
 third_party/quiche/quiche/quic/core/congestion_control/loss_detection_interface.h
 third_party/quiche/quiche/quic/core/congestion_control/pacing_sender.cc
 third_party/quiche/quiche/quic/core/congestion_control/pacing_sender.h
+third_party/quiche/quiche/quic/core/congestion_control/prague_sender.cc
+third_party/quiche/quiche/quic/core/congestion_control/prague_sender.h
 third_party/quiche/quiche/quic/core/congestion_control/prr_sender.cc
 third_party/quiche/quiche/quic/core/congestion_control/prr_sender.h
 third_party/quiche/quiche/quic/core/congestion_control/rtt_stats.cc
@@ -668,7 +701,6 @@ third_party/quiche/quiche/quic/core/quic_dispatcher.cc
 third_party/quiche/quiche/quic/core/quic_dispatcher.h
 third_party/quiche/quiche/quic/core/quic_error_codes.cc
 third_party/quiche/quiche/quic/core/quic_error_codes.h
-third_party/quiche/quiche/quic/core/quic_flags_list.h
 third_party/quiche/quiche/quic/core/quic_flow_controller.cc
 third_party/quiche/quiche/quic/core/quic_flow_controller.h
 third_party/quiche/quiche/quic/core/quic_framer.cc
@@ -762,6 +794,8 @@ third_party/quiche/quiche/quic/core/uber_received_packet_manager.cc
 third_party/quiche/quiche/quic/core/uber_received_packet_manager.h
 third_party/quiche/quiche/quic/core/web_transport_stats.h
 third_party/quiche/quiche/quic/core/web_transport_stats.cc
+third_party/quiche/quiche/quic/core/web_transport_write_blocked_list.h
+third_party/quiche/quiche/quic/core/web_transport_write_blocked_list.cc
 third_party/quiche/quiche/quic/platform/api/quic_bug_tracker.h
 third_party/quiche/quiche/quic/platform/api/quic_client_stats.h
 third_party/quiche/quiche/quic/platform/api/quic_export.h
@@ -779,39 +813,6 @@ third_party/quiche/quiche/quic/platform/api/quic_stack_trace.h
 third_party/quiche/quiche/quic/platform/api/quic_thread.h
 third_party/quiche/quiche/quic/tools/quic_simple_crypto_server_stream_helper.cc
 third_party/quiche/quiche/quic/tools/quic_simple_crypto_server_stream_helper.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_constants.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_constants.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_decoder_adapter.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_decoder_adapter.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_encoder.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_encoder.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_entry.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_entry.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_header_table.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_header_table.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_output_stream.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_output_stream.h
-third_party/quiche/quiche/spdy/core/hpack/hpack_static_table.cc
-third_party/quiche/quiche/spdy/core/hpack/hpack_static_table.h
-third_party/quiche/quiche/spdy/core/http2_frame_decoder_adapter.cc
-third_party/quiche/quiche/spdy/core/http2_frame_decoder_adapter.h
-third_party/quiche/quiche/spdy/core/recording_headers_handler.cc
-third_party/quiche/quiche/spdy/core/recording_headers_handler.h
-third_party/quiche/quiche/spdy/core/spdy_alt_svc_wire_format.cc
-third_party/quiche/quiche/spdy/core/spdy_alt_svc_wire_format.h
-third_party/quiche/quiche/spdy/core/spdy_bitmasks.h
-third_party/quiche/quiche/spdy/core/spdy_frame_builder.cc
-third_party/quiche/quiche/spdy/core/spdy_frame_builder.h
-#third_party/quiche/quiche/spdy/core/spdy_frame_reader.cc
-#third_party/quiche/quiche/spdy/core/spdy_frame_reader.h
-third_party/quiche/quiche/spdy/core/spdy_framer.cc
-third_party/quiche/quiche/spdy/core/spdy_framer.h
-third_party/quiche/quiche/spdy/core/spdy_headers_handler_interface.h
-third_party/quiche/quiche/spdy/core/spdy_no_op_visitor.cc
-third_party/quiche/quiche/spdy/core/spdy_no_op_visitor.h
-third_party/quiche/quiche/spdy/core/spdy_protocol.cc
-third_party/quiche/quiche/spdy/core/spdy_protocol.h
-third_party/quiche/quiche/spdy/core/zero_copy_output_buffer.h
 )
 
 IF(APPLE OR WIN32)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport-transport-http3-quiche",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "A component to add webtransport support (server and client) to node.js, transport using libquiche",
   "exports": {
     ".": {

package/src/http3backendresponse.cc

@@ -15,7 +15,7 @@ namespace quic
 
   Http3BackendResponse::ServerPushInfo::ServerPushInfo(
       std::string request_url,
-      spdy::Http2HeaderBlock headers,
+      quiche::HttpHeaderBlock headers,
       spdy::SpdyPriority priority,
       std::string body)
       : request_url(request_url),

package/src/http3backendresponse.h

@@ -30,13 +30,13 @@ namespace quic
     struct ServerPushInfo
     {
       ServerPushInfo(std::string request_url,
-                     spdy::Http2HeaderBlock headers,
+                     quiche::HttpHeaderBlock headers,
                      spdy::SpdyPriority priority,
                      std::string body);
       ServerPushInfo(const ServerPushInfo &other);
 
       std::string request_url;
-      spdy::Http2HeaderBlock headers;
+      quiche::HttpHeaderBlock headers;
       spdy::SpdyPriority priority;
       std::string body;
     };
@@ -62,18 +62,18 @@ namespace quic
 
     ~Http3BackendResponse();
 
-    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)
+    void AddEarlyHints(const quiche::HttpHeaderBlock &headers)
     {
-      spdy::Http2HeaderBlock hints = headers.Clone();
+      quiche::HttpHeaderBlock hints = headers.Clone();
       hints[":status"] = "103";
       early_hints_.push_back(std::move(hints));
     }
@@ -83,11 +83,11 @@ namespace quic
       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);
     }
@@ -97,10 +97,10 @@ namespace quic
     }
 
   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_;
   };
 

package/src/http3client.cc

@@ -39,7 +39,7 @@
 #include "quiche/quic/tools/quic_url.h"
 #include "quiche/common/quiche_text_utils.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic
 {
@@ -200,7 +200,7 @@ namespace quic
 
     void Http3Client::setHostname(QuicSocketAddress server_address, const std::string &server_hostname)
     {
-        server_id_ = QuicServerId(server_hostname, server_address.port(), false);
+        server_id_ = QuicServerId(server_hostname, server_address.port());
         set_server_address(server_address);
         Initialize();
     }
@@ -249,7 +249,7 @@ namespace quic
 
     void Http3Client::SendRequest(const std::string &uri)
     {
-        spdy::Http2HeaderBlock headers;
+        quiche::HttpHeaderBlock headers;
         if (!PopulateHeaderBlockFromUrl(uri, &headers))
         {
             return;
@@ -259,7 +259,7 @@ namespace quic
 
     void Http3Client::SendRequestAndRstTogether(const std::string &uri)
     {
-        spdy::Http2HeaderBlock headers;
+        quiche::HttpHeaderBlock headers;
         if (!PopulateHeaderBlockFromUrl(uri, &headers))
         {
             return;
@@ -275,13 +275,13 @@ namespace quic
     }
 
     void Http3Client::GetOrCreateStreamAndSendRequest(
-        const spdy::Http2HeaderBlock *headers, absl::string_view body, bool fin)
+        const quiche::HttpHeaderBlock *headers, absl::string_view body, bool fin)
     {
-        std::shared_ptr<spdy::Http2HeaderBlock> spdy_headers;
+        std::shared_ptr<quiche::HttpHeaderBlock> spdy_headers;
         bool hasheaders = false;
         if (headers != nullptr)
         {
-            spdy_headers = std::make_shared<spdy::Http2HeaderBlock>(headers->Clone());
+            spdy_headers = std::make_shared<quiche::HttpHeaderBlock>(headers->Clone());
             hasheaders = true;
         }
 
@@ -315,13 +315,13 @@ namespace quic
             });
     }
 
-    void Http3Client::SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+    void Http3Client::SendMessageAsync(const quiche::HttpHeaderBlock &headers,
                                        absl::string_view body)
     {
         return SendMessageAsync(headers, body, /*fin=*/true);
     }
 
-    void Http3Client::SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+    void Http3Client::SendMessageAsync(const quiche::HttpHeaderBlock &headers,
                                        absl::string_view body, bool fin)
     {
         // Always force creation of a stream for SendMessage.
@@ -498,7 +498,7 @@ namespace quic
         if (override_sni_set_)
         {
             // This should only be set before the initial Connect()
-            server_id_ = QuicServerId(override_sni_, address().port(), false);
+            server_id_ = QuicServerId(override_sni_, address().port());
         }
         connection_in_progress_ = true;
         connectionrecheck_ = true;
@@ -616,7 +616,7 @@ namespace quic
 
     void Http3Client::openWTSessionInt(absl::string_view path)
     {
-        spdy::Http2HeaderBlock headers;
+        quiche::HttpHeaderBlock headers;
         headers[":scheme"] = "https";
         headers[":authority"] = "localhost";
         headers[":path"] = path;
@@ -915,7 +915,7 @@ namespace quic
         return response_headers_complete_;
     }
 
-    const spdy::Http2HeaderBlock *Http3Client::response_headers() const
+    const quiche::HttpHeaderBlock *Http3Client::response_headers() const
     {
         for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
         {
@@ -928,7 +928,7 @@ namespace quic
         return &response_headers_;
     }
 
-    const spdy::Http2HeaderBlock &Http3Client::response_trailers() const
+    const quiche::HttpHeaderBlock &Http3Client::response_trailers() const
     {
         return response_trailers_;
     }
@@ -964,7 +964,7 @@ namespace quic
     }
 
     void Http3Client::OnCompleteResponse(
-        QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
+        QuicStreamId id, const quiche::HttpHeaderBlock &response_headers,
         const absl::string_view &response_body)
     {
         // implement
@@ -982,7 +982,7 @@ namespace quic
         QuicSpdyClientStream *client_stream =
             static_cast<QuicSpdyClientStream *>(stream);
 
-        const Http2HeaderBlock &response_headers = client_stream->response_headers();
+        const HttpHeaderBlock &response_headers = client_stream->response_headers();
 
         OnCompleteResponse(stream->id(), response_headers, client_stream->data());
 
@@ -999,7 +999,7 @@ namespace quic
                 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());
@@ -1044,7 +1044,7 @@ namespace quic
     }
 
     Http3Client::Http3ClientDataToResend::Http3ClientDataToResend(
-        std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
+        std::unique_ptr<quiche::HttpHeaderBlock> headers, absl::string_view body,
         bool fin, Http3Client *client)
         : headers_(std::move(headers)), body_(body), fin_(fin),
           client_(client) {}
@@ -1071,8 +1071,8 @@ namespace quic
     Http3Client::PerStreamState::PerStreamState(
         QuicRstStreamErrorCode stream_error, bool response_complete,
         bool response_headers_complete,
-        const spdy::Http2HeaderBlock &response_headers,
-        const absl::string_view response, const spdy::Http2HeaderBlock &response_trailers,
+        const quiche::HttpHeaderBlock &response_headers,
+        const absl::string_view response, const quiche::HttpHeaderBlock &response_trailers,
         uint64_t bytes_read, uint64_t bytes_written, int64_t response_body_size)
         : stream_error(stream_error),
           response_complete(response_complete),
@@ -1087,7 +1087,7 @@ namespace quic
     Http3Client::PerStreamState::~PerStreamState() = default;
 
     bool Http3Client::PopulateHeaderBlockFromUrl(
-        const std::string &uri, spdy::Http2HeaderBlock *headers)
+        const std::string &uri, quiche::HttpHeaderBlock *headers)
     {
         std::string url;
         if (absl::StartsWith(uri, "https://") || absl::StartsWith(uri, "http://"))

package/src/http3client.h

@@ -157,12 +157,12 @@ namespace quic
 
         // Sends a request containing |headers| and |body| and returns the number of
         // bytes sent (the size of the serialized request headers and body).
-        void SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+        void SendMessageAsync(const quiche::HttpHeaderBlock &headers,
                               absl::string_view body);
         // Sends a request containing |headers| and |body| with the fin bit set to
         // |fin| and returns the number of bytes sent (the size of the serialized
         // request headers and body).
-        void SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+        void SendMessageAsync(const quiche::HttpHeaderBlock &headers,
                               absl::string_view body, bool fin);
 
         void SendConnectivityProbing();
@@ -193,13 +193,13 @@ namespace quic
         // is received. 2) returns state of the oldest active stream which have
         // received partial response (if any).
         // Group 1.
-        const spdy::Http2HeaderBlock &response_trailers() const;
+        const quiche::HttpHeaderBlock &response_trailers() const;
         bool response_complete() const;
         int64_t response_body_size() const;
         const std::string &response_body() const;
         // Group 2.
         bool response_headers_complete() const;
-        const spdy::Http2HeaderBlock *response_headers() const;
+        const quiche::HttpHeaderBlock *response_headers() const;
         int64_t response_size() const;
         size_t bytes_read() const;
         size_t bytes_written() const;
@@ -214,7 +214,7 @@ namespace quic
 
         // QuicSpdyClientBase::Reponselistener
         void OnCompleteResponse(
-            QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
+            QuicStreamId id, const quiche::HttpHeaderBlock &response_headers,
             const absl::string_view &response_body);
 
         // Returns nullptr if the maximum number of streams have already been created.
@@ -226,7 +226,7 @@ namespace quic
         // stores the request in case it needs to be resent.  If |headers| is
         // null, only the body will be sent on the stream.
         void GetOrCreateStreamAndSendRequest(
-            const spdy::Http2HeaderBlock *headers, absl::string_view body, bool fin);
+            const quiche::HttpHeaderBlock *headers, absl::string_view body, bool fin);
 
         QuicRstStreamErrorCode stream_error() { return stream_error_; }
         QuicErrorCode connection_error() const;
@@ -263,7 +263,7 @@ namespace quic
         // request. If |uri| is a relative URL, the QuicServerId will be
         // use to specify the authority.
         bool PopulateHeaderBlockFromUrl(const std::string &uri,
-                                        spdy::Http2HeaderBlock *headers);
+                                        quiche::HttpHeaderBlock *headers);
 
         QuicSpdyClientStream *latest_created_stream()
         {
@@ -291,7 +291,7 @@ namespace quic
         {
         public:
             Http3ClientDataToResend(
-                std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
+                std::unique_ptr<quiche::HttpHeaderBlock> headers, absl::string_view body,
                 bool fin, Http3Client *client);
 
             ~Http3ClientDataToResend();
@@ -299,7 +299,7 @@ namespace quic
             void Resend();
 
         protected:
-            std::unique_ptr<spdy::Http2HeaderBlock> headers_;
+            std::unique_ptr<quiche::HttpHeaderBlock> headers_;
             absl::string_view body_;
             bool fin_;
             Http3Client *client_;
@@ -311,9 +311,9 @@ namespace quic
             PerStreamState(const PerStreamState &other);
             PerStreamState(QuicRstStreamErrorCode stream_error, bool response_complete,
                            bool response_headers_complete,
-                           const spdy::Http2HeaderBlock &response_headers,
+                           const quiche::HttpHeaderBlock &response_headers,
                            const absl::string_view response,
-                           const spdy::Http2HeaderBlock &response_trailers,
+                           const quiche::HttpHeaderBlock &response_trailers,
                            uint64_t bytes_read, uint64_t bytes_written,
                            int64_t response_body_size);
             ~PerStreamState();
@@ -321,9 +321,9 @@ namespace quic
             QuicRstStreamErrorCode stream_error;
             bool response_complete;
             bool response_headers_complete;
-            spdy::Http2HeaderBlock response_headers;
+            quiche::HttpHeaderBlock response_headers;
             std::string response;
-            spdy::Http2HeaderBlock response_trailers;
+            quiche::HttpHeaderBlock response_trailers;
             uint64_t bytes_read;
             uint64_t bytes_written;
             int64_t response_body_size;
@@ -381,10 +381,10 @@ namespace quic
 
         bool response_complete_;
         bool response_headers_complete_;
-        mutable spdy::Http2HeaderBlock response_headers_;
+        mutable quiche::HttpHeaderBlock response_headers_;
 
         // Parsed response trailers (if present), copied from the stream in OnClose.
-        spdy::Http2HeaderBlock response_trailers_;
+        quiche::HttpHeaderBlock response_trailers_;
 
         QuicStreamPriority priority_;
         std::string response_;
@@ -504,7 +504,7 @@ namespace quic
         // 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.

package/src/http3clientsession.h

@@ -47,13 +47,13 @@ namespace quic
     }
 
     void set_on_interim_headers(
-        std::function<void(const spdy::Http2HeaderBlock &)> on_interim_headers)
+        std::function<void(const quiche::HttpHeaderBlock &)> on_interim_headers)
     {
       on_interim_headers_ = std::move(on_interim_headers);
     }
 
   private:
-    std::function<void(const spdy::Http2HeaderBlock &)> on_interim_headers_;
+    std::function<void(const quiche::HttpHeaderBlock &)> on_interim_headers_;
     const bool drop_response_body_;
     const bool enable_web_transport_;
     absl::flat_hash_map<QuicStreamId, webtransport::SessionVisitor *> svisitors_;

package/src/http3clientstream.h

@@ -24,7 +24,7 @@ class Http3ClientStream : public QuicSpdyClientStream {
   void OnBodyAvailable() override;
 
   void set_on_interim_headers(
-      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+      std::function<void(const quiche::HttpHeaderBlock&)> on_interim_headers) {
     on_interim_headers_ = std::move(on_interim_headers);
   }
 
@@ -33,7 +33,7 @@ class Http3ClientStream : public QuicSpdyClientStream {
 
 
  private:
-  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
+  std::function<void(const quiche::HttpHeaderBlock&)> on_interim_headers_;
   const bool drop_response_body_;
 };
 

package/src/http3server.cc

@@ -426,7 +426,7 @@ namespace quic
         .Call(objVal, {retObj});
   }
 
-  void Http3ServerJS::processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqhead, WebTransportRespPromisePtr promise)
+  void Http3ServerJS::processNewSessionRequest(WebTransportSession *session, const quiche::HttpHeaderBlock &reqhead, WebTransportRespPromisePtr promise)
   {
     Napi::HandleScope scope(Env());
 

package/src/http3server.h

@@ -85,7 +85,7 @@ namespace quic
         }
 
         void processNewSession(Http3WTSession *session, const std::string &path, Napi::Reference<Napi::Value> *header, Napi::Reference<Napi::Value> *userData);
-        void processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqheadcopy, WebTransportRespPromisePtr promise);
+        void processNewSessionRequest(WebTransportSession *session, const quiche::HttpHeaderBlock &reqheadcopy, WebTransportRespPromisePtr promise);
 
     protected:
         std::unique_ptr<Http3Server> server_;

package/src/http3serverbackend.cc

@@ -25,7 +25,7 @@
 #include "quiche/common/platform/api/quiche_file_utils.h"
 #include "quiche/common/quiche_text_utils.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic
 {
@@ -34,7 +34,7 @@ namespace quic
   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));
@@ -45,7 +45,7 @@ namespace quic
 
   Http3ServerBackend::WebTransportRespPromisePtr
   Http3ServerBackend::ProcessWebTransportRequest(
-      const spdy::Http2HeaderBlock &request_headers,
+      const quiche::HttpHeaderBlock &request_headers,
       WebTransportSession *session)
   {
     WebTransportRespPromisePtr promise = std::make_shared<WebTransportRespPromise>();

package/src/http3serverbackend.h

@@ -15,7 +15,7 @@
 
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/web_transport_interface.h"
-#include "quiche/spdy/core/http2_header_block.h"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic
 {
@@ -62,7 +62,7 @@ namespace quic
   public:
     struct WebTransportResponse
     {
-      spdy::Http2HeaderBlock response_headers;
+      quiche::HttpHeaderBlock response_headers;
       std::unique_ptr<WebTransportVisitor> visitor;
     };
 
@@ -77,7 +77,7 @@ namespace quic
     void setJSHandler(bool on) { jshandlerequesthandler_ = on; }
 
     WebTransportRespPromisePtr ProcessWebTransportRequest(
-        const spdy::Http2HeaderBlock & /*request_headers*/,
+        const quiche::HttpHeaderBlock & /*request_headers*/,
         WebTransportSession * /*session*/);
     bool SupportsWebTransport() { return true; }
     bool UsesDatagramContexts() { return true; }

package/src/http3serverstream.cc

@@ -27,7 +27,7 @@
 #include "src/http3serversession.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic
 {
@@ -279,7 +279,7 @@ namespace quic
     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");
@@ -317,7 +317,7 @@ namespace quic
         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);
@@ -356,7 +356,7 @@ namespace quic
   void Http3ServerStream::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);
@@ -374,7 +374,7 @@ namespace quic
     {
       StopReading();
     }
-    Http2HeaderBlock headers;
+    HttpHeaderBlock headers;
     if (resp_code <= 0)
     {
       headers[":status"] = "500";
@@ -388,7 +388,7 @@ namespace quic
   }
 
   void Http3ServerStream::SendIncompleteResponse(
-      Http2HeaderBlock response_headers,
+      HttpHeaderBlock response_headers,
       absl::string_view body)
   {
     QUIC_DLOG(INFO) << "Stream " << id() << " writing headers (fin = false) : "
@@ -406,17 +406,17 @@ namespace quic
   }
 
   void Http3ServerStream::SendHeadersAndBody(
-      Http2HeaderBlock response_headers,
+      HttpHeaderBlock response_headers,
       absl::string_view body)
   {
     SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
-                                  Http2HeaderBlock());
+                                  HttpHeaderBlock());
   }
 
   void Http3ServerStream::SendHeadersAndBodyAndTrailers(
-      Http2HeaderBlock response_headers,
+      HttpHeaderBlock response_headers,
       absl::string_view body,
-      Http2HeaderBlock response_trailers)
+      HttpHeaderBlock response_trailers)
   {
     // Send the headers, with a FIN if there's nothing else to send.
     bool send_fin = (body.empty() && response_trailers.empty());

package/src/http3serverstream.h

@@ -16,7 +16,7 @@
 #include "quiche/quic/core/quic_packets.h"
 #include "src/http3serverbackend.h"
 #include "src/http3backendresponse.h"
-#include "quiche/spdy/core/spdy_framer.h"
+#include "quiche/http2/core/spdy_framer.h"
 
 namespace quic
 {
@@ -78,16 +78,16 @@ namespace quic
     void SendNotFoundResponse();
 
     // Sends the response header and body, but not the fin.
-    void SendIncompleteResponse(spdy::Http2HeaderBlock response_headers,
+    void SendIncompleteResponse(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(spdy::Http2HeaderBlock response_headers,
+    void SendHeadersAndBodyAndTrailers(quiche::HttpHeaderBlock response_headers,
                                        absl::string_view body,
-                                       spdy::Http2HeaderBlock response_trailers);
+                                       quiche::HttpHeaderBlock response_trailers);
 
-    spdy::Http2HeaderBlock *request_headers() { return &request_headers_; }
+    quiche::HttpHeaderBlock *request_headers() { return &request_headers_; }
 
     const std::string &body() { return body_; }
 
@@ -95,7 +95,7 @@ namespace quic
     void WriteGeneratedBytes();
 
     // The parsed headers received from the client.
-    spdy::Http2HeaderBlock request_headers_;
+    quiche::HttpHeaderBlock request_headers_;
     int64_t content_length_;
     std::string body_;
     // promises not fullfilled from js side or c++ side

package/src/librarymain.cc

@@ -14,6 +14,7 @@
 #include "src/http3wtsessionvisitor.h"
 #include "src/napialarmfactory.h"
 #include "quiche/common/platform/api/quiche_command_line_flags.h"
+#include "quiche/common/platform/api/quiche_flags.h"
 
 #include "absl/log/initialize.h"
 #include "absl/strings/string_view.h"
@@ -58,6 +59,7 @@ namespace quic
     {
       quiche_cmd_line_char.push_back((*cur).c_str());
     }
+    SetQuicheReloadableFlag(quic_deliver_stop_sending_to_zombie_streams, true); // enable patch
     if (!hasSetLogging)
     {
       quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));