quic: update to support client side priority

Author: jasnell

doc/api/quic.md

@@ -882,6 +882,10 @@ The current priority of the stream. Returns `null` if the session does not
 support priority (e.g. non-HTTP/3) or if the stream has been destroyed.
 Read only. Use [`stream.setPriority()`][] to change the priority.
 
+On client-side HTTP/3 sessions, the value reflects what was set via
+[`stream.setPriority()`][]. On server-side HTTP/3 sessions, the value
+reflects the peer's requested priority (e.g., from `PRIORITY_UPDATE` frames).
+
 ### `stream.setPriority([options])`
 
 <!-- YAML
@@ -895,8 +899,9 @@ added: REPLACEME
     interleaved with data from other streams of the same priority level.
     **Default:** `false`.
 
-Sets the priority of the stream. Has no effect if the session does not
-support priority or if the stream has been destroyed.
+Sets the priority of the stream. Throws `ERR_INVALID_STATE` if the session
+does not support priority (e.g. non-HTTP/3). Has no effect if the stream
+has been destroyed.
 
 ### `stream.readable`
 

src/quic/http3.cc

@@ -66,6 +66,20 @@ inline uint64_t ReadBE64(const uint8_t* buf) {
          (static_cast<uint64_t>(buf[5]) << 16) |
          (static_cast<uint64_t>(buf[6]) << 8) | static_cast<uint64_t>(buf[7]);
 }
+
+// Serialize an nghttp3_pri into an RFC 9218 priority field value
+// (e.g., "u=3" or "u=0, i"). Returns the number of bytes written.
+// This is used only for setting the priority field of HTTP/3 streams on
+// the client side.
+inline size_t FormatPriority(char* buf, size_t buflen, const nghttp3_pri& pri) {
+  int len;
+  if (pri.inc) {
+    len = snprintf(buf, buflen, "u=%d, i", pri.urgency);
+  } else {
+    len = snprintf(buf, buflen, "u=%d", pri.urgency);
+  }
+  return static_cast<size_t>(len);
+}
 }  // namespace
 
 struct Http3HeadersTraits {
@@ -506,17 +520,24 @@ class Http3ApplicationImpl final : public Session::Application {
     }
     if (session().is_server()) {
       nghttp3_conn_set_server_stream_priority(*this, stream.id(), &pri);
+    } else {
+      // The client API takes a serialized RFC 9218 priority field value
+      // (e.g., "u=0, i") rather than an nghttp3_pri struct.
+      char buf[8];
+      size_t len = FormatPriority(buf, sizeof(buf), pri);
+      nghttp3_conn_set_client_stream_priority(
+          *this, stream.id(), reinterpret_cast<const uint8_t*>(buf), len);
     }
-    // Client-side priority is set at request submission time via
-    // nghttp3_conn_submit_request and is not typically changed
-    // after the fact. The client API takes a serialized RFC 9218
-    // field value rather than an nghttp3_pri struct.
   }
 
   StreamPriorityResult GetStreamPriority(const Stream& stream) override {
-    // nghttp3_conn_get_stream_priority is only available on the server side.
+    // nghttp3_conn_get_stream_priority is only available on the server
+    // side, where it reflects the peer's requested priority (e.g., from
+    // PRIORITY_UPDATE frames). Client-side priority is tracked by the
+    // Stream itself and returned directly from GetPriority in streams.cc.
     if (!session().is_server()) {
-      return {StreamPriority::DEFAULT, StreamPriorityFlags::NON_INCREMENTAL};
+      auto& stored = stream.stored_priority();
+      return {stored.priority, stored.flags};
     }
     nghttp3_pri pri;
     if (nghttp3_conn_get_stream_priority(*this, &pri, stream.id()) == 0) {

src/quic/streams.cc

@@ -367,12 +367,14 @@ struct Stream::Impl {
                                     ? StreamPriorityFlags::INCREMENTAL
                                     : StreamPriorityFlags::NON_INCREMENTAL;
 
-    if (stream->is_pending()) {
-      stream->pending_priority_ = PendingPriority{
-          .priority = priority,
-          .flags = flags,
-      };
-    } else {
+    // Always update the stored priority on the stream.
+    stream->priority_ = StoredPriority{
+        .priority = priority,
+        .flags = flags,
+        .pending = stream->is_pending(),
+    };
+
+    if (!stream->is_pending()) {
       stream->session().application().SetStreamPriority(
           *stream, priority, flags);
     }
@@ -382,9 +384,15 @@ struct Stream::Impl {
     Stream* stream;
     ASSIGN_OR_RETURN_UNWRAP(&stream, args.This());
 
-    if (stream->is_pending()) {
-      uint32_t packed =
-          (static_cast<uint32_t>(StreamPriority::DEFAULT) << 1) | 0;
+    // On the client side, priority is always read from the stream's
+    // stored value since the client is the one setting it. On the
+    // server side, we delegate to the application which can read
+    // the peer's requested priority (e.g., from PRIORITY_UPDATE
+    // frames in HTTP/3).
+    if (!stream->session().is_server()) {
+      auto& pri = stream->priority_;
+      uint32_t packed = (static_cast<uint32_t>(pri.priority) << 1) |
+                        (pri.flags == StreamPriorityFlags::INCREMENTAL ? 1 : 0);
       return args.GetReturnValue().Set(packed);
     }
 
@@ -979,11 +987,10 @@ void Stream::NotifyStreamOpened(stream_id id) {
   CHECK_EQ(ngtcp2_conn_set_stream_user_data(this->session(), id, this), 0);
   maybe_pending_stream_.reset();
 
-  if (pending_priority_) {
-    auto& priority = pending_priority_.value();
+  if (priority_.pending) {
     session().application().SetStreamPriority(
-        *this, priority.priority, priority.flags);
-    pending_priority_ = std::nullopt;
+        *this, priority_.priority, priority_.flags);
+    priority_.pending = false;
   }
   if (!pending_headers_queue_.empty()) {
     if (!session().application().SupportsHeaders()) {

src/quic/streams.h

@@ -355,11 +355,14 @@ class Stream final : public AsyncWrap,
   error_code pending_close_read_code_ = 0;
   error_code pending_close_write_code_ = 0;
 
-  struct PendingPriority {
-    StreamPriority priority;
-    StreamPriorityFlags flags;
+  struct StoredPriority {
+    StreamPriority priority = StreamPriority::DEFAULT;
+    StreamPriorityFlags flags = StreamPriorityFlags::NON_INCREMENTAL;
+    bool pending = false;
   };
-  std::optional<PendingPriority> pending_priority_ = std::nullopt;
+  StoredPriority priority_;
+
+  const StoredPriority& stored_priority() const { return priority_; }
 
   // The headers_ field holds a block of headers that have been received and
   // are being buffered for delivery to the JavaScript side.