Allow QuicStreamPriority hold different types of priority.
The two types introduced in this CL are HttpStreamPriority and WebTransportStreamPriority.
PiperOrigin-RevId: 517979331
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.
