@fails-components/webtransport 0.1.5 → 0.1.7

package/dist/lib/webtransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webtransport.d.ts","sourceRoot":"","sources":["../../lib/webtransport.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,iBAHW,MAAM,0DAyDhB;IAlCC,qBAA6B;IAC7B,uDAA+B;IAE/B,4DAAqC;IAErC,8DAA8D;IAC9D,8BADW,eAAe,+BAA+B,CAAC,CACiB;IAE3E,wDAAwD;IACxD,+BADW,eAAe,yBAAyB,CAAC,CAEV;IA0B5C;;OAEG;IACH,2EASC;IAED,sFASC;IAED,8EASC;CACF;oCA1GY,OAAO,OAAO,EAAE,qBAAqB;8CACrC,OAAO,OAAO,EAAE,+BAA+B;wCAC/C,OAAO,OAAO,EAAE,yBAAyB;oCAIzC,OAAO,OAAO,EAAE,YAAY"}
+{"version":3,"file":"webtransport.d.ts","sourceRoot":"","sources":["../../lib/webtransport.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,iBAHW,MAAM,0DA0DhB;IAnCC,qBAA6B;IAC7B,uDAA+B;IAC/B,6BAAmC;IAEnC,4DAAqC;IAErC,8DAA8D;IAC9D,8BADW,eAAe,+BAA+B,CAAC,CACiB;IAE3E,wDAAwD;IACxD,+BADW,eAAe,yBAAyB,CAAC,CAEV;IA0B5C,+DAQC;IAED,uEAQC;IAED;;;;;;;;;;;;;;;;;;OAQC;IAED;;OAEG;IACH,2EASC;IAED,sFASC;IAED,8EASC;CACF;oCAzIY,OAAO,OAAO,EAAE,qBAAqB;8CACrC,OAAO,OAAO,EAAE,+BAA+B;wCAC/C,OAAO,OAAO,EAAE,yBAAyB;oCAIzC,OAAO,OAAO,EAAE,YAAY"}

package/lib/dom.ts

@@ -73,13 +73,16 @@ export interface WebTransportOptions {
   allowPooling?: boolean
   requireUnreliable?: boolean
   serverCertificateHashes?: WebTransportHash[]
+  congestionControl?: WebTransportCongestionControl
 }
 
 export interface WebTransport {
-  // getStats: () => Promise<WebTransportStats>
+  getStats: () => Promise<WebTransportStats>
   readonly ready: Promise<void>
-  // readonly reliability: WebTransportReliabilityMode
+  readonly reliability: WebTransportReliabilityMode
+  readonly congestionControl: WebTransportCongestionControl
   readonly closed: Promise<WebTransportCloseInfo>
+  readonly draining: Promise<undefined>
   close: (closeInfo?: WebTransportCloseInfo) => void
   readonly datagrams: WebTransportDatagramDuplexStream
 
@@ -93,3 +96,5 @@ export interface WebTransport {
 }
 
 export type WebTransportReliabilityMode = 'pending' | 'reliable-only' | 'supports-unreliable'
+export type WebTransportCongestionControl = 'default' | 'throughput' | 'low-latency';
+

package/lib/event-loop.js

@@ -15,7 +15,8 @@ export class Http3EventLoop {
       transportCallback: Http3WebTransport.transportCallback,
       streamCallback: Http3WTStream.callback,
       sessionCallback: Http3WTSession.callback,
-      eventloopCallback: Http3EventLoop.callback
+      eventloopCallback: Http3EventLoop.callback,
+      quicheLogVerbose: args?.quicheLogVerbose
     })
     this.eventloopInt.jsobj = this
 
@@ -23,9 +24,12 @@ export class Http3EventLoop {
     this.loopGuardian = this.loopGuardian.bind(this)
   }
 
-  startEventLoop() {
+  /**
+   * @param {*} [args]
+   */
+  startEventLoop(args) {
     console.log('start GlobalEventLoop')
-    this.eventloopInt.startEventLoop()
+    this.eventloopInt.startEventLoop(args)
     this.loopGuardianTimer = setInterval(this.loopGuardian, 5000)
   }
 
@@ -54,12 +58,13 @@ export class Http3EventLoop {
   }
 
   /**
+   * @param {any} [args]
    * @returns {Http3EventLoop}
    */
-  static createGlobalEventLoop() {
+  static createGlobalEventLoop(args) {
     if (!Http3EventLoop.globalLoop) {
       Http3EventLoop.globalLoop = new Http3EventLoop()
-      Http3EventLoop.globalLoop.startEventLoop()
+      Http3EventLoop.globalLoop.startEventLoop(args)
       console.log('createGlobalEventLoop')
     }
     return Http3EventLoop.globalLoop
@@ -67,12 +72,13 @@ export class Http3EventLoop {
 
   /**
    * @param {any} object
+   * @param {any} args
    * @returns {Http3EventLoop}
    */
-  static getGlobalEventLoop(object) {
+  static getGlobalEventLoop(object, args) {
     if (!object) throw new Error('getGlobalEventLoop without reference object')
     const loop =
-      Http3EventLoop.globalLoop ?? Http3EventLoop.createGlobalEventLoop()
+      Http3EventLoop.globalLoop ?? Http3EventLoop.createGlobalEventLoop(args)
     loop.refObjects.add(new WeakRef(object))
     return loop
   }

package/lib/server.js

@@ -29,7 +29,7 @@ export class Http3Server extends Http3WebTransport {
     /** @type {Record<string, ReadableStream>} */
     this.sessionStreams = {}
 
-    /** @type {Record<string, ReadableStreamController<any>>} */
+    /** @type {Record<string, ReadableStreamDefaultController<Http3WTSession>>} */
     this.sessionController = {}
 
     this.port = null

package/lib/session.js

@@ -13,7 +13,11 @@ import { Http3WTStream } from './stream.js'
  * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./dom').WebTransportDatagramDuplexStream} WebTransportDatagramDuplexStream
+ * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
+ * @typedef {import('./dom').WebTransportCongestionControl} WebTransportCongestionControl
+ * @typedef {import('./dom').WebTransportStats} WebTransportStats
  *
  * @typedef {import('./types').NativeHttp3WTSession} NativeHttp3WTSession
  *
@@ -58,19 +62,32 @@ export class Http3WTSession {
       this.readyResolve = resolve
       this.readyReject = reject
     })
+    /** @type {WebTransportReliabilityMode} */
+    this.reliability = 'pending'
+    /** @type {WebTransportCongestionControl} */
+    this.congestionControl = 'default'
     /** @type {Promise<WebTransportCloseInfo>} */
     this.closed = new Promise((resolve, reject) => {
       this.closedResolve = resolve
       this.closedReject = reject
     })
 
+    /** @type {Promise<undefined>} */
+    this.draining = new Promise((resolve, reject) => {
+      this.drainingResolve = resolve
+      this.drainingReject = reject
+    })
+
+    /** @type {ReadableStream<WebTransportBidirectionalStream>} */
     this.incomingBidirectionalStreams = new ReadableStream({
+      /** @param {ReadableStreamDefaultController<WebTransportBidirectionalStream>} controller */
       start: (controller) => {
         this.incomBiDiController = controller
       }
     })
-
+    /** @type {ReadableStream<WebTransportReceiveStream>} */
     this.incomingUnidirectionalStreams = new ReadableStream({
+      /** @param {ReadableStreamDefaultController<WebTransportReceiveStream>} controller */
       start: (controller) => {
         this.incomUniDiController = controller
       }
@@ -86,7 +103,9 @@ export class Http3WTSession {
     /** @type {WebTransportDatagramDuplexStream} */
     this.datagrams = {
       readable: new ReadableStream({
-        start: (controller) => {
+        start: (
+          /** @type {ReadableStreamDefaultController<Uint8Array>} */ controller
+        ) => {
           this.incomDatagramController = controller
         }
       }),
@@ -126,7 +145,9 @@ export class Http3WTSession {
     /** @type {Array<(err?: Error) => void>} */
     this.rejectUniDi = []
 
+    /** @type {Set<WebTransportSendStream>} */
     this.sendStreams = new Set()
+    /** @type {Set<WebTransportReceiveStream>} */
     this.receiveStreams = new Set()
     /** @type {Set<Http3WTStream>} */
     this.streamObjs = new Set()
@@ -147,6 +168,28 @@ export class Http3WTSession {
     }
   }
 
+  getStats() {
+    return Promise.resolve({
+      timestamp: Date.now(),
+      bytesSent: BigInt(0),
+      packetsSent: BigInt(0),
+      packetsLost: BigInt(0),
+      numOutgoingStreamsCreated: 0,
+      numIncomingStreamsCreated: 0,
+      bytesReceived: BigInt(0),
+      packetsReceived: BigInt(0),
+      smoothedRtt: 0,
+      rttVariation: 0,
+      minRtt: 0,
+      datagrams: {
+        timestamp: Date.now(),
+        expiredOutgoing: BigInt(0),
+        droppedIncoming: BigInt(0),
+        lostOutgoing: BigInt(0)
+      }
+    })
+  }
+
   async waitForDatagramsSend() {
     while (this.writeDatagramProm.length > 0) {
       try {
@@ -172,7 +215,7 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {WritableStream} stream
+   * @param {WebTransportSendStream} stream
    * @param {WritableStreamDefaultController} controller
    */
   addSendStream(stream, controller) {
@@ -181,7 +224,7 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {WritableStream} stream
+   * @param {WebTransportSendStream} stream
    * @param {WritableStreamDefaultController} controller
    */
   removeSendStream(stream, controller) {
@@ -190,7 +233,7 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {ReadableStream} stream
+   * @param {WebTransportReceiveStream } stream
    * @param {ReadableStreamDefaultController} controller
    */
   addReceiveStream(stream, controller) {
@@ -199,7 +242,7 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {ReadableStream} stream
+   * @param {WebTransportReceiveStream } stream
    * @param {ReadableStreamDefaultController} controller
    */
   removeReceiveStream(stream, controller) {
@@ -257,6 +300,7 @@ export class Http3WTSession {
   }
 
   onReady(/* error */) {
+    this.reliability = 'supports-unreliable'
     if (this.readyResolve) this.readyResolve()
     delete this.readyResolve
   }
@@ -347,20 +391,7 @@ export class Http3WTSession {
         const curres = this.resolveUniDi.shift()
 
         if (curres != null && strobj.writable != null) {
-          /** @type {WebTransportSendStream} */
-          // @ts-expect-error `getStats` property is missing from WritableStream
-          // we add it on the next line
-          const sendStream = strobj.writable
-          sendStream.getStats = () => {
-            return Promise.resolve({
-              timestamp: 0,
-              bytesWritten: 0n,
-              bytesSent: 0n,
-              bytesAcknowledged: 0n
-            })
-          }
-
-          curres(sendStream)
+          curres(strobj.writable)
         }
       }
     }

package/lib/stream.js

@@ -39,21 +39,26 @@ export class Http3WTStream {
     this.pendingres = null
 
     if (this.bidirectional || this.incoming) {
+      // @ts-expect-error `getStats` property is missing from ReadavleStream
+      /** @type {WebTransportReceiveStream} */
       this.readable = new ReadableStream(
         {
-          start: (controller) => {
+          start: (
+            /** @type {ReadableStreamDefaultController<Uint8Array>} */ controller
+          ) => {
             this.readableController = controller
-            // @ts-expect-error this.readable could be undefined
             this.parentobj.addReceiveStream(this.readable, controller)
             this.objint.startReading()
           },
-          pull: (controller) => {
+          pull: (
+            /** @type {ReadableStreamDefaultController<Uint8Array>} */ controller
+          ) => {
             if (this.readableclosed) {
               return Promise.resolve()
             }
             this.objint.startReading()
           },
-          cancel: (reason) => {
+          cancel: (/** @type {{ code: number; }} */ reason) => {
             /** @type {Promise<void>} */
             const promise = new Promise((resolve, reject) => {
               this.cancelres = resolve
@@ -71,13 +76,21 @@ export class Http3WTStream {
         },
         { highWaterMark: 4 }
       )
+      this.readable.getStats = () => {
+        return Promise.resolve({
+          timestamp: 0,
+          bytesReceived: 0n,
+          bytesResd: 0n
+        })
+      }
     }
     if (this.bidirectional || !this.incoming) {
+      // @ts-expect-error `getStats` property is missing from WritableStream
+      /** @type {WebTransportSendStream} */
       this.writable = new WritableStream(
         {
           start: (controller) => {
             this.writableController = controller
-            // @ts-expect-error this.writable could be undefined
             this.parentobj.addSendStream(this.writable, controller)
           },
           write: (chunk, controller) => {
@@ -130,6 +143,14 @@ export class Http3WTStream {
         },
         { highWaterMark: 4 }
       )
+      this.writable.getStats = () => {
+        return Promise.resolve({
+          timestamp: 0,
+          bytesWritten: 0n,
+          bytesSent: 0n,
+          bytesAcknowledged: 0n
+        })
+      }
     }
 
     /** @type {(() => void) | null} */

package/lib/transport.js

@@ -7,7 +7,9 @@ export class Http3WebTransport {
    * @param {'server' | 'client'} purpose
    */
   constructor(args, purpose) {
-    const eventloop = Http3EventLoop.getGlobalEventLoop(this).eventloopInt
+    const eventloop = Http3EventLoop.getGlobalEventLoop(this, {
+      quicheLogVerbose: args.quicheLogVerbose
+    }).eventloopInt
 
     if (purpose === 'server')
       this.transportInt = new wtrouter.Http3WebTransportServer(args, eventloop)

package/lib/types.ts

@@ -8,6 +8,7 @@ import type { WebTransport } from './dom'
   writeDatagram: (chunk: Uint8Array) => void
   orderUnidiStream: () => void
   orderBidiStream: () => void
+  // orderStats: () => void
   close: (arg: { code: number, reason: string }) => void
 }
 

package/lib/webtransport.js

@@ -42,6 +42,7 @@ export class WebTransport {
 
     this.ready = sessionint.ready
     this.closed = sessionint.closed
+    this.draining = sessionint.draining
 
     this.datagrams = sessionint.datagrams
 
@@ -76,6 +77,36 @@ export class WebTransport {
       })
   }
 
+  get reliability() {
+    const session = sessions.get(this)
+
+    if (session == null) {
+      // should never happen as session is only removed when this instance is garbage collected
+      throw new Error('Http3WTSession was undefined')
+    }
+    return session.reliability
+  }
+
+  get congestionControl() {
+    const session = sessions.get(this)
+
+    if (session == null) {
+      // should never happen as session is only removed when this instance is garbage collected
+      throw new Error('Http3WTSession was undefined')
+    }
+    return session.congestionControl
+  }
+
+  getStats() {
+    const session = sessions.get(this)
+
+    if (session == null) {
+      // should never happen as session is only removed when this instance is garbage collected
+      throw new Error('Http3WTSession was undefined')
+    }
+    return session.getStats()
+  }
+
   /**
    * @param {WebTransportCloseInfo} [closeinfo]
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -45,7 +45,7 @@
     "@types/chai": "^4.3.3",
     "@types/dirty-chai": "^2.0.2",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^18.11.5",
+    "@types/node": "^18.15.3",
     "chai": "^4.3.6",
     "cmake-js": "^6.3.2",
     "dirty-chai": "^2.0.1",

package/platform/quiche/quic/core/io/socket_win.inc

@@ -0,0 +1,3 @@
+#include "absl/strings/ascii.h"
+#warning "Fake socketwin included"
+#include "third_party/quiche/quiche/quic/core/io/socket_win.inc"

package/platform/quiche_platform_impl/quiche_command_line_flags_impl.h

@@ -0,0 +1,7 @@
+// use default impl
+#ifndef QUICHE_COMMAND_LINE_FLAGS_IMPL
+#define QUICHE_COMMAND_LINE_FLAGS_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_export_impl.h

@@ -1,12 +1,6 @@
-#ifndef QUICHE_EXPORT_IMPL
-#define QUICHE_EXPORT_IMPL
+#ifndef QUICHE_EXPORT_IMPL_HEADER
+#define QUICHE_EXPORT_IMPL_HEADER
 
-// dirty hack to fix absl include error
-
-#include "absl/types/optional.h"
-
-#define QUICHE_EXPORT_IMPL
-#define QUICHE_EXPORT_PRIVATE_IMPL
-#define QUICHE_NO_EXPORT_IMPL
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_export_impl.h"
 
 #endif

package/platform/quiche_platform_impl/quiche_server_stats_impl.h

@@ -2,27 +2,6 @@
 #ifndef QUICHE_SERVER_STATS_IMPL
 #define QUICHE_SERVER_STATS_IMPL
 
-
-// NOLINT(namespace-envoy)
-//
-// This file is part of the QUICHE platform implementation, and is not to be
-// consumed or referenced directly by other Envoy code. It serves purely as a
-// porting layer for QUICHE.
-
-#define QUICHE_SERVER_HISTOGRAM_ENUM_IMPL(name, sample, enum_size, docstring)                        \
-  do {                                                                                             \
-  } while (0)
-
-#define QUICHE_SERVER_HISTOGRAM_BOOL_IMPL(name, sample, docstring)                                   \
-  do {                                                                                             \
-  } while (0)
-
-#define QUICHE_SERVER_HISTOGRAM_TIMES_IMPL(name, sample, min, max, bucket_count, docstring)          \
-  do {                                                                                             \
-  } while (0)
-
-#define QUICHE_SERVER_HISTOGRAM_COUNTS_IMPL(name, sample, min, max, bucket_count, docstring)         \
-  do {                                                                                             \
-  } while (0)
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_server_stats_impl.h"
 
 #endif

package/platform/quiche_platform_impl/quiche_stream_buffer_allocator_impl.h

@@ -4,8 +4,5 @@
 // found in the LICENSE file.
 #ifndef NET_QUIC_PLATFORM_IMPL_QUIC_STREAM_BUFFER_ALLOCATOR_IMPL_H_
 #define NET_QUIC_PLATFORM_IMPL_QUIC_STREAM_BUFFER_ALLOCATOR_IMPL_H_
-#include "quiche/common/simple_buffer_allocator.h"
-namespace quiche {
-using QuicheStreamBufferAllocatorImpl = quiche::SimpleBufferAllocator;
-}  // namespace quic
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_stream_buffer_allocator_impl.h"
 #endif  // NET_QUIC_PLATFORM_IMPL_QUIC_STREAM_BUFFER_ALLOCATOR_IMPL_H_

package/platform/quiche_platform_impl/quiche_time_utils_impl.h

@@ -8,18 +8,6 @@
 #ifndef QUICHE_TIME_UTILS_IMPL
 #define QUICHE_TIME_UTILS_IMPL
 
-#include <cstdint>
-
-#include "absl/time/civil_time.h"
-#include "absl/time/time.h"
-#include "absl/types/optional.h"
-
-namespace quiche {
-
-// NOLINTNEXTLINE(readability-identifier-naming)
-absl::optional<int64_t> QuicheUtcDateTimeToUnixSecondsImpl(int year, int month, int day, int hour,
-                                                           int minute, int second);
-
-} // namespace quiche
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_time_utils_impl.h"
 
 #endif

package/platform/quiche_platform_impl/quiche_udp_socket_platform_impl.h

@@ -25,6 +25,15 @@ inline bool GetGooglePacketHeadersFromControlMessageImpl(
 
 inline void SetGoogleSocketOptionsImpl(int fd) {}
 
+inline int GetEcnCmsgArgsPreserveDscpImpl(const int /*fd*/,
+                                          const int /*address_family*/,
+                                          uint8_t /*ecn_codepoint*/,
+                                          int& /*type*/, void* /*value*/,
+                                          socklen_t& /*value_len*/) {
+  // TODO(b/273081493): implement this.
+  return 0;
+}
+
 }  // namespace quic
 
 #endif  // NET_QUIC_PLATFORM_IMPL_QUIC_UDP_SOCKET_PLATFORM_IMPL_H_

package/readme.md

@@ -59,7 +59,7 @@ When testing remember you might need to start chromium based browser with certai
 ```
 chrome --ignore-certificate-errors-spki-list=FINGERPRINTOFYOURCERTIFICATE --ignore-certificate-errors --v=2 --enable-logging=stderr --origin-to-force-quic-on=192.168.1.50:8080
 ```
-of course replace IP and fingerprint of your certificate accordingly.
+of course replace IP and fingerprint of your certificate accordingly. However, the author never got this to work and is using this without flags, but supplies instead a fingerprint when opening a WebTransport session. (PR welcome).
 
 ## Specification divergence
 
@@ -76,6 +76,8 @@ They are:
 * [getStats()](https://www.w3.org/TR/webtransport/#dom-webtransport-getstats)
 * [reliability](https://www.w3.org/TR/webtransport/#dom-webtransport-reliability)
 
+The WebTransport client only supports certification validation using fingerprints. Without a fingerprint it will accept any server without certificate checking.
+
 ### WebTransportDatagramDuplexStream
 
 * [maxDatagramSize](https://www.w3.org/TR/webtransport/#dom-webtransportdatagramduplexstream-maxdatagramsize)

package/src/http3client.cc

@@ -63,10 +63,11 @@ namespace quic
             WriteResult WritePacket(const char *buffer, size_t buf_len,
                                     const QuicIpAddress &self_address,
                                     const QuicSocketAddress &peer_address,
-                                    PerPacketOptions *options) override
+                                    PerPacketOptions *options,
+                                    const quic::QuicPacketWriterParams& wparams) override
             {
                 WriteResult result = QuicDefaultPacketWriter::WritePacket(
-                    buffer, buf_len, self_address, peer_address, options);
+                    buffer, buf_len, self_address, peer_address, options, wparams);
                 if (IsWriteBlockedStatus(result.status))
                 {
                     bool success = event_loop_->RearmSocket(fd(), kSocketEventWritable);
@@ -148,7 +149,8 @@ namespace quic
           connection_in_progress_(false),
           num_attempts_connect_(0),
           webtransport_server_support_inform_(false),
-          connection_debug_visitor_(nullptr)
+          connection_debug_visitor_(nullptr),
+          priority_(HttpStreamPriority())
     {
         set_server_address(server_address);
         Initialize();
@@ -183,7 +185,7 @@ namespace quic
 
     void Http3Client::Initialize()
     {
-        priority_ = QuicStreamPriority();
+        priority_ = QuicStreamPriority(HttpStreamPriority());
         connect_attempted_ = false;
         auto_reconnect_ = false;
         buffer_body_ = true;
@@ -891,7 +893,6 @@ namespace quic
         response_ = "";
         response_complete_ = false;
         response_headers_complete_ = false;
-        preliminary_headers_.clear();
         response_headers_.clear();
         response_trailers_.clear();
         bytes_read_ = 0;
@@ -990,21 +991,6 @@ namespace quic
         return &response_headers_;
     }
 
-    const spdy::Http2HeaderBlock *Http3Client::preliminary_headers() const
-    {
-        for (std::pair<QuicStreamId, QuicSpdyClientStream *> stream : open_streams_)
-        {
-            size_t bytes_read =
-                stream.second->stream_bytes_read() + stream.second->header_bytes_read();
-            if (bytes_read > 0)
-            {
-                preliminary_headers_ = stream.second->preliminary_headers().Clone();
-                break;
-            }
-        }
-        return &preliminary_headers_;
-    }
-
     const spdy::Http2HeaderBlock &Http3Client::response_trailers() const
     {
         return response_trailers_;
@@ -1042,7 +1028,7 @@ namespace quic
 
     void Http3Client::OnCompleteResponse(
         QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
-        const std::string &response_body)
+        const absl::string_view &response_body)
     {
         // implement
     }
@@ -1076,8 +1062,11 @@ namespace quic
                 QUIC_LOG(ERROR) << "Invalid :status response header: " << status->second;
             }
             latest_response_headers_ = response_headers.DebugString();
-            preliminary_response_headers_ =
-                client_stream->preliminary_headers().DebugString();
+            for (const Http2HeaderBlock &headers :
+                 client_stream->preliminary_headers())
+            {
+                absl::StrAppend(&preliminary_response_headers_, headers.DebugString());
+            }
             latest_response_header_block_ = response_headers.Clone();
             latest_response_body_ = client_stream->data();
             latest_response_trailers_ =
@@ -1101,7 +1090,6 @@ namespace quic
                 client_stream->stream_error(), connected(),
                 client_stream->headers_decompressed(),
                 client_stream->response_headers(),
-                client_stream->preliminary_headers(),
                 (buffer_body() ? client_stream->data() : ""),
                 client_stream->received_trailers(),
                 // Use NumBytesConsumed to avoid counting retransmitted stream frames.
@@ -1226,7 +1214,6 @@ namespace quic
           response_complete(other.response_complete),
           response_headers_complete(other.response_headers_complete),
           response_headers(other.response_headers.Clone()),
-          preliminary_headers(other.preliminary_headers.Clone()),
           response(other.response),
           response_trailers(other.response_trailers.Clone()),
           bytes_read(other.bytes_read),
@@ -1237,14 +1224,12 @@ namespace quic
         QuicRstStreamErrorCode stream_error, bool response_complete,
         bool response_headers_complete,
         const spdy::Http2HeaderBlock &response_headers,
-        const spdy::Http2HeaderBlock &preliminary_headers,
-        const std::string &response, const spdy::Http2HeaderBlock &response_trailers,
+        const absl::string_view response, const spdy::Http2HeaderBlock &response_trailers,
         uint64_t bytes_read, uint64_t bytes_written, int64_t response_body_size)
         : stream_error(stream_error),
           response_complete(response_complete),
           response_headers_complete(response_headers_complete),
           response_headers(response_headers.Clone()),
-          preliminary_headers(preliminary_headers.Clone()),
           response(response),
           response_trailers(response_trailers.Clone()),
           bytes_read(bytes_read),
@@ -1286,7 +1271,6 @@ namespace quic
             response_ = state.response;
             response_complete_ = state.response_complete;
             response_headers_complete_ = state.response_headers_complete;
-            preliminary_headers_ = state.preliminary_headers.Clone();
             response_headers_ = state.response_headers.Clone();
             response_trailers_ = state.response_trailers.Clone();
             bytes_read_ = state.bytes_read;