Change PriorityWriteScheduler to use SpdyPriority. PriorityWriteScheduler only uses the priority value of spdy::StreamPrecedence, it ignores the parent stream and weight (if any). For simplicity, this CL changes RegisterStream() and UpdateStreamPriority() to take SpdyPriority instead, and GetStreamPriority() to return one. Also introduce PriorityWriteScheduler::PriorityType. This is an alias for spdy::SpdyPriority for now, and will become a template parameter in the next CL. Also rename UpdateStreamPrecedence() to UpdateStreamPriority() and GetStreamPrecedence() to GetStreamPriority() to reflect the argument type change. Also renames GetLatestEventWithPrecedence() to GetLatestEventWithPriority(), both on PriorityWriteScheduler and Http2Dispatcher, to reflect that it is only the priority (integer value) of the stream that is considered in that method. Also remove unused GetStreamChildren() method. PiperOrigin-RevId: 502977611
diff --git a/quiche/http2/adapter/oghttp2_session.cc b/quiche/http2/adapter/oghttp2_session.cc index a760bbc..5f8b5ef 100644 --- a/quiche/http2/adapter/oghttp2_session.cc +++ b/quiche/http2/adapter/oghttp2_session.cc
@@ -1769,8 +1769,8 @@ std::move(listener), options_.should_window_update_fn)); if (inserted) { // Add the stream to the write scheduler. - const WriteScheduler::StreamPrecedenceType precedence(3); - write_scheduler_.RegisterStream(stream_id, precedence); + const spdy::SpdyPriority priority = 3; + write_scheduler_.RegisterStream(stream_id, priority); highest_processed_stream_id_ = std::max(highest_processed_stream_id_, stream_id);
diff --git a/quiche/http2/core/priority_write_scheduler.h b/quiche/http2/core/priority_write_scheduler.h index ff867a9..54181f3 100644 --- a/quiche/http2/core/priority_write_scheduler.h +++ b/quiche/http2/core/priority_write_scheduler.h
@@ -44,7 +44,7 @@ template <typename StreamIdType> class QUICHE_EXPORT PriorityWriteScheduler { public: - using StreamPrecedenceType = spdy::StreamPrecedence<StreamIdType>; + using PriorityType = spdy::SpdyPriority; static constexpr int kHighestPriority = 0; static constexpr int kLowestPriority = 7; @@ -53,16 +53,12 @@ static_assert(spdy::kV3LowestPriority == kLowestPriority); // Registers new stream `stream_id` with the scheduler, assigning it the - // given precedence. If the scheduler supports stream dependencies, the - // stream is inserted into the dependency tree under - // `precedence.parent_id()`. + // given priority. // - // Preconditions: `stream_id` should be unregistered, and - // `precedence.parent_id()` should be registered or `kHttp2RootStreamId`. - void RegisterStream(StreamIdType stream_id, - const StreamPrecedenceType& precedence) { - auto stream_info = std::make_unique<StreamInfo>( - StreamInfo{precedence.spdy3_priority(), stream_id, false}); + // Preconditions: `stream_id` should be unregistered. + void RegisterStream(StreamIdType stream_id, PriorityType priority) { + auto stream_info = + std::make_unique<StreamInfo>(StreamInfo{priority, stream_id, false}); bool inserted = stream_infos_.insert(std::make_pair(stream_id, std::move(stream_info))) .second; @@ -94,29 +90,22 @@ return stream_infos_.find(stream_id) != stream_infos_.end(); } - // Returns the precedence of the specified stream. If the scheduler supports - // stream dependencies, calling `parent_id()` on the return value returns the - // stream's parent, and calling `exclusive()` returns true iff the specified - // stream is an only child of the parent stream. + // Returns the priority of the specified stream. // // Preconditions: `stream_id` should be registered. - StreamPrecedenceType GetStreamPrecedence(StreamIdType stream_id) const { + PriorityType GetStreamPriority(StreamIdType stream_id) const { auto it = stream_infos_.find(stream_id); if (it == stream_infos_.end()) { QUICHE_DVLOG(1) << "Stream " << stream_id << " not registered"; - return StreamPrecedenceType(kLowestPriority); + return kLowestPriority; } - return StreamPrecedenceType(it->second->priority); + return it->second->priority; } - // Updates the precedence of the given stream. If the scheduler supports - // stream dependencies, `stream_id`'s parent will be updated to be - // `precedence.parent_id()` if it is not already. + // Updates the priority of the given stream. // - // Preconditions: `stream_id` should be unregistered, and - // `precedence.parent_id()` should be registered or `kHttp2RootStreamId`. - void UpdateStreamPrecedence(StreamIdType stream_id, - const StreamPrecedenceType& precedence) { + // Preconditions: `stream_id` should be registered. + void UpdateStreamPriority(StreamIdType stream_id, PriorityType priority) { auto it = stream_infos_.find(stream_id); if (it == stream_infos_.end()) { // TODO(mpw): add to stream_infos_ on demand--see b/15676312. @@ -124,27 +113,17 @@ return; } StreamInfo* const stream_info = it->second.get(); - spdy::SpdyPriority new_priority = precedence.spdy3_priority(); - if (stream_info->priority == new_priority) { + if (stream_info->priority == priority) { return; } if (stream_info->ready) { bool erased = Erase(&priority_infos_[stream_info->priority].ready_list, stream_info); QUICHE_DCHECK(erased); - priority_infos_[new_priority].ready_list.push_back(stream_info); + priority_infos_[priority].ready_list.push_back(stream_info); ++num_ready_streams_; } - stream_info->priority = new_priority; - } - - // Returns child streams of the given stream, if any. If the scheduler - // doesn't support stream dependencies, returns an empty vector. - // - // Preconditions: `stream_id` should be registered. - std::vector<StreamIdType> GetStreamChildren( - StreamIdType /*stream_id*/) const { - return std::vector<StreamIdType>(); + stream_info->priority = priority; } // Records time (in microseconds) of a read/write event for the given @@ -167,7 +146,7 @@ // is no such event. // // Preconditions: `stream_id` should be registered. - int64_t GetLatestEventWithPrecedence(StreamIdType stream_id) const { + int64_t GetLatestEventWithPriority(StreamIdType stream_id) const { auto it = stream_infos_.find(stream_id); if (it == stream_infos_.end()) { QUICHE_BUG(spdy_bug_19_5) << "Stream " << stream_id << " not registered"; @@ -175,8 +154,7 @@ } int64_t last_event_time_usec = 0; const StreamInfo* const stream_info = it->second.get(); - for (spdy::SpdyPriority p = kHighestPriority; p < stream_info->priority; - ++p) { + for (PriorityType p = kHighestPriority; p < stream_info->priority; ++p) { last_event_time_usec = std::max(last_event_time_usec, priority_infos_[p].last_event_time_usec); } @@ -189,7 +167,7 @@ // // Preconditions: `HasReadyStreams() == true` StreamIdType PopNextReadyStream() { - return std::get<0>(PopNextReadyStreamAndPrecedence()); + return std::get<0>(PopNextReadyStreamAndPriority()); } // If the scheduler has any ready streams, returns the next scheduled @@ -197,9 +175,8 @@ // ready to not ready. // // Preconditions: `HasReadyStreams() == true` - std::tuple<StreamIdType, StreamPrecedenceType> - PopNextReadyStreamAndPrecedence() { - for (spdy::SpdyPriority p = kHighestPriority; p <= kLowestPriority; ++p) { + std::tuple<StreamIdType, PriorityType> PopNextReadyStreamAndPriority() { + for (PriorityType p = kHighestPriority; p <= kLowestPriority; ++p) { ReadyList& ready_list = priority_infos_[p].ready_list; if (!ready_list.empty()) { StreamInfo* const info = ready_list.front(); @@ -209,12 +186,11 @@ QUICHE_DCHECK(stream_infos_.find(info->stream_id) != stream_infos_.end()); info->ready = false; - return std::make_tuple(info->stream_id, - StreamPrecedenceType(info->priority)); + return std::make_tuple(info->stream_id, info->priority); } } QUICHE_BUG(spdy_bug_19_6) << "No ready streams available"; - return std::make_tuple(0, StreamPrecedenceType(kLowestPriority)); + return std::make_tuple(0, kLowestPriority); } // Returns true if there's another stream ahead of the given stream in the @@ -231,8 +207,7 @@ // If there's a higher priority stream, this stream should yield. const StreamInfo* const stream_info = it->second.get(); - for (spdy::SpdyPriority p = kHighestPriority; p < stream_info->priority; - ++p) { + for (PriorityType p = kHighestPriority; p < stream_info->priority; ++p) { if (!priority_infos_[p].ready_list.empty()) { return true; } @@ -324,10 +299,11 @@ private: friend class test::PriorityWriteSchedulerPeer<StreamIdType>; - // State kept for all registered streams. All ready streams have ready = true - // and should be present in priority_infos_[priority].ready_list. + // State kept for all registered streams. + // All ready streams have `ready == true` and should be present in + // `priority_infos_[priority].ready_list`. struct QUICHE_EXPORT StreamInfo { - spdy::SpdyPriority priority; + PriorityType priority; StreamIdType stream_id; bool ready; };
diff --git a/quiche/http2/core/priority_write_scheduler_test.cc b/quiche/http2/core/priority_write_scheduler_test.cc index e8a54dd..8a4e518 100644 --- a/quiche/http2/core/priority_write_scheduler_test.cc +++ b/quiche/http2/core/priority_write_scheduler_test.cc
@@ -15,7 +15,6 @@ using ::spdy::kHttp2RootStreamId; using ::spdy::SpdyPriority; using ::spdy::SpdyStreamId; -using ::spdy::SpdyStreamPrecedence; template <typename StreamIdType> class PriorityWriteSchedulerPeer { @@ -49,20 +48,20 @@ EXPECT_FALSE(scheduler_.HasReadyStreams()); EXPECT_FALSE(scheduler_.StreamRegistered(1)); EXPECT_EQ(0u, scheduler_.NumRegisteredStreams()); - scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)); + scheduler_.RegisterStream(1, 1); EXPECT_TRUE(scheduler_.StreamRegistered(1)); EXPECT_EQ(1u, scheduler_.NumRegisteredStreams()); // Try redundant registrations. - EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)), + EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, 1), "Stream 1 already registered"); EXPECT_EQ(1u, scheduler_.NumRegisteredStreams()); - EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(2)), + EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, 2), "Stream 1 already registered"); EXPECT_EQ(1u, scheduler_.NumRegisteredStreams()); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(2, 3); EXPECT_EQ(2u, scheduler_.NumRegisteredStreams()); // Verify registration != ready. @@ -79,101 +78,70 @@ EXPECT_EQ(0u, scheduler_.NumRegisteredStreams()); } -TEST_F(PriorityWriteSchedulerTest, RegisterStreamWithHttp2StreamDependency) { - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_FALSE(scheduler_.StreamRegistered(1)); - scheduler_.RegisterStream( - 1, SpdyStreamPrecedence(kHttp2RootStreamId, 123, false)); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - - EXPECT_QUICHE_BUG( - scheduler_.RegisterStream( - 1, SpdyStreamPrecedence(kHttp2RootStreamId, 256, false)), - "Stream 1 already registered"); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - // Registering stream with a non-existent parent stream is permissible, per - // b/15676312, but parent stream will always be reset to 0. - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3, 123, false)); - EXPECT_TRUE(scheduler_.StreamRegistered(2)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(2).parent_id()); -} - -TEST_F(PriorityWriteSchedulerTest, GetStreamPrecedence) { +TEST_F(PriorityWriteSchedulerTest, GetStreamPriority) { // Unknown streams tolerated due to b/15676312. However, return lowest // priority. - EXPECT_EQ(kLowestPriority, - scheduler_.GetStreamPrecedence(1).spdy3_priority()); + EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(1)); - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); + scheduler_.RegisterStream(1, 3); + EXPECT_EQ(3, scheduler_.GetStreamPriority(1)); // Redundant registration shouldn't change stream priority. - EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)), + EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, 4), "Stream 1 already registered"); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); + EXPECT_EQ(3, scheduler_.GetStreamPriority(1)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(5)); - EXPECT_EQ(5, scheduler_.GetStreamPrecedence(1).spdy3_priority()); + scheduler_.UpdateStreamPriority(1, 5); + EXPECT_EQ(5, scheduler_.GetStreamPriority(1)); // Toggling ready state shouldn't change stream priority. scheduler_.MarkStreamReady(1, true); - EXPECT_EQ(5, scheduler_.GetStreamPrecedence(1).spdy3_priority()); + EXPECT_EQ(5, scheduler_.GetStreamPriority(1)); // Test changing priority of ready stream. EXPECT_EQ(1u, peer_.NumReadyStreams(5)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(6)); - EXPECT_EQ(6, scheduler_.GetStreamPrecedence(1).spdy3_priority()); + scheduler_.UpdateStreamPriority(1, 6); + EXPECT_EQ(6, scheduler_.GetStreamPriority(1)); EXPECT_EQ(0u, peer_.NumReadyStreams(5)); EXPECT_EQ(1u, peer_.NumReadyStreams(6)); EXPECT_EQ(1u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(6, scheduler_.GetStreamPrecedence(1).spdy3_priority()); + EXPECT_EQ(6, scheduler_.GetStreamPriority(1)); scheduler_.UnregisterStream(1); - EXPECT_EQ(kLowestPriority, - scheduler_.GetStreamPrecedence(1).spdy3_priority()); + EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(1)); } -TEST_F(PriorityWriteSchedulerTest, PopNextReadyStreamAndPrecedence) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); +TEST_F(PriorityWriteSchedulerTest, PopNextReadyStreamAndPriority) { + scheduler_.RegisterStream(1, 3); scheduler_.MarkStreamReady(1, true); - EXPECT_EQ(std::make_tuple(1u, SpdyStreamPrecedence(3)), - scheduler_.PopNextReadyStreamAndPrecedence()); + EXPECT_EQ(std::make_tuple(1u, 3), scheduler_.PopNextReadyStreamAndPriority()); scheduler_.UnregisterStream(1); } -TEST_F(PriorityWriteSchedulerTest, UpdateStreamPrecedence) { - // For the moment, updating stream precedence on a non-registered stream - // should have no effect. In the future, it will lazily cause the stream to - // be registered (b/15676312). - EXPECT_EQ(kLowestPriority, - scheduler_.GetStreamPrecedence(3).spdy3_priority()); +TEST_F(PriorityWriteSchedulerTest, UpdateStreamPriority) { + // For the moment, updating stream priority on a non-registered stream should + // have no effect. In the future, it will lazily cause the stream to be + // registered (b/15676312). + EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(3)); EXPECT_FALSE(scheduler_.StreamRegistered(3)); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(1)); + scheduler_.UpdateStreamPriority(3, 1); EXPECT_FALSE(scheduler_.StreamRegistered(3)); - EXPECT_EQ(kLowestPriority, - scheduler_.GetStreamPrecedence(3).spdy3_priority()); + EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(3)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1)); - EXPECT_EQ(1, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(2)); - EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).spdy3_priority()); + scheduler_.RegisterStream(3, 1); + EXPECT_EQ(1, scheduler_.GetStreamPriority(3)); + scheduler_.UpdateStreamPriority(3, 2); + EXPECT_EQ(2, scheduler_.GetStreamPriority(3)); // Updating priority of stream to current priority value is valid, but has no // effect. - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(2)); - EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).spdy3_priority()); + scheduler_.UpdateStreamPriority(3, 2); + EXPECT_EQ(2, scheduler_.GetStreamPriority(3)); // Even though stream 4 is marked ready after stream 5, it should be returned // first by PopNextReadyStream() since it has higher priority. - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1)); + scheduler_.RegisterStream(4, 1); scheduler_.MarkStreamReady(3, false); // priority 2 EXPECT_TRUE(scheduler_.IsStreamReady(3)); scheduler_.MarkStreamReady(4, false); // priority 1 @@ -187,29 +155,13 @@ // by PopNextReadyStream(). scheduler_.MarkStreamReady(3, false); // priority 2 scheduler_.MarkStreamReady(4, false); // priority 1 - scheduler_.UpdateStreamPrecedence(4, SpdyStreamPrecedence(3)); + scheduler_.UpdateStreamPriority(4, 3); EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); scheduler_.UnregisterStream(3); } -TEST_F(PriorityWriteSchedulerTest, - UpdateStreamPrecedenceWithHttp2StreamDependency) { - // Unknown streams tolerated due to b/15676312, but should have no effect. - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false)); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(3).is_spdy3_priority()); - EXPECT_EQ(4, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - - scheduler_.UnregisterStream(3); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); -} - TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBack) { EXPECT_FALSE(scheduler_.HasReadyStreams()); EXPECT_QUICHE_BUG(scheduler_.MarkStreamReady(1, false), @@ -220,16 +172,16 @@ // Add a bunch of ready streams to tail of per-priority lists. // Expected order: (P2) 4, (P3) 1, 2, 3, (P5) 5. - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(1, 3); scheduler_.MarkStreamReady(1, false); EXPECT_TRUE(scheduler_.HasReadyStreams()); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(2, 3); scheduler_.MarkStreamReady(2, false); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(3, 3); scheduler_.MarkStreamReady(3, false); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2)); + scheduler_.RegisterStream(4, 2); scheduler_.MarkStreamReady(4, false); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(5)); + scheduler_.RegisterStream(5, 5); scheduler_.MarkStreamReady(5, false); EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); @@ -251,16 +203,16 @@ // Add a bunch of ready streams to head of per-priority lists. // Expected order: (P2) 4, (P3) 3, 2, 1, (P5) 5 - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(1, 3); scheduler_.MarkStreamReady(1, true); EXPECT_TRUE(scheduler_.HasReadyStreams()); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(2, 3); scheduler_.MarkStreamReady(2, true); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); + scheduler_.RegisterStream(3, 3); scheduler_.MarkStreamReady(3, true); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2)); + scheduler_.RegisterStream(4, 2); scheduler_.MarkStreamReady(4, true); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(5)); + scheduler_.RegisterStream(5, 5); scheduler_.MarkStreamReady(5, true); EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); @@ -273,12 +225,12 @@ } TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBackAndFront) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(3)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(1)); + scheduler_.RegisterStream(1, 4); + scheduler_.RegisterStream(2, 3); + scheduler_.RegisterStream(3, 3); + scheduler_.RegisterStream(4, 3); + scheduler_.RegisterStream(5, 4); + scheduler_.RegisterStream(6, 1); // Add a bunch of ready streams to per-priority lists, with variety of adding // at head and tail. @@ -302,7 +254,7 @@ TEST_F(PriorityWriteSchedulerTest, MarkStreamNotReady) { // Verify ready state reflected in NumReadyStreams(). - scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)); + scheduler_.RegisterStream(1, 1); EXPECT_EQ(0u, scheduler_.NumReadyStreams()); scheduler_.MarkStreamReady(1, false); EXPECT_EQ(1u, scheduler_.NumReadyStreams()); @@ -323,7 +275,7 @@ } TEST_F(PriorityWriteSchedulerTest, UnregisterRemovesStream) { - scheduler_.RegisterStream(3, SpdyStreamPrecedence(4)); + scheduler_.RegisterStream(3, 4); scheduler_.MarkStreamReady(3, false); EXPECT_EQ(1u, scheduler_.NumReadyStreams()); @@ -335,10 +287,10 @@ } TEST_F(PriorityWriteSchedulerTest, ShouldYield) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(7)); + scheduler_.RegisterStream(1, 1); + scheduler_.RegisterStream(4, 4); + scheduler_.RegisterStream(5, 4); + scheduler_.RegisterStream(7, 7); // Make sure we don't yield when the list is empty. EXPECT_FALSE(scheduler_.ShouldYield(1)); @@ -361,23 +313,23 @@ EXPECT_TRUE(scheduler_.ShouldYield(5)); } -TEST_F(PriorityWriteSchedulerTest, GetLatestEventWithPrecedence) { +TEST_F(PriorityWriteSchedulerTest, GetLatestEventWithPriority) { EXPECT_QUICHE_BUG(scheduler_.RecordStreamEventTime(3, 5), "Stream 3 not registered"); - EXPECT_QUICHE_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)), + EXPECT_QUICHE_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPriority(4)), "Stream 4 not registered"); for (int i = 1; i < 5; ++i) { - scheduler_.RegisterStream(i, SpdyStreamPrecedence(i)); + scheduler_.RegisterStream(i, i); } for (int i = 1; i < 5; ++i) { - EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(i)); + EXPECT_EQ(0, scheduler_.GetLatestEventWithPriority(i)); } for (int i = 1; i < 5; ++i) { scheduler_.RecordStreamEventTime(i, i * 100); } for (int i = 1; i < 5; ++i) { - EXPECT_EQ((i - 1) * 100, scheduler_.GetLatestEventWithPrecedence(i)); + EXPECT_EQ((i - 1) * 100, scheduler_.GetLatestEventWithPriority(i)); } }
diff --git a/quiche/quic/core/quic_write_blocked_list.cc b/quiche/quic/core/quic_write_blocked_list.cc index 9e53c94..473b154 100644 --- a/quiche/quic/core/quic_write_blocked_list.cc +++ b/quiche/quic/core/quic_write_blocked_list.cc
@@ -35,11 +35,10 @@ return static_stream_id; } - const auto id_and_precedence = - priority_write_scheduler_.PopNextReadyStreamAndPrecedence(); - const QuicStreamId id = std::get<0>(id_and_precedence); - const spdy::SpdyPriority priority = - std::get<1>(id_and_precedence).spdy3_priority(); + const auto id_and_priority = + priority_write_scheduler_.PopNextReadyStreamAndPriority(); + const QuicStreamId id = std::get<0>(id_and_priority); + const spdy::SpdyPriority priority = std::get<1>(id_and_priority); if (!priority_write_scheduler_.HasReadyStreams()) { // If no streams are blocked, don't bother latching. This stream will be @@ -66,8 +65,7 @@ return; } - priority_write_scheduler_.RegisterStream( - stream_id, spdy::SpdyStreamPrecedence(priority.urgency)); + priority_write_scheduler_.RegisterStream(stream_id, priority.urgency); } void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id, @@ -82,8 +80,8 @@ void QuicWriteBlockedList::UpdateStreamPriority( QuicStreamId stream_id, const QuicStreamPriority& new_priority) { QUICHE_DCHECK(!static_stream_collection_.IsRegistered(stream_id)); - priority_write_scheduler_.UpdateStreamPrecedence( - stream_id, spdy::SpdyStreamPrecedence(new_priority.urgency)); + priority_write_scheduler_.UpdateStreamPriority(stream_id, + new_priority.urgency); } 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 3a8fc6c..1bbff6e 100644 --- a/quiche/quic/core/quic_write_blocked_list.h +++ b/quiche/quic/core/quic_write_blocked_list.h
@@ -51,7 +51,7 @@ bool ShouldYield(QuicStreamId id) const; spdy::SpdyPriority GetSpdyPriorityofStream(QuicStreamId id) const { - return priority_write_scheduler_.GetStreamPrecedence(id).spdy3_priority(); + return priority_write_scheduler_.GetStreamPriority(id); } // Pops the highest priority stream, special casing static streams. Latches