diff --git a/quiche/quic/core/http/quic_send_control_stream.cc b/quiche/quic/core/http/quic_send_control_stream.cc
index 97b27b2..fbde32c 100644
--- a/quiche/quic/core/http/quic_send_control_stream.cc
+++ b/quiche/quic/core/http/quic_send_control_stream.cc
@@ -16,8 +16,19 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/structured_headers.h"
 
 namespace quic {
+namespace {
+
+// See https://httpwg.org/specs/rfc9218.html for Priority Field Value format.
+constexpr absl::string_view kUrgencyKey = "u";
+constexpr absl::string_view kIncrementalKey = "i";
+constexpr int kMinimumUrgency = 0;
+constexpr int kMaximumUrgency = 7;
+constexpr bool kDefaultIncremental = false;
+
+}  // anonymous namespace
 
 QuicSendControlStream::QuicSendControlStream(QuicStreamId id,
                                              QuicSpdySession* spdy_session,
@@ -82,19 +93,23 @@
                     nullptr);
 }
 
-void QuicSendControlStream::WritePriorityUpdate(
-    const PriorityUpdateFrame& priority_update) {
+void QuicSendControlStream::WritePriorityUpdate(QuicStreamId stream_id,
+                                                int urgency, bool incremental) {
   QuicConnection::ScopedPacketFlusher flusher(session()->connection());
   MaybeSendSettingsFrame();
 
+  const std::string priority_field_value =
+      SerializePriorityFieldValue(urgency, incremental);
+  PriorityUpdateFrame priority_update_frame{stream_id, priority_field_value};
   if (spdy_session_->debug_visitor()) {
-    spdy_session_->debug_visitor()->OnPriorityUpdateFrameSent(priority_update);
+    spdy_session_->debug_visitor()->OnPriorityUpdateFrameSent(
+        priority_update_frame);
   }
 
   std::string frame =
-      HttpEncoder::SerializePriorityUpdateFrame(priority_update);
+      HttpEncoder::SerializePriorityUpdateFrame(priority_update_frame);
   QUIC_DVLOG(1) << "Control Stream " << id() << " is writing "
-                << priority_update;
+                << priority_update_frame;
   WriteOrBufferData(frame, false, nullptr);
 }
 
@@ -111,4 +126,30 @@
   WriteOrBufferData(HttpEncoder::SerializeGoAwayFrame(frame), false, nullptr);
 }
 
+std::string QuicSendControlStream::SerializePriorityFieldValue(
+    int urgency, bool incremental) {
+  quiche::structured_headers::Dictionary dictionary;
+
+  if (urgency != QuicStream::kDefaultUrgency && urgency >= kMinimumUrgency &&
+      urgency <= kMaximumUrgency) {
+    dictionary[kUrgencyKey] = quiche::structured_headers::ParameterizedMember(
+        quiche::structured_headers::Item(static_cast<int64_t>(urgency)), {});
+  }
+
+  if (incremental != kDefaultIncremental) {
+    dictionary[kIncrementalKey] =
+        quiche::structured_headers::ParameterizedMember(
+            quiche::structured_headers::Item(incremental), {});
+  }
+
+  absl::optional<std::string> priority_field_value =
+      quiche::structured_headers::SerializeDictionary(dictionary);
+  if (!priority_field_value.has_value()) {
+    QUICHE_BUG(priority_field_value_serialization_failed);
+    return "";
+  }
+
+  return *priority_field_value;
+}
+
 }  // namespace quic
diff --git a/quiche/quic/core/http/quic_send_control_stream.h b/quiche/quic/core/http/quic_send_control_stream.h
index 18ee01f..c76aaf9 100644
--- a/quiche/quic/core/http/quic_send_control_stream.h
+++ b/quiche/quic/core/http/quic_send_control_stream.h
@@ -39,7 +39,8 @@
 
   // Send a PRIORITY_UPDATE frame on this stream, and a SETTINGS frame
   // beforehand if one has not been already sent.
-  void WritePriorityUpdate(const PriorityUpdateFrame& priority_update);
+  void WritePriorityUpdate(QuicStreamId stream_id, int urgency,
+                           bool incremental);
 
   // Send a GOAWAY frame on this stream, and a SETTINGS frame beforehand if one
   // has not been already sent.
@@ -49,6 +50,9 @@
   // never be called.
   void OnDataAvailable() override { QUICHE_NOTREACHED(); }
 
+  // Serialize the Priority Field Value for a PRIORITY_UPDATE frame.
+  static std::string SerializePriorityFieldValue(int urgency, bool incremental);
+
  private:
   // Track if a settings frame is already sent.
   bool settings_sent_;
diff --git a/quiche/quic/core/http/quic_send_control_stream_test.cc b/quiche/quic/core/http/quic_send_control_stream_test.cc
index b606934..1627e78 100644
--- a/quiche/quic/core/http/quic_send_control_stream_test.cc
+++ b/quiche/quic/core/http/quic_send_control_stream_test.cc
@@ -251,11 +251,14 @@
   // SETTINGS frame, and a greased frame before the PRIORITY_UPDATE frame.
   EXPECT_CALL(session_, WritevData(send_control_stream_->id(), _, _, _, _, _))
       .Times(4);
-  PriorityUpdateFrame frame;
-  send_control_stream_->WritePriorityUpdate(frame);
+  send_control_stream_->WritePriorityUpdate(
+      /* stream_id = */ 0, /* urgency = */ 3, /* incremental = */ false);
+
+  EXPECT_TRUE(testing::Mock::VerifyAndClearExpectations(&session_));
 
   EXPECT_CALL(session_, WritevData(send_control_stream_->id(), _, _, _, _, _));
-  send_control_stream_->WritePriorityUpdate(frame);
+  send_control_stream_->WritePriorityUpdate(
+      /* stream_id = */ 0, /* urgency = */ 3, /* incremental = */ false);
 }
 
 TEST_P(QuicSendControlStreamTest, CloseControlStream) {
@@ -291,6 +294,23 @@
   send_control_stream_->SendGoAway(stream_id);
 }
 
+TEST(SerializePriorityFieldValueTest, SerializePriorityFieldValue) {
+  // Default value is omitted.
+  EXPECT_EQ("", QuicSendControlStream::SerializePriorityFieldValue(
+                    /* urgency = */ 3, /* incremental = */ false));
+  EXPECT_EQ("u=5", QuicSendControlStream::SerializePriorityFieldValue(
+                       /* urgency = */ 5, /* incremental = */ false));
+  EXPECT_EQ("i", QuicSendControlStream::SerializePriorityFieldValue(
+                     /* urgency = */ 3, /* incremental = */ true));
+  EXPECT_EQ("u=0, i", QuicSendControlStream::SerializePriorityFieldValue(
+                          /* urgency = */ 0, /* incremental = */ true));
+  // Out-of-bound value is ignored.
+  EXPECT_EQ("", QuicSendControlStream::SerializePriorityFieldValue(
+                    /* urgency = */ -2, /* incremental = */ false));
+  EXPECT_EQ("i", QuicSendControlStream::SerializePriorityFieldValue(
+                     /* urgency = */ 9, /* incremental = */ true));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_session.cc b/quiche/quic/core/http/quic_spdy_session.cc
index e9effda..8827e01 100644
--- a/quiche/quic/core/http/quic_spdy_session.cc
+++ b/quiche/quic/core/http/quic_spdy_session.cc
@@ -694,22 +694,22 @@
       /* exclusive = */ false, std::move(ack_listener));
 }
 
-size_t QuicSpdySession::WritePriority(QuicStreamId id,
+size_t QuicSpdySession::WritePriority(QuicStreamId stream_id,
                                       QuicStreamId parent_stream_id, int weight,
                                       bool exclusive) {
   QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
-  SpdyPriorityIR priority_frame(id, parent_stream_id, weight, exclusive);
+  SpdyPriorityIR priority_frame(stream_id, parent_stream_id, weight, exclusive);
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(priority_frame));
   headers_stream()->WriteOrBufferData(
       absl::string_view(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
-void QuicSpdySession::WriteHttp3PriorityUpdate(
-    const PriorityUpdateFrame& priority_update) {
+void QuicSpdySession::WriteHttp3PriorityUpdate(QuicStreamId stream_id,
+                                               int urgency, bool incremental) {
   QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
-  send_control_stream_->WritePriorityUpdate(priority_update);
+  send_control_stream_->WritePriorityUpdate(stream_id, urgency, incremental);
 }
 
 void QuicSpdySession::OnHttp3GoAway(uint64_t id) {
diff --git a/quiche/quic/core/http/quic_spdy_session.h b/quiche/quic/core/http/quic_spdy_session.h
index 476841d..0cb3f6b 100644
--- a/quiche/quic/core/http/quic_spdy_session.h
+++ b/quiche/quic/core/http/quic_spdy_session.h
@@ -209,11 +209,12 @@
 
   // Writes an HTTP/2 PRIORITY frame the to peer. Returns the size in bytes of
   // the resulting PRIORITY frame.
-  size_t WritePriority(QuicStreamId id, QuicStreamId parent_stream_id,
+  size_t WritePriority(QuicStreamId stream_id, QuicStreamId parent_stream_id,
                        int weight, bool exclusive);
 
   // Writes an HTTP/3 PRIORITY_UPDATE frame to the peer.
-  void WriteHttp3PriorityUpdate(const PriorityUpdateFrame& priority_update);
+  void WriteHttp3PriorityUpdate(QuicStreamId stream_id, int urgency,
+                                bool incremental);
 
   // Process received HTTP/3 GOAWAY frame.  When sent from server to client,
   // |id| is a stream ID.  When sent from client to server, |id| is a push ID.
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index ed0dd74..b1f9db5 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -588,14 +588,14 @@
   }
 
   // Value between 0 and 7, inclusive.  Lower value means higher priority.
-  int urgency = precedence().spdy3_priority();
+  const int urgency = precedence().spdy3_priority();
   if (last_sent_urgency_ == urgency) {
     return;
   }
   last_sent_urgency_ = urgency;
 
-  PriorityUpdateFrame priority_update{id(), absl::StrCat("u=", urgency)};
-  spdy_session_->WriteHttp3PriorityUpdate(priority_update);
+  spdy_session_->WriteHttp3PriorityUpdate(id(), urgency,
+                                          /* incremental = */ false);
 }
 
 void QuicSpdyStream::OnHeadersTooLarge() { Reset(QUIC_HEADERS_TOO_LARGE); }