@fails-components/webtransport 0.1.5 → 0.2.0

package/lib/stream.js

@@ -38,22 +38,48 @@ export class Http3WTStream {
     this.pendingoperation = null
     this.pendingres = null
 
+    /** @type {Promise<void> | null} */
+    this.pendingoperationRead = null
+    this.pendingresRead = null
+
     if (this.bidirectional || this.incoming) {
+      /** @type {Number} */
+      this.incomingbufferfilled = 0
+      /** @type {Number} */
+      this.incomingbufferreadpos = 0
+      if (!this.objint.readbuffer)
+        throw new Error('No readbuffer for read stream')
+      // @ts-expect-error `getStats` property is missing from ReadableStream
+      /** @type {WebTransportReceiveStream} */
       this.readable = new ReadableStream(
         {
-          start: (controller) => {
+          start: (
+            /** @type {import("stream/web").ReadableByteStreamController} */ controller
+          ) => {
             this.readableController = controller
-            // @ts-expect-error this.readable could be undefined
             this.parentobj.addReceiveStream(this.readable, controller)
             this.objint.startReading()
           },
-          pull: (controller) => {
+          pull: async (
+            /** @type {import("stream/web").ReadableByteStreamController} */ controller
+          ) => {
             if (this.readableclosed) {
               return Promise.resolve()
             }
-            this.objint.startReading()
+
+            /** @type {Uint8Array} */
+            if (this.incomingbufferfilled === 0) {
+              this.pendingoperationRead = new Promise((resolve, reject) => {
+                this.pendingresRead = resolve
+              })
+              await this.pendingoperationRead
+            }
+            if (this.incomingbufferfilled === 0)
+              throw new Error('error reading')
+
+            this.drainBuffer()
           },
-          cancel: (reason) => {
+          cancel: (/** @type {{ code: number; }} */ reason) => {
             /** @type {Promise<void>} */
             const promise = new Promise((resolve, reject) => {
               this.cancelres = resolve
@@ -67,17 +93,27 @@ export class Http3WTStream {
             this.readableclosed = true
             this.objint.stopSending(code)
             return promise
-          }
-        },
-        { highWaterMark: 4 }
+          },
+          type: 'bytes',
+          autoAllocateChunkSize: 4096 // lets take this as buffer size
+        }
+        // TODO fix stretegy
       )
+      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 +166,14 @@ export class Http3WTStream {
         },
         { highWaterMark: 4 }
       )
+      this.writable.getStats = () => {
+        return Promise.resolve({
+          timestamp: 0,
+          bytesWritten: 0n,
+          bytesSent: 0n,
+          bytesAcknowledged: 0n
+        })
+      }
     }
 
     /** @type {(() => void) | null} */
@@ -140,6 +184,62 @@ export class Http3WTStream {
     this.abortres = null
   }
 
+  drainBuffer() {
+    const byob = this.readableController.byobRequest
+    // @ts-ignore
+    const view = byob?.view
+    // @ts-ignore
+    if (!(byob?.view instanceof Uint8Array))
+      throw new Error('byob view is not a Uint8Array')
+    let toread = Math.min(view.byteLength, this.incomingbufferfilled)
+    let read = 0
+    if (!this.objint.readbuffer)
+      throw new Error('No readbuffer in read for read stream')
+    if (
+      this.incomingbufferreadpos + toread >
+      this.objint.readbuffer.byteLength
+    ) {
+      /** @type {Number} */
+      const firstread =
+        this.objint.readbuffer.byteLength - this.incomingbufferreadpos
+      read += firstread
+      toread -= firstread
+      const destview = new Uint8Array(
+        view.buffer,
+        0 + view.byteOffset,
+        firstread
+      )
+      const srcview = new Uint8Array(
+        this.objint.readbuffer,
+        this.incomingbufferreadpos,
+        firstread
+      )
+      destview.set(srcview)
+      this.incomingbufferreadpos = 0
+    }
+    {
+      const destview = new Uint8Array(
+        view.buffer,
+        read + view.byteOffset,
+        toread
+      )
+      const srcview = new Uint8Array(
+        this.objint.readbuffer,
+        this.incomingbufferreadpos,
+        toread
+      )
+      destview.set(srcview)
+      read += toread
+      this.incomingbufferreadpos =
+        (this.incomingbufferreadpos + toread) %
+        this.objint.readbuffer.byteLength
+    }
+    // @ts-ignore
+    byob.respond(read)
+    this.incomingbufferfilled -= read
+    this.objint.updateReadPos(read, this.incomingbufferreadpos)
+  }
+
   /**
    * @param {import('./types').StreamRecvSignalEvent} args
    * @returns {void}
@@ -190,6 +290,14 @@ export class Http3WTStream {
         res()
       }
     }
+    if (this.pendingoperationRead) {
+      const res = this.pendingresRead
+      this.pendingoperationRead = null
+      this.pendingresRead = null
+      if (res != null) {
+        res()
+      }
+    }
   }
 
   /**
@@ -197,9 +305,16 @@ export class Http3WTStream {
    * @returns {void}
    */
   onStreamRead(args) {
-    if (args.data && args.data.length && !this.readableclosed) {
+    if (args.buffergrow && !this.readableclosed) {
+      this.incomingbufferfilled += args.buffergrow
       // console.log('stream read received', args.data, Date.now())
-      this.readableController.enqueue(args.data)
+      if (this.pendingoperationRead) {
+        // this.readableController.enqueue(data)
+        const res = this.pendingresRead
+        this.pendingoperationRead = null
+        this.pendingresRead = null
+        if (res) res()
+      }
       if (
         this.readableController.desiredSize != null &&
         this.readableController.desiredSize < 0
@@ -207,6 +322,13 @@ export class Http3WTStream {
         this.objint.stopReading()
     }
     if (args.fin) {
+      if (this.incomingbufferfilled > 0) {
+        console.log('Warning buffer filled and we got a fin')
+        if (this.pendingoperationRead || this.pendingresRead)
+          throw new Error('We have pendingoperationRead and a filled buffer?')
+
+        this.drainBuffer()
+      }
       if (this.cancelres) {
         const res = this.cancelres
         this.cancelres = null
@@ -305,7 +427,10 @@ export class Http3WTStream {
           visitor.onStreamRecvSignal(args)
           break
         case 'StreamRead':
-          if (visitor && Object.prototype.hasOwnProperty.call(args, 'data')) {
+          if (
+            visitor &&
+            Object.prototype.hasOwnProperty.call(args, 'buffergrow')
+          ) {
             visitor.onStreamRead(args)
           } else {
             console.log('Stream callback called', visitor, args)

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,8 @@ import type { WebTransport } from './dom'
   writeDatagram: (chunk: Uint8Array) => void
   orderUnidiStream: () => void
   orderBidiStream: () => void
+  // orderStats: () => void
+  notifySessionDraining(): () => void
   close: (arg: { code: number, reason: string }) => void
 }
 
@@ -15,7 +17,9 @@ import type { WebTransport } from './dom'
  * Native Http3WTStream counterpart
  */
 export interface NativeHttp3WTStream {
+  updateReadPos(bytesread: Number, pos: Number): unknown
   jsobj: WebTransportStreamEventHandler
+  readbuffer: Uint8Array | undefined
   startReading: () => void
   stopReading: () => void
   stopSending: (code: number) => void
@@ -37,8 +41,9 @@ export interface StreamRecvSignalEvent {
 export interface StreamReadEvent {
   object: NativeHttp3WTStream
   purpose: 'StreamRead'
-  data?: Uint8Array
+  buffergrow?: number
   fin?: boolean
+  success?: boolean
 }
 
 export interface StreamWriteEvent {
@@ -88,6 +93,11 @@ export interface DatagramSendEvent {
   purpose: 'DatagramSend'
 }
 
+export interface GoawayReceivedEvent {
+  object: NativeHttp3WTSession
+  purpose: 'GoawayReceived'
+}
+
 export interface NewStreamEvent {
   object: NativeHttp3WTSession
   purpose: 'Http3WTStreamVisitor'
@@ -102,6 +112,7 @@ export interface WebTransportSessionEventHandler {
   onClose: (evt: SessionCloseEvent) => void
   onDatagramReceived: (evt: DatagramReceivedEvent) => void
   onDatagramSend: (evt: DatagramSendEvent) => void
+  onGoAwayReceived: (evt: GoawayReceivedEvent) => void
   onStream: (evt: NewStreamEvent) => void
   closeHook?: (() => void) | null
 }
@@ -174,7 +185,7 @@ export interface Deferred<T = unknown> {
   reject: (reason?: any) => void
 }
 
-export type WebTransportSessionState = 'connected' | 'closed' | 'failed'
+export type WebTransportSessionState = 'connected' | 'draining' | 'closed' | 'failed'
 
 export interface WebTransportSession extends WebTransport {
   state: WebTransportSessionState

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,11 +1,11 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "main": "lib/index.js",
   "module": "lib/index.js",
   "engines": {
-    "node": ">=16"
+    "node": ">=16.5"
   },
   "type": "module",
   "types": "./dist/lib/index.d.ts",
@@ -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",
@@ -60,7 +60,8 @@
     "mocha": "^10.1.0",
     "node-forge": "^1.3.1",
     "prettier": "^2.4.1",
-    "typescript": "4.8.4"
+    "typescript": "4.8.4",
+    "uint8arrays": "^4.0.2"
   },
   "binary": {
     "napi_versions": [

package/platform/base/strings/utf_ostream_operators.h

@@ -0,0 +1,5 @@
+// adds string to the includes of google url
+#include <string>
+#warning "Fake utf_stream_operators.h included"
+
+#include "third_party/googleurl/base/strings/utf_ostream_operators.h"

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;

package/src/http3client.h

@@ -180,7 +180,6 @@ namespace quic
         // Group 2.
         bool response_headers_complete() const;
         const spdy::Http2HeaderBlock *response_headers() const;
-        const spdy::Http2HeaderBlock *preliminary_headers() const;
         int64_t response_size() const;
         size_t bytes_read() const;
         size_t bytes_written() const;
@@ -218,7 +217,7 @@ namespace quic
         // QuicSpdyClientBase::Reponselistener
         void OnCompleteResponse(
             QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
-            const std::string &response_body);
+            const absl::string_view &response_body);
 
         // From QuicClientPushPromiseIndex::Delegate
         bool CheckVary(const spdy::Http2HeaderBlock &client_request,
@@ -321,8 +320,7 @@ namespace quic
             PerStreamState(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 absl::string_view response,
                            const spdy::Http2HeaderBlock &response_trailers,
                            uint64_t bytes_read, uint64_t bytes_written,
                            int64_t response_body_size);
@@ -332,7 +330,6 @@ namespace quic
             bool response_complete;
             bool response_headers_complete;
             spdy::Http2HeaderBlock response_headers;
-            spdy::Http2HeaderBlock preliminary_headers;
             std::string response;
             spdy::Http2HeaderBlock response_trailers;
             uint64_t bytes_read;
@@ -398,7 +395,6 @@ namespace quic
 
         bool response_complete_;
         bool response_headers_complete_;
-        mutable spdy::Http2HeaderBlock preliminary_headers_;
         mutable spdy::Http2HeaderBlock response_headers_;
 
         // Parsed response trailers (if present), copied from the stream in OnClose.