diff --git a/quiche/quic/core/http/quic_receive_control_stream.cc b/quiche/quic/core/http/quic_receive_control_stream.cc
index c3862be..4be1536 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.cc
+++ b/quiche/quic/core/http/quic_receive_control_stream.cc
@@ -137,7 +137,7 @@
     spdy_session()->debug_visitor()->OnPriorityUpdateFrameReceived(frame);
   }
 
-  absl::optional<QuicStreamPriority> priority =
+  absl::optional<HttpStreamPriority> priority =
       ParsePriorityFieldValue(frame.priority_field_value);
 
   if (!priority.has_value()) {
diff --git a/quiche/quic/core/http/quic_send_control_stream.cc b/quiche/quic/core/http/quic_send_control_stream.cc
index d3c2ef2..e9b06ed 100644
--- a/quiche/quic/core/http/quic_send_control_stream.cc
+++ b/quiche/quic/core/http/quic_send_control_stream.cc
@@ -86,7 +86,7 @@
 }
 
 void QuicSendControlStream::WritePriorityUpdate(QuicStreamId stream_id,
-                                                QuicStreamPriority priority) {
+                                                HttpStreamPriority priority) {
   QuicConnection::ScopedPacketFlusher flusher(session()->connection());
   MaybeSendSettingsFrame();
 
diff --git a/quiche/quic/core/http/quic_send_control_stream.h b/quiche/quic/core/http/quic_send_control_stream.h
index 6d0745c..fa8b96a 100644
--- a/quiche/quic/core/http/quic_send_control_stream.h
+++ b/quiche/quic/core/http/quic_send_control_stream.h
@@ -40,7 +40,7 @@
 
   // Send a PRIORITY_UPDATE frame on this stream, and a SETTINGS frame
   // beforehand if one has not been already sent.
-  void WritePriorityUpdate(QuicStreamId stream_id, QuicStreamPriority priority);
+  void WritePriorityUpdate(QuicStreamId stream_id, HttpStreamPriority priority);
 
   // Send a GOAWAY frame on this stream, and a SETTINGS frame beforehand if one
   // has not been already 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 20e96c6..cd3a274 100644
--- a/quiche/quic/core/http/quic_send_control_stream_test.cc
+++ b/quiche/quic/core/http/quic_send_control_stream_test.cc
@@ -253,14 +253,14 @@
       .Times(4);
   send_control_stream_->WritePriorityUpdate(
       /* stream_id = */ 0,
-      QuicStreamPriority{/* urgency = */ 3, /* incremental = */ false});
+      HttpStreamPriority{/* urgency = */ 3, /* incremental = */ false});
 
   EXPECT_TRUE(testing::Mock::VerifyAndClearExpectations(&session_));
 
   EXPECT_CALL(session_, WritevData(send_control_stream_->id(), _, _, _, _, _));
   send_control_stream_->WritePriorityUpdate(
       /* stream_id = */ 0,
-      QuicStreamPriority{/* urgency = */ 3, /* incremental = */ false});
+      HttpStreamPriority{/* urgency = */ 3, /* incremental = */ false});
 }
 
 TEST_P(QuicSendControlStreamTest, CloseControlStream) {
diff --git a/quiche/quic/core/http/quic_server_session_base_test.cc b/quiche/quic/core/http/quic_server_session_base_test.cc
index 807f05f..256abae 100644
--- a/quiche/quic/core/http/quic_server_session_base_test.cc
+++ b/quiche/quic/core/http/quic_server_session_base_test.cc
@@ -545,7 +545,8 @@
   if (!VersionUsesHttp3(transport_version())) {
     session_->RegisterStreamPriority(
         QuicUtils::GetHeadersStreamId(transport_version()),
-        /*is_static=*/true, QuicStreamPriority());
+        /*is_static=*/true,
+        QuicStreamPriority::Default(session_->priority_type()));
   }
 
   // Set some initial bandwidth values.
diff --git a/quiche/quic/core/http/quic_spdy_session.cc b/quiche/quic/core/http/quic_spdy_session.cc
index c404b70..e024213 100644
--- a/quiche/quic/core/http/quic_spdy_session.cc
+++ b/quiche/quic/core/http/quic_spdy_session.cc
@@ -621,7 +621,7 @@
 }
 
 bool QuicSpdySession::OnPriorityUpdateForRequestStream(
-    QuicStreamId stream_id, QuicStreamPriority priority) {
+    QuicStreamId stream_id, HttpStreamPriority priority) {
   if (perspective() == Perspective::IS_CLIENT ||
       !QuicUtils::IsBidirectionalStreamId(stream_id, version()) ||
       !QuicUtils::IsClientInitiatedStreamId(transport_version(), stream_id)) {
@@ -642,7 +642,7 @@
     return false;
   }
 
-  if (MaybeSetStreamPriority(stream_id, priority)) {
+  if (MaybeSetStreamPriority(stream_id, QuicStreamPriority(priority))) {
     return true;
   }
 
@@ -706,7 +706,7 @@
 }
 
 void QuicSpdySession::WriteHttp3PriorityUpdate(QuicStreamId stream_id,
-                                               QuicStreamPriority priority) {
+                                               HttpStreamPriority priority) {
   QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   send_control_stream_->WritePriorityUpdate(stream_id, priority);
@@ -842,7 +842,7 @@
     return;
   }
 
-  stream->SetPriority(it->second);
+  stream->SetPriority(QuicStreamPriority(it->second));
   buffered_stream_priorities_.erase(it);
 }
 
diff --git a/quiche/quic/core/http/quic_spdy_session.h b/quiche/quic/core/http/quic_spdy_session.h
index 9f4782b..0102787 100644
--- a/quiche/quic/core/http/quic_spdy_session.h
+++ b/quiche/quic/core/http/quic_spdy_session.h
@@ -182,7 +182,7 @@
   // Called when an HTTP/3 PRIORITY_UPDATE frame has been received for a request
   // stream.  Returns false and closes connection if |stream_id| is invalid.
   bool OnPriorityUpdateForRequestStream(QuicStreamId stream_id,
-                                        QuicStreamPriority priority);
+                                        HttpStreamPriority priority);
 
   // Called when an HTTP/3 ACCEPT_CH frame has been received.
   // This method will only be called for client sessions.
@@ -216,7 +216,7 @@
 
   // Writes an HTTP/3 PRIORITY_UPDATE frame to the peer.
   void WriteHttp3PriorityUpdate(QuicStreamId stream_id,
-                                QuicStreamPriority priority);
+                                HttpStreamPriority priority);
 
   // 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.
@@ -629,7 +629,7 @@
 
   // Priority values received in PRIORITY_UPDATE frames for streams that are not
   // open yet.
-  absl::flat_hash_map<QuicStreamId, QuicStreamPriority>
+  absl::flat_hash_map<QuicStreamId, HttpStreamPriority>
       buffered_stream_priorities_;
 
   // An integer used for live check. The indicator is assigned a value in
diff --git a/quiche/quic/core/http/quic_spdy_session_test.cc b/quiche/quic/core/http/quic_spdy_session_test.cc
index 67ed9ea..89ee9e4 100644
--- a/quiche/quic/core/http/quic_spdy_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_session_test.cc
@@ -2110,8 +2110,8 @@
   session_.OnPriorityFrame(stream_id,
                            spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
-  EXPECT_EQ((QuicStreamPriority{kV3HighestPriority,
-                                QuicStreamPriority::kDefaultIncremental}),
+  EXPECT_EQ((QuicStreamPriority(HttpStreamPriority{
+                kV3HighestPriority, HttpStreamPriority::kDefaultIncremental})),
             stream->priority());
 }
 
@@ -2156,12 +2156,14 @@
 
   // PRIORITY_UPDATE frame arrives after stream creation.
   TestStream* stream1 = session_.CreateIncomingStream(stream_id1);
-  EXPECT_EQ((QuicStreamPriority{QuicStreamPriority::kDefaultUrgency,
-                                QuicStreamPriority::kDefaultIncremental}),
+  EXPECT_EQ(QuicStreamPriority(
+                HttpStreamPriority{HttpStreamPriority::kDefaultUrgency,
+                                   HttpStreamPriority::kDefaultIncremental}),
             stream1->priority());
   EXPECT_CALL(debug_visitor, OnPriorityUpdateFrameReceived(priority_update1));
   session_.OnStreamFrame(data3);
-  EXPECT_EQ((QuicStreamPriority{2u, QuicStreamPriority::kDefaultIncremental}),
+  EXPECT_EQ(QuicStreamPriority(HttpStreamPriority{
+                2u, HttpStreamPriority::kDefaultIncremental}),
             stream1->priority());
 
   // PRIORITY_UPDATE frame for second request stream.
@@ -2179,7 +2181,8 @@
   session_.OnStreamFrame(stream_frame3);
   // Priority is applied upon stream construction.
   TestStream* stream2 = session_.CreateIncomingStream(stream_id2);
-  EXPECT_EQ((QuicStreamPriority{5u, true}), stream2->priority());
+  EXPECT_EQ(QuicStreamPriority(HttpStreamPriority{5u, true}),
+            stream2->priority());
 }
 
 TEST_P(QuicSpdySessionTestServer, OnInvalidPriorityUpdateFrame) {
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index 93546ec..84f57e3 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -22,6 +22,7 @@
 #include "quiche/quic/core/http/web_transport_http3.h"
 #include "quiche/quic/core/qpack/qpack_decoder.h"
 #include "quiche/quic/core/qpack/qpack_encoder.h"
+#include "quiche/quic/core/quic_stream_priority.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/core/quic_versions.h"
@@ -191,7 +192,9 @@
                HttpDecoderOptionsForBidiStream(spdy_session)),
       sequencer_offset_(0),
       is_decoder_processing_input_(false),
-      ack_listener_(nullptr) {
+      ack_listener_(nullptr),
+      last_sent_priority_(
+          QuicStreamPriority::Default(spdy_session->priority_type())) {
   QUICHE_DCHECK_EQ(session()->connection(), spdy_session->connection());
   QUICHE_DCHECK_EQ(transport_version(), spdy_session->transport_version());
   QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
@@ -225,7 +228,9 @@
       decoder_(http_decoder_visitor_.get()),
       sequencer_offset_(sequencer()->NumBytesConsumed()),
       is_decoder_processing_input_(false),
-      ack_listener_(nullptr) {
+      ack_listener_(nullptr),
+      last_sent_priority_(
+          QuicStreamPriority::Default(spdy_session->priority_type())) {
   QUICHE_DCHECK_EQ(session()->connection(), spdy_session->connection());
   QUICHE_DCHECK_EQ(transport_version(), spdy_session->transport_version());
   QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id()));
@@ -504,8 +509,11 @@
     const spdy::SpdyStreamPrecedence& precedence) {
   QUICHE_DCHECK_EQ(Perspective::IS_SERVER,
                    session()->connection()->perspective());
-  SetPriority(QuicStreamPriority{precedence.spdy3_priority(),
-                                 QuicStreamPriority::kDefaultIncremental});
+  if (session()->priority_type() != QuicPriorityType::kHttp) {
+    return;
+  }
+  SetPriority(QuicStreamPriority(HttpStreamPriority{
+      precedence.spdy3_priority(), HttpStreamPriority::kDefaultIncremental}));
 }
 
 void QuicSpdyStream::OnStreamHeaderList(bool fin, size_t frame_len,
@@ -586,13 +594,16 @@
       session()->perspective() != Perspective::IS_CLIENT) {
     return;
   }
+  if (spdy_session_->priority_type() != QuicPriorityType::kHttp) {
+    return;
+  }
 
   if (last_sent_priority_ == priority()) {
     return;
   }
   last_sent_priority_ = priority();
 
-  spdy_session_->WriteHttp3PriorityUpdate(id(), priority());
+  spdy_session_->WriteHttp3PriorityUpdate(id(), priority().http());
 }
 
 void QuicSpdyStream::OnHeadersTooLarge() { Reset(QUIC_HEADERS_TOO_LARGE); }
@@ -704,8 +715,11 @@
     const spdy::SpdyStreamPrecedence& precedence) {
   QUICHE_DCHECK_EQ(Perspective::IS_SERVER,
                    session()->connection()->perspective());
-  SetPriority(QuicStreamPriority{precedence.spdy3_priority(),
-                                 QuicStreamPriority::kDefaultIncremental});
+  if (session()->priority_type() != QuicPriorityType::kHttp) {
+    return;
+  }
+  SetPriority(QuicStreamPriority(HttpStreamPriority{
+      precedence.spdy3_priority(), HttpStreamPriority::kDefaultIncremental}));
 }
 
 void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
@@ -1151,7 +1165,7 @@
   if (!VersionUsesHttp3(transport_version())) {
     return spdy_session_->WriteHeadersOnHeadersStream(
         id(), std::move(header_block), fin,
-        spdy::SpdyStreamPrecedence(priority().urgency),
+        spdy::SpdyStreamPrecedence(priority().http().urgency),
         std::move(ack_listener));
   }
 
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc
index 90b58df..2b966b2 100644
--- a/quiche/quic/core/http/quic_spdy_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -326,18 +326,19 @@
   void UpdateStreamPriority(QuicStreamId id,
                             const QuicStreamPriority& new_priority) override {
     EXPECT_EQ(id, expected_stream_->id());
-    EXPECT_EQ(expected_priority_, new_priority);
-    EXPECT_EQ(expected_priority_, expected_stream_->priority());
+    EXPECT_EQ(expected_priority_, new_priority.http());
+    EXPECT_EQ(QuicStreamPriority(expected_priority_),
+              expected_stream_->priority());
   }
 
   void SetExpectedStream(QuicSpdyStream* stream) { expected_stream_ = stream; }
-  void SetExpectedPriority(const QuicStreamPriority& priority) {
+  void SetExpectedPriority(const HttpStreamPriority& priority) {
     expected_priority_ = priority;
   }
 
  private:
   QuicSpdyStream* expected_stream_;
-  QuicStreamPriority expected_priority_;
+  HttpStreamPriority expected_priority_;
 };
 
 class QuicSpdyStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
@@ -1563,22 +1564,22 @@
   EXPECT_CALL(*session_, WritevData(send_control_stream->id(), _, _, _, _, _));
   PriorityUpdateFrame priority_update1{stream_->id(), "u=0"};
   EXPECT_CALL(debug_visitor, OnPriorityUpdateFrameSent(priority_update1));
-  const QuicStreamPriority priority1{kV3HighestPriority,
-                                     QuicStreamPriority::kDefaultIncremental};
-  stream_->SetPriority(priority1);
+  const HttpStreamPriority priority1{kV3HighestPriority,
+                                     HttpStreamPriority::kDefaultIncremental};
+  stream_->SetPriority(QuicStreamPriority(priority1));
   testing::Mock::VerifyAndClearExpectations(&debug_visitor);
 
   // Send another PRIORITY_UPDATE frame with incremental flag set to true.
   EXPECT_CALL(*session_, WritevData(send_control_stream->id(), _, _, _, _, _));
   PriorityUpdateFrame priority_update2{stream_->id(), "u=2, i"};
   EXPECT_CALL(debug_visitor, OnPriorityUpdateFrameSent(priority_update2));
-  const QuicStreamPriority priority2{2, true};
-  stream_->SetPriority(priority2);
+  const HttpStreamPriority priority2{2, true};
+  stream_->SetPriority(QuicStreamPriority(priority2));
   testing::Mock::VerifyAndClearExpectations(&debug_visitor);
 
   // Calling SetPriority() with the same priority does not trigger sending
   // another PRIORITY_UPDATE frame.
-  stream_->SetPriority(priority2);
+  stream_->SetPriority(QuicStreamPriority(priority2));
 }
 
 TEST_P(QuicSpdyStreamTest, ChangePriorityBeforeWritingHeaders) {
@@ -1594,8 +1595,8 @@
       QuicSpdySessionPeer::GetSendControlStream(session_.get());
   EXPECT_CALL(*session_, WritevData(send_control_stream->id(), _, _, _, _, _));
 
-  stream_->SetPriority(QuicStreamPriority{
-      kV3HighestPriority, QuicStreamPriority::kDefaultIncremental});
+  stream_->SetPriority(QuicStreamPriority(HttpStreamPriority{
+      kV3HighestPriority, HttpStreamPriority::kDefaultIncremental}));
   testing::Mock::VerifyAndClearExpectations(session_.get());
 
   // Two writes on the request stream: HEADERS frame header and payload.
@@ -1796,8 +1797,8 @@
 TEST_P(QuicSpdyStreamTest, OnPriorityFrame) {
   Initialize(kShouldProcessData);
   stream_->OnPriorityFrame(spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  EXPECT_EQ((QuicStreamPriority{kV3HighestPriority,
-                                QuicStreamPriority::kDefaultIncremental}),
+  EXPECT_EQ(QuicStreamPriority(HttpStreamPriority{
+                kV3HighestPriority, HttpStreamPriority::kDefaultIncremental}),
             stream_->priority());
 }
 
@@ -1811,8 +1812,8 @@
   EXPECT_CALL(*session_, WritevData(_, 4, _, FIN, _, _));
   stream_->WriteOrBufferBody("data", true);
   stream_->OnPriorityFrame(spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  EXPECT_EQ((QuicStreamPriority{kV3HighestPriority,
-                                QuicStreamPriority::kDefaultIncremental}),
+  EXPECT_EQ(QuicStreamPriority(HttpStreamPriority{
+                kV3HighestPriority, HttpStreamPriority::kDefaultIncremental}),
             stream_->priority());
 }
 
@@ -1834,11 +1835,13 @@
   // if called within UpdateStreamPriority(). This expectation is enforced in
   // TestMockUpdateStreamSession::UpdateStreamPriority().
   session->SetExpectedStream(stream);
-  session->SetExpectedPriority(QuicStreamPriority{kV3HighestPriority});
-  stream->SetPriority(QuicStreamPriority{kV3HighestPriority});
+  session->SetExpectedPriority(HttpStreamPriority{kV3HighestPriority});
+  stream->SetPriority(
+      QuicStreamPriority(HttpStreamPriority{kV3HighestPriority}));
 
-  session->SetExpectedPriority(QuicStreamPriority{kV3LowestPriority});
-  stream->SetPriority(QuicStreamPriority{kV3LowestPriority});
+  session->SetExpectedPriority(HttpStreamPriority{kV3LowestPriority});
+  stream->SetPriority(
+      QuicStreamPriority(HttpStreamPriority{kV3LowestPriority}));
 }
 
 TEST_P(QuicSpdyStreamTest, StreamWaitsForAcks) {
diff --git a/quiche/quic/core/quic_session.h b/quiche/quic/core/quic_session.h
index e12bb8f..e1c1932 100644
--- a/quiche/quic/core/quic_session.h
+++ b/quiche/quic/core/quic_session.h
@@ -656,6 +656,9 @@
   // streams.
   QuicStream* GetActiveStream(QuicStreamId id) const;
 
+  // Returns the priority type used by the streams in the session.
+  QuicPriorityType priority_type() const { return QuicPriorityType::kHttp; }
+
  protected:
   using StreamMap =
       absl::flat_hash_map<QuicStreamId, std::unique_ptr<QuicStream>>;
@@ -723,7 +726,9 @@
   virtual bool ShouldProcessPendingStreamImmediately() const { return true; }
 
   spdy::SpdyPriority GetSpdyPriorityofStream(QuicStreamId stream_id) const {
-    return write_blocked_streams_->GetPriorityOfStream(stream_id).urgency;
+    return write_blocked_streams_->GetPriorityOfStream(stream_id)
+        .http()
+        .urgency;
   }
 
   size_t pending_streams_size() const { return pending_stream_map_.size(); }
diff --git a/quiche/quic/core/quic_session_test.cc b/quiche/quic/core/quic_session_test.cc
index 750ffac..c8f5f5b 100644
--- a/quiche/quic/core/quic_session_test.cc
+++ b/quiche/quic/core/quic_session_test.cc
@@ -1030,8 +1030,9 @@
   TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
   TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
 
-  const QuicStreamPriority priority{QuicStreamPriority::kDefaultUrgency,
-                                    /* incremental = */ true};
+  const QuicStreamPriority priority(
+      HttpStreamPriority{HttpStreamPriority::kDefaultUrgency,
+                         /* incremental = */ true});
   stream2->SetPriority(priority);
   stream4->SetPriority(priority);
   stream6->SetPriority(priority);
@@ -1075,8 +1076,8 @@
   session_.OnCanWrite();
 
   // The next write adds a block for stream 6.
-  stream6->SetPriority(QuicStreamPriority{
-      kV3HighestPriority, QuicStreamPriority::kDefaultIncremental});
+  stream6->SetPriority(QuicStreamPriority(HttpStreamPriority{
+      kV3HighestPriority, HttpStreamPriority::kDefaultIncremental}));
   if (GetQuicReloadableFlag(quic_disable_batch_write)) {
     EXPECT_CALL(*stream2, OnCanWrite())
         .WillOnce(Invoke([this, stream2, stream6]() {
diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index 6a436ff..e570b44 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -336,6 +336,7 @@
       id_(id),
       session_(session),
       stream_delegate_(session),
+      priority_(QuicStreamPriority::Default(session->priority_type())),
       stream_bytes_read_(stream_bytes_read),
       stream_error_(QuicResetStreamError::NoError()),
       connection_error_(QUIC_NO_ERROR),
diff --git a/quiche/quic/core/quic_stream_priority.cc b/quiche/quic/core/quic_stream_priority.cc
index 1d2e251..5199a43 100644
--- a/quiche/quic/core/quic_stream_priority.cc
+++ b/quiche/quic/core/quic_stream_priority.cc
@@ -9,23 +9,23 @@
 
 namespace quic {
 
-std::string SerializePriorityFieldValue(QuicStreamPriority priority) {
+std::string SerializePriorityFieldValue(HttpStreamPriority priority) {
   quiche::structured_headers::Dictionary dictionary;
 
   // TODO(b/266722347): Never send `urgency` if value equals default value.
-  if ((priority.urgency != QuicStreamPriority::kDefaultUrgency ||
-       priority.incremental != QuicStreamPriority::kDefaultIncremental) &&
-      priority.urgency >= QuicStreamPriority::kMinimumUrgency &&
-      priority.urgency <= QuicStreamPriority::kMaximumUrgency) {
-    dictionary[QuicStreamPriority::kUrgencyKey] =
+  if ((priority.urgency != HttpStreamPriority::kDefaultUrgency ||
+       priority.incremental != HttpStreamPriority::kDefaultIncremental) &&
+      priority.urgency >= HttpStreamPriority::kMinimumUrgency &&
+      priority.urgency <= HttpStreamPriority::kMaximumUrgency) {
+    dictionary[HttpStreamPriority::kUrgencyKey] =
         quiche::structured_headers::ParameterizedMember(
             quiche::structured_headers::Item(
                 static_cast<int64_t>(priority.urgency)),
             {});
   }
 
-  if (priority.incremental != QuicStreamPriority::kDefaultIncremental) {
-    dictionary[QuicStreamPriority::kIncrementalKey] =
+  if (priority.incremental != HttpStreamPriority::kDefaultIncremental) {
+    dictionary[HttpStreamPriority::kIncrementalKey] =
         quiche::structured_headers::ParameterizedMember(
             quiche::structured_headers::Item(priority.incremental), {});
   }
@@ -40,7 +40,7 @@
   return *priority_field_value;
 }
 
-absl::optional<QuicStreamPriority> ParsePriorityFieldValue(
+absl::optional<HttpStreamPriority> ParsePriorityFieldValue(
     absl::string_view priority_field_value) {
   absl::optional<quiche::structured_headers::Dictionary> parsed_dictionary =
       quiche::structured_headers::ParseDictionary(priority_field_value);
@@ -48,8 +48,8 @@
     return absl::nullopt;
   }
 
-  uint8_t urgency = QuicStreamPriority::kDefaultUrgency;
-  bool incremental = QuicStreamPriority::kDefaultIncremental;
+  uint8_t urgency = HttpStreamPriority::kDefaultUrgency;
+  bool incremental = HttpStreamPriority::kDefaultIncremental;
 
   for (const auto& [name, value] : *parsed_dictionary) {
     if (value.member_is_inner_list) {
@@ -66,20 +66,20 @@
     }
 
     const quiche::structured_headers::Item item = member[0].item;
-    if (name == QuicStreamPriority::kUrgencyKey && item.is_integer()) {
+    if (name == HttpStreamPriority::kUrgencyKey && item.is_integer()) {
       int parsed_urgency = item.GetInteger();
       // Ignore out-of-range values.
-      if (parsed_urgency >= QuicStreamPriority::kMinimumUrgency &&
-          parsed_urgency <= QuicStreamPriority::kMaximumUrgency) {
+      if (parsed_urgency >= HttpStreamPriority::kMinimumUrgency &&
+          parsed_urgency <= HttpStreamPriority::kMaximumUrgency) {
         urgency = parsed_urgency;
       }
-    } else if (name == QuicStreamPriority::kIncrementalKey &&
+    } else if (name == HttpStreamPriority::kIncrementalKey &&
                item.is_boolean()) {
       incremental = item.GetBoolean();
     }
   }
 
-  return QuicStreamPriority{urgency, incremental};
+  return HttpStreamPriority{urgency, incremental};
 }
 
 }  // namespace quic
diff --git a/quiche/quic/core/quic_stream_priority.h b/quiche/quic/core/quic_stream_priority.h
index de2cce2..b06f475 100644
--- a/quiche/quic/core/quic_stream_priority.h
+++ b/quiche/quic/core/quic_stream_priority.h
@@ -11,13 +11,15 @@
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "quiche/quic/platform/api/quic_export.h"
+#include "absl/types/variant.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/common/platform/api/quiche_bug_tracker.h"
+#include "quiche/common/platform/api/quiche_export.h"
 
 namespace quic {
 
-// Class to hold urgency and incremental values defined by
-// https://httpwg.org/specs/rfc9218.html.
-struct QUICHE_EXPORT QuicStreamPriority {
+// Represents HTTP priorities as defined by RFC 9218.
+struct QUICHE_EXPORT HttpStreamPriority {
   static constexpr int kMinimumUrgency = 0;
   static constexpr int kMaximumUrgency = 7;
   static constexpr int kDefaultUrgency = 3;
@@ -30,36 +32,104 @@
   int urgency = kDefaultUrgency;
   bool incremental = kDefaultIncremental;
 
-  bool operator==(const QuicStreamPriority& other) const {
+  bool operator==(const HttpStreamPriority& other) const {
     return std::tie(urgency, incremental) ==
            std::tie(other.urgency, other.incremental);
   }
 
-  bool operator!=(const QuicStreamPriority& other) const {
-    return !operator==(other);
+  bool operator!=(const HttpStreamPriority& other) const {
+    return !(*this == other);
   }
 };
 
-// Functors to be used as template parameters for PriorityWriteScheduler.
-struct QUICHE_EXPORT QuicStreamPriorityToInt {
-  int operator()(const QuicStreamPriority& priority) {
-    return priority.urgency;
+// Represents WebTransport priorities as defined by
+// <https://w3c.github.io/webtransport/>.
+struct QUICHE_EXPORT WebTransportStreamPriority {
+  enum class StreamType : uint8_t {
+    // WebTransport data streams.
+    kData = 0,
+    // Regular HTTP traffic. Since we're currently only supporting dedicated
+    // HTTP/3 transport, this means that all HTTP traffic is control traffic,
+    // and thus should always go first.
+    kHttp = 1,
+    // Streams that the QUIC stack declares as static.
+    kStatic = 2,
+  };
+
+  // Allows prioritizing control streams over the data streams.
+  StreamType stream_type = StreamType::kData;
+  // https://w3c.github.io/webtransport/#dom-webtransportsendstreamoptions-sendorder
+  int64_t send_order = 0;
+
+  bool operator==(const WebTransportStreamPriority& other) const {
+    return stream_type == other.stream_type && send_order == other.send_order;
+  }
+  bool operator!=(const WebTransportStreamPriority& other) const {
+    return !(*this == other);
   }
 };
 
-struct QUICHE_EXPORT IntToQuicStreamPriority {
-  QuicStreamPriority operator()(int urgency) {
-    return QuicStreamPriority{urgency};
+// A class that wraps different types of priorities that can be used for
+// scheduling QUIC streams.
+class QUICHE_EXPORT QuicStreamPriority {
+ public:
+  explicit QuicStreamPriority(HttpStreamPriority priority) : value_(priority) {}
+  explicit QuicStreamPriority(WebTransportStreamPriority priority)
+      : value_(priority) {}
+
+  static QuicStreamPriority Default(QuicPriorityType type) {
+    switch (type) {
+      case QuicPriorityType::kHttp:
+        return QuicStreamPriority(HttpStreamPriority());
+      case QuicPriorityType::kWebTransport:
+        return QuicStreamPriority(WebTransportStreamPriority());
+    }
   }
+
+  QuicPriorityType type() const { return std::visit(TypeExtractor(), value_); }
+
+  HttpStreamPriority http() const {
+    if (absl::holds_alternative<HttpStreamPriority>(value_)) {
+      return absl::get<HttpStreamPriority>(value_);
+    }
+    QUICHE_BUG(invalid_priority_type_http)
+        << "Tried to access HTTP priority for a priority type" << type();
+    return HttpStreamPriority();
+  }
+  WebTransportStreamPriority web_transport() const {
+    if (absl::holds_alternative<WebTransportStreamPriority>(value_)) {
+      return absl::get<WebTransportStreamPriority>(value_);
+    }
+    QUICHE_BUG(invalid_priority_type_wt)
+        << "Tried to access WebTransport priority for a priority type"
+        << type();
+    return WebTransportStreamPriority();
+  }
+
+  bool operator==(const QuicStreamPriority& other) const {
+    return value_ == other.value_;
+  }
+
+ private:
+  struct TypeExtractor {
+    QuicPriorityType operator()(const HttpStreamPriority&) {
+      return QuicPriorityType::kHttp;
+    }
+    QuicPriorityType operator()(const WebTransportStreamPriority&) {
+      return QuicPriorityType::kWebTransport;
+    }
+  };
+
+  absl::variant<HttpStreamPriority, WebTransportStreamPriority> value_;
 };
 
 // Serializes the Priority Field Value for a PRIORITY_UPDATE frame.
 QUICHE_EXPORT std::string SerializePriorityFieldValue(
-    QuicStreamPriority priority);
+    HttpStreamPriority priority);
 
 // Parses the Priority Field Value field of a PRIORITY_UPDATE frame.
 // Returns nullopt on failure.
-QUICHE_EXPORT absl::optional<QuicStreamPriority> ParsePriorityFieldValue(
+QUICHE_EXPORT absl::optional<HttpStreamPriority> ParsePriorityFieldValue(
     absl::string_view priority_field_value);
 
 }  // namespace quic
diff --git a/quiche/quic/core/quic_stream_priority_test.cc b/quiche/quic/core/quic_stream_priority_test.cc
index 88be74e..db5d1a9 100644
--- a/quiche/quic/core/quic_stream_priority_test.cc
+++ b/quiche/quic/core/quic_stream_priority_test.cc
@@ -4,30 +4,73 @@
 
 #include "quiche/quic/core/quic_stream_priority.h"
 
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
 namespace quic::test {
 
-TEST(QuicStreamPriority, DefaultConstructed) {
-  QuicStreamPriority priority;
+TEST(HttpStreamPriority, DefaultConstructed) {
+  HttpStreamPriority priority;
 
-  EXPECT_EQ(QuicStreamPriority::kDefaultUrgency, priority.urgency);
-  EXPECT_EQ(QuicStreamPriority::kDefaultIncremental, priority.incremental);
+  EXPECT_EQ(HttpStreamPriority::kDefaultUrgency, priority.urgency);
+  EXPECT_EQ(HttpStreamPriority::kDefaultIncremental, priority.incremental);
+}
+
+TEST(HttpStreamPriority, Equals) {
+  EXPECT_EQ((HttpStreamPriority()),
+            (HttpStreamPriority{HttpStreamPriority::kDefaultUrgency,
+                                HttpStreamPriority::kDefaultIncremental}));
+  EXPECT_EQ((HttpStreamPriority{5, true}), (HttpStreamPriority{5, true}));
+  EXPECT_EQ((HttpStreamPriority{2, false}), (HttpStreamPriority{2, false}));
+  EXPECT_EQ((HttpStreamPriority{11, true}), (HttpStreamPriority{11, true}));
+
+  EXPECT_NE((HttpStreamPriority{1, true}), (HttpStreamPriority{3, true}));
+  EXPECT_NE((HttpStreamPriority{4, false}), (HttpStreamPriority{4, true}));
+  EXPECT_NE((HttpStreamPriority{6, true}), (HttpStreamPriority{2, false}));
+  EXPECT_NE((HttpStreamPriority{12, true}), (HttpStreamPriority{9, true}));
+  EXPECT_NE((HttpStreamPriority{2, false}), (HttpStreamPriority{8, false}));
+}
+
+TEST(WebTransportStreamPriority, DefaultConstructed) {
+  WebTransportStreamPriority priority;
+
+  EXPECT_EQ(priority.stream_type,
+            WebTransportStreamPriority::StreamType::kData);
+  EXPECT_EQ(priority.send_order, 0);
+}
+
+TEST(WebTransportStreamPriority, Equals) {
+  EXPECT_EQ(WebTransportStreamPriority(),
+            (WebTransportStreamPriority{
+                WebTransportStreamPriority::StreamType::kData, 0}));
+  EXPECT_NE(WebTransportStreamPriority(),
+            (WebTransportStreamPriority{
+                WebTransportStreamPriority::StreamType::kData, 1}));
+  EXPECT_NE(WebTransportStreamPriority(),
+            (WebTransportStreamPriority{
+                WebTransportStreamPriority::StreamType::kHttp, 0}));
+}
+
+TEST(QuicStreamPriority, Default) {
+  EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kHttp).http(),
+            HttpStreamPriority());
+  EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kWebTransport)
+                .web_transport(),
+            WebTransportStreamPriority());
 }
 
 TEST(QuicStreamPriority, Equals) {
-  EXPECT_EQ((QuicStreamPriority()),
-            (QuicStreamPriority{QuicStreamPriority::kDefaultUrgency,
-                                QuicStreamPriority::kDefaultIncremental}));
-  EXPECT_EQ((QuicStreamPriority{5, true}), (QuicStreamPriority{5, true}));
-  EXPECT_EQ((QuicStreamPriority{2, false}), (QuicStreamPriority{2, false}));
-  EXPECT_EQ((QuicStreamPriority{11, true}), (QuicStreamPriority{11, true}));
+  EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kHttp),
+            QuicStreamPriority(HttpStreamPriority()));
+  EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kWebTransport),
+            QuicStreamPriority(WebTransportStreamPriority()));
+}
 
-  EXPECT_NE((QuicStreamPriority{1, true}), (QuicStreamPriority{3, true}));
-  EXPECT_NE((QuicStreamPriority{4, false}), (QuicStreamPriority{4, true}));
-  EXPECT_NE((QuicStreamPriority{6, true}), (QuicStreamPriority{2, false}));
-  EXPECT_NE((QuicStreamPriority{12, true}), (QuicStreamPriority{9, true}));
-  EXPECT_NE((QuicStreamPriority{2, false}), (QuicStreamPriority{8, false}));
+TEST(QuicStreamPriority, Type) {
+  EXPECT_EQ(QuicStreamPriority(HttpStreamPriority()).type(),
+            QuicPriorityType::kHttp);
+  EXPECT_EQ(QuicStreamPriority(WebTransportStreamPriority()).type(),
+            QuicPriorityType::kWebTransport);
 }
 
 TEST(SerializePriorityFieldValueTest, SerializePriorityFieldValue) {
@@ -48,7 +91,7 @@
 
 TEST(ParsePriorityFieldValueTest, ParsePriorityFieldValue) {
   // Default values
-  absl::optional<QuicStreamPriority> result = ParsePriorityFieldValue("");
+  absl::optional<HttpStreamPriority> result = ParsePriorityFieldValue("");
   ASSERT_TRUE(result.has_value());
   EXPECT_EQ(3, result->urgency);
   EXPECT_FALSE(result->incremental);
diff --git a/quiche/quic/core/quic_types.cc b/quiche/quic/core/quic_types.cc
index 46b2fc2..e046092 100644
--- a/quiche/quic/core/quic_types.cc
+++ b/quiche/quic/core/quic_types.cc
@@ -431,6 +431,21 @@
   return os;
 }
 
+QUICHE_EXPORT std::string QuicPriorityTypeToString(QuicPriorityType type) {
+  switch (type) {
+    case quic::QuicPriorityType::kHttp:
+      return "HTTP (RFC 9218)";
+    case quic::QuicPriorityType::kWebTransport:
+      return "WebTransport (W3C API)";
+  }
+  return "(unknown)";
+}
+QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
+                                             QuicPriorityType type) {
+  os << QuicPriorityTypeToString(type);
+  return os;
+}
+
 #undef RETURN_STRING_LITERAL  // undef for jumbo builds
 
 }  // namespace quic
diff --git a/quiche/quic/core/quic_types.h b/quiche/quic/core/quic_types.h
index c3a71bb..1eba1f7 100644
--- a/quiche/quic/core/quic_types.h
+++ b/quiche/quic/core/quic_types.h
@@ -904,6 +904,18 @@
   QuicPacketCount ce = 0;
 };
 
+// Type of the priorities used by a QUIC session.
+enum class QuicPriorityType : uint8_t {
+  // HTTP priorities as defined by RFC 9218
+  kHttp,
+  // WebTransport priorities as defined by <https://w3c.github.io/webtransport/>
+  kWebTransport,
+};
+
+QUICHE_EXPORT std::string QuicPriorityTypeToString(QuicPriorityType type);
+QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
+                                             QuicPriorityType type);
+
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_QUIC_TYPES_H_
diff --git a/quiche/quic/core/quic_write_blocked_list.cc b/quiche/quic/core/quic_write_blocked_list.cc
index 3f09167..475bdc1 100644
--- a/quiche/quic/core/quic_write_blocked_list.cc
+++ b/quiche/quic/core/quic_write_blocked_list.cc
@@ -39,10 +39,8 @@
     return static_stream_id;
   }
 
-  const auto id_and_priority =
+  const auto [id, priority] =
       priority_write_scheduler_.PopNextReadyStreamAndPriority();
-  const QuicStreamId id = std::get<0>(id_and_priority);
-  const QuicStreamPriority& priority = std::get<1>(id_and_priority);
   const spdy::SpdyPriority urgency = priority.urgency;
   const bool incremental = priority.incremental;
 
@@ -86,7 +84,7 @@
     return;
   }
 
-  priority_write_scheduler_.RegisterStream(stream_id, priority);
+  priority_write_scheduler_.RegisterStream(stream_id, priority.http());
 }
 
 void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id) {
@@ -99,7 +97,8 @@
 void QuicWriteBlockedList::UpdateStreamPriority(
     QuicStreamId stream_id, const QuicStreamPriority& new_priority) {
   QUICHE_DCHECK(!static_stream_collection_.IsRegistered(stream_id));
-  priority_write_scheduler_.UpdateStreamPriority(stream_id, new_priority);
+  priority_write_scheduler_.UpdateStreamPriority(stream_id,
+                                                 new_priority.http());
 }
 
 void QuicWriteBlockedList::UpdateBytesForStream(QuicStreamId stream_id,
diff --git a/quiche/quic/core/quic_write_blocked_list.h b/quiche/quic/core/quic_write_blocked_list.h
index f6726dc..1c7f25a 100644
--- a/quiche/quic/core/quic_write_blocked_list.h
+++ b/quiche/quic/core/quic_write_blocked_list.h
@@ -98,7 +98,7 @@
   bool ShouldYield(QuicStreamId id) const override;
 
   QuicStreamPriority GetPriorityOfStream(QuicStreamId id) const override {
-    return priority_write_scheduler_.GetStreamPriority(id);
+    return QuicStreamPriority(priority_write_scheduler_.GetStreamPriority(id));
   }
 
   // Pops the highest priority stream, special casing static streams. Latches
@@ -134,9 +134,20 @@
   bool IsStreamBlocked(QuicStreamId stream_id) const override;
 
  private:
-  http2::PriorityWriteScheduler<QuicStreamId, QuicStreamPriority,
-                                QuicStreamPriorityToInt,
-                                IntToQuicStreamPriority>
+  struct QUICHE_EXPORT HttpStreamPriorityToInt {
+    int operator()(const HttpStreamPriority& priority) {
+      return priority.urgency;
+    }
+  };
+
+  struct QUICHE_EXPORT IntToHttpStreamPriority {
+    HttpStreamPriority operator()(int urgency) {
+      return HttpStreamPriority{urgency};
+    }
+  };
+  http2::PriorityWriteScheduler<QuicStreamId, HttpStreamPriority,
+                                HttpStreamPriorityToInt,
+                                IntToHttpStreamPriority>
       priority_write_scheduler_;
 
   // If performing batch writes, this will be the stream ID of the stream doing
diff --git a/quiche/quic/core/quic_write_blocked_list_test.cc b/quiche/quic/core/quic_write_blocked_list_test.cc
index 4272358..ba6569e 100644
--- a/quiche/quic/core/quic_write_blocked_list_test.cc
+++ b/quiche/quic/core/quic_write_blocked_list_test.cc
@@ -57,8 +57,9 @@
   QuicStreamId PopFront() { return write_blocked_list_->PopFront(); }
 
   void RegisterStream(QuicStreamId stream_id, bool is_static_stream,
-                      const QuicStreamPriority& priority) {
-    write_blocked_list_->RegisterStream(stream_id, is_static_stream, priority);
+                      const HttpStreamPriority& priority) {
+    write_blocked_list_->RegisterStream(stream_id, is_static_stream,
+                                        QuicStreamPriority(priority));
   }
 
   void UnregisterStream(QuicStreamId stream_id) {
@@ -66,8 +67,9 @@
   }
 
   void UpdateStreamPriority(QuicStreamId stream_id,
-                            const QuicStreamPriority& new_priority) {
-    write_blocked_list_->UpdateStreamPriority(stream_id, new_priority);
+                            const HttpStreamPriority& new_priority) {
+    write_blocked_list_->UpdateStreamPriority(stream_id,
+                                              QuicStreamPriority(new_priority));
   }
 
   void UpdateBytesForStream(QuicStreamId stream_id, size_t bytes) {
@@ -95,14 +97,14 @@
   RegisterStream(1, kStatic, {kV3HighestPriority, kNotIncremental});
   RegisterStream(3, kStatic, {kV3HighestPriority, kNotIncremental});
 
-  EXPECT_EQ(kV3LowestPriority, GetPriorityOfStream(40).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(40).incremental);
+  EXPECT_EQ(kV3LowestPriority, GetPriorityOfStream(40).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(40).http().incremental);
 
-  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(23).urgency);
-  EXPECT_EQ(kIncremental, GetPriorityOfStream(23).incremental);
+  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(23).http().urgency);
+  EXPECT_EQ(kIncremental, GetPriorityOfStream(23).http().incremental);
 
-  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(17).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(17).incremental);
+  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(17).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(17).http().incremental);
 
   AddStream(40);
   EXPECT_TRUE(IsStreamBlocked(40));
@@ -577,27 +579,27 @@
   RegisterStream(1, kStatic, {2, kNotIncremental});
   RegisterStream(3, kStatic, {kV3HighestPriority, kNotIncremental});
 
-  EXPECT_EQ(kV3LowestPriority, GetPriorityOfStream(40).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(40).incremental);
+  EXPECT_EQ(kV3LowestPriority, GetPriorityOfStream(40).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(40).http().incremental);
 
-  EXPECT_EQ(6, GetPriorityOfStream(23).urgency);
-  EXPECT_EQ(kIncremental, GetPriorityOfStream(23).incremental);
+  EXPECT_EQ(6, GetPriorityOfStream(23).http().urgency);
+  EXPECT_EQ(kIncremental, GetPriorityOfStream(23).http().incremental);
 
-  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(17).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(17).incremental);
+  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(17).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(17).http().incremental);
 
   UpdateStreamPriority(40, {3, kIncremental});
   UpdateStreamPriority(23, {kV3HighestPriority, kNotIncremental});
   UpdateStreamPriority(17, {5, kNotIncremental});
 
-  EXPECT_EQ(3, GetPriorityOfStream(40).urgency);
-  EXPECT_EQ(kIncremental, GetPriorityOfStream(40).incremental);
+  EXPECT_EQ(3, GetPriorityOfStream(40).http().urgency);
+  EXPECT_EQ(kIncremental, GetPriorityOfStream(40).http().incremental);
 
-  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(23).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(23).incremental);
+  EXPECT_EQ(kV3HighestPriority, GetPriorityOfStream(23).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(23).http().incremental);
 
-  EXPECT_EQ(5, GetPriorityOfStream(17).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(17).incremental);
+  EXPECT_EQ(5, GetPriorityOfStream(17).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(17).http().incremental);
 
   AddStream(40);
   AddStream(23);
@@ -637,13 +639,13 @@
   RegisterStream(3, kNotStatic, {6, kNotIncremental});
   RegisterStream(4, kNotStatic, {6, kNotIncremental});
 
-  EXPECT_EQ(6, GetPriorityOfStream(3).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(3).incremental);
+  EXPECT_EQ(6, GetPriorityOfStream(3).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(3).http().incremental);
 
   UpdateStreamPriority(3, {6, kIncremental});
 
-  EXPECT_EQ(6, GetPriorityOfStream(3).urgency);
-  EXPECT_EQ(kIncremental, GetPriorityOfStream(3).incremental);
+  EXPECT_EQ(6, GetPriorityOfStream(3).http().urgency);
+  EXPECT_EQ(kIncremental, GetPriorityOfStream(3).http().incremental);
 
   AddStream(3);
   AddStream(4);
@@ -656,13 +658,13 @@
   RegisterStream(5, kNotStatic, {6, kIncremental});
   RegisterStream(6, kNotStatic, {6, kIncremental});
 
-  EXPECT_EQ(6, GetPriorityOfStream(6).urgency);
-  EXPECT_EQ(kIncremental, GetPriorityOfStream(6).incremental);
+  EXPECT_EQ(6, GetPriorityOfStream(6).http().urgency);
+  EXPECT_EQ(kIncremental, GetPriorityOfStream(6).http().incremental);
 
   UpdateStreamPriority(6, {6, kNotIncremental});
 
-  EXPECT_EQ(6, GetPriorityOfStream(6).urgency);
-  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(6).incremental);
+  EXPECT_EQ(6, GetPriorityOfStream(6).http().urgency);
+  EXPECT_EQ(kNotIncremental, GetPriorityOfStream(6).http().incremental);
 
   AddStream(5);
   AddStream(6);
diff --git a/quiche/quic/qbone/qbone_stream_test.cc b/quiche/quic/qbone/qbone_stream_test.cc
index ea5fafb..b7cc198 100644
--- a/quiche/quic/qbone/qbone_stream_test.cc
+++ b/quiche/quic/qbone/qbone_stream_test.cc
@@ -71,7 +71,7 @@
     write_blocked_streams()->RegisterStream(
         stream_id,
         /* is_static_stream = */ false,
-        QuicStreamPriority{3, QuicStreamPriority::kDefaultIncremental});
+        QuicStreamPriority::Default(priority_type()));
   }
 
   // The session take ownership of the stream.
diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
index 224046a..a617348 100644
--- a/quiche/quic/test_tools/quic_test_client.cc
+++ b/quiche/quic/test_tools/quic_test_client.cc
@@ -543,8 +543,8 @@
   if (!latest_created_stream_) {
     SetLatestCreatedStream(client_->CreateClientStream());
     if (latest_created_stream_) {
-      latest_created_stream_->SetPriority(
-          QuicStreamPriority{priority_, /* incremental = */ false});
+      latest_created_stream_->SetPriority(QuicStreamPriority(
+          HttpStreamPriority{priority_, /* incremental = */ false}));
     }
   }
 
diff --git a/quiche/quic/tools/quic_simple_server_session.cc b/quiche/quic/tools/quic_simple_server_session.cc
index a8ac5f0..ed5b40d 100644
--- a/quiche/quic/tools/quic_simple_server_session.cc
+++ b/quiche/quic/tools/quic_simple_server_session.cc
@@ -196,9 +196,9 @@
     QUICHE_DCHECK_EQ(promised_info.stream_id, promised_stream->id());
     QUIC_DLOG(INFO) << "created server push stream " << promised_stream->id();
 
-    promised_stream->SetPriority(
-        QuicStreamPriority{promised_info.precedence.spdy3_priority(),
-                           QuicStreamPriority::kDefaultIncremental});
+    promised_stream->SetPriority(QuicStreamPriority(
+        HttpStreamPriority{promised_info.precedence.spdy3_priority(),
+                           HttpStreamPriority::kDefaultIncremental}));
 
     spdy::Http2HeaderBlock request_headers(
         std::move(promised_info.request_headers));
diff --git a/quiche/quic/tools/quic_simple_server_session_test.cc b/quiche/quic/tools/quic_simple_server_session_test.cc
index c30283c..9bb5a1a 100644
--- a/quiche/quic/tools/quic_simple_server_session_test.cc
+++ b/quiche/quic/tools/quic_simple_server_session_test.cc
@@ -502,7 +502,8 @@
   if (!VersionUsesHttp3(transport_version())) {
     session_->RegisterStreamPriority(
         QuicUtils::GetHeadersStreamId(transport_version()),
-        /*is_static=*/true, QuicStreamPriority());
+        /*is_static=*/true,
+        QuicStreamPriority::Default(session_->priority_type()));
   }
 
   // Create push streams till reaching the upper limit of allowed open streams.