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.