Renumber QUIC streams when there is no crypto stream This also modifies spdy::PriorityWriteScheduler to allow using a different value than kHttp2RootStreamId as the root stream ID. gfe-relnote: Renumber QUIC streams, protected by QUIC_VERSION_99 PiperOrigin-RevId: 248609263 Change-Id: I5e83b5950253068996df830694ac55e424d7aa54
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc index e0e417a..8217cd7 100644 --- a/quic/core/http/quic_spdy_session_test.cc +++ b/quic/core/http/quic_spdy_session_test.cc
@@ -395,12 +395,6 @@ if (perspective == Perspective::IS_SERVER) { id |= 0x1; } - if (bidirectional && perspective == Perspective::IS_CLIENT && - QuicVersionUsesCryptoFrames(transport_version())) { - // Once stream ID 0 is used as a normal client initiated bidirectional - // stream, this shouldn't be needed any more. - id += 4; - } return id; } @@ -1564,7 +1558,7 @@ EXPECT_CALL( *connection_, CloseConnection(QUIC_INVALID_STREAM_ID, - "Stream id 28 would exceed stream count limit 6", _)); + "Stream id 24 would exceed stream count limit 6", _)); } // Create one more data streams to exceed limit of open stream. QuicStreamFrame data1(kFinalStreamId, false, 0, QuicStringPiece("HT"));
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc index 96f98ad..abc6331 100644 --- a/quic/core/quic_session.cc +++ b/quic/core/quic_session.cc
@@ -51,7 +51,7 @@ const ParsedQuicVersionVector& supported_versions) : connection_(connection), visitor_(owner), - write_blocked_streams_(), + write_blocked_streams_(connection->transport_version()), config_(config), stream_id_manager_(this, kDefaultMaxStreamsPerConnection,
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc index deb6643..5af49fa 100644 --- a/quic/core/quic_session_test.cc +++ b/quic/core/quic_session_test.cc
@@ -423,10 +423,6 @@ if (perspective == Perspective::IS_SERVER) { id |= 0x1; } - if (QuicVersionUsesCryptoFrames(connection_->transport_version()) && - bidirectional && perspective == Perspective::IS_CLIENT) { - id += 4; - } return id; } @@ -787,13 +783,16 @@ GetNthClientInitiatedBidirectionalId(49))); // and this should fail because it exceeds the bnidirectional limit // (but not the uni-) + std::string error_detail; + if (QuicVersionUsesCryptoFrames(transport_version())) { + error_detail = "Stream id 796 would exceed stream count limit 50"; + } else { + error_detail = "Stream id 800 would exceed stream count limit 50"; + } EXPECT_CALL( *connection_, - CloseConnection(QUIC_INVALID_STREAM_ID, - "Stream id 800 would exceed stream count limit 50", - ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET - - )) + CloseConnection(QUIC_INVALID_STREAM_ID, error_detail, + ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET)) .Times(1); EXPECT_EQ(nullptr, session_.GetOrCreateDynamicStream( GetNthClientInitiatedBidirectionalId(199))); @@ -1648,7 +1647,7 @@ EXPECT_CALL( *connection_, CloseConnection(QUIC_INVALID_STREAM_ID, - "Stream id 24 would exceed stream count limit 5", _)); + "Stream id 20 would exceed stream count limit 5", _)); } else { EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1); EXPECT_CALL(*connection_, @@ -2385,7 +2384,7 @@ EXPECT_CALL( *connection_, CloseConnection(QUIC_INVALID_STREAM_ID, - "Stream id 404 would exceed stream count limit 100", _)); + "Stream id 400 would exceed stream count limit 100", _)); session_.OnStreamFrame(bidirectional_stream_frame); QuicStreamId unidirectional_stream_id = StreamCountToId(
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc index dc40122..a7fe40f 100644 --- a/quic/core/quic_utils.cc +++ b/quic/core/quic_utils.cc
@@ -399,7 +399,7 @@ // static QuicStreamId QuicUtils::GetHeadersStreamId(QuicTransportVersion version) { - return version == QUIC_VERSION_99 ? 4 : 3; + return GetFirstBidirectionalStreamId(version, Perspective::IS_CLIENT); } // static @@ -461,19 +461,26 @@ QuicStreamId QuicUtils::GetFirstBidirectionalStreamId( QuicTransportVersion version, Perspective perspective) { - if (perspective == Perspective::IS_CLIENT) { - // TODO(nharper): Return 0 instead of 4 when CRYPTO frames are used. - return version == QUIC_VERSION_99 ? 4 : 3; + if (version == QUIC_VERSION_99) { + return perspective == Perspective::IS_CLIENT ? 0 : 1; + } else if (QuicVersionUsesCryptoFrames(version)) { + return perspective == Perspective::IS_CLIENT ? 1 : 2; } - return version == QUIC_VERSION_99 ? 1 : 2; + return perspective == Perspective::IS_CLIENT ? 3 : 2; } // static QuicStreamId QuicUtils::GetFirstUnidirectionalStreamId( QuicTransportVersion version, Perspective perspective) { + if (version == QUIC_VERSION_99) { + return perspective == Perspective::IS_CLIENT ? 2 : 3; + } else if (QuicVersionUsesCryptoFrames(version)) { + return perspective == Perspective::IS_CLIENT ? 1 : 2; + } + return perspective == Perspective::IS_CLIENT ? 3 : 2; if (perspective == Perspective::IS_CLIENT) { - return version == QUIC_VERSION_99 ? 2 : 3; + return version == QUIC_VERSION_99 ? 2 : 1; } return version == QUIC_VERSION_99 ? 3 : 2; }
diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc index e392955..d7fe3c0 100644 --- a/quic/core/quic_write_blocked_list.cc +++ b/quic/core/quic_write_blocked_list.cc
@@ -9,7 +9,11 @@ namespace quic { -QuicWriteBlockedList::QuicWriteBlockedList() : last_priority_popped_(0) { +QuicWriteBlockedList::QuicWriteBlockedList(QuicTransportVersion version) + : priority_write_scheduler_(QuicVersionUsesCryptoFrames(version) + ? std::numeric_limits<QuicStreamId>::max() + : 0), + last_priority_popped_(0) { memset(batch_write_stream_id_, 0, sizeof(batch_write_stream_id_)); memset(bytes_left_for_batch_write_, 0, sizeof(bytes_left_for_batch_write_)); }
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h index 83c2e20..eca7c1a 100644 --- a/quic/core/quic_write_blocked_list.h +++ b/quic/core/quic_write_blocked_list.h
@@ -24,7 +24,7 @@ typedef spdy::PriorityWriteScheduler<QuicStreamId> QuicPriorityWriteScheduler; public: - explicit QuicWriteBlockedList(); + explicit QuicWriteBlockedList(QuicTransportVersion version); QuicWriteBlockedList(const QuicWriteBlockedList&) = delete; QuicWriteBlockedList& operator=(const QuicWriteBlockedList&) = delete; ~QuicWriteBlockedList();
diff --git a/quic/core/quic_write_blocked_list_test.cc b/quic/core/quic_write_blocked_list_test.cc index a9319e3..30bb08e 100644 --- a/quic/core/quic_write_blocked_list_test.cc +++ b/quic/core/quic_write_blocked_list_test.cc
@@ -14,218 +14,214 @@ namespace test { namespace { -class QuicWriteBlockedListTest : public QuicTest {}; +class QuicWriteBlockedListTest : public QuicTest { + public: + QuicWriteBlockedListTest() + : write_blocked_list_(AllSupportedVersions()[0].transport_version) {} + + protected: + QuicWriteBlockedList write_blocked_list_; +}; TEST_F(QuicWriteBlockedListTest, PriorityOrder) { - QuicWriteBlockedList write_blocked_list; - // Mark streams blocked in roughly reverse priority order, and // verify that streams are sorted. - write_blocked_list.RegisterStream(40, false, kV3LowestPriority); - write_blocked_list.RegisterStream(23, false, kV3HighestPriority); - write_blocked_list.RegisterStream(17, false, kV3HighestPriority); - write_blocked_list.RegisterStream(1, true, kV3HighestPriority); - write_blocked_list.RegisterStream(3, true, kV3HighestPriority); + write_blocked_list_.RegisterStream(40, false, kV3LowestPriority); + write_blocked_list_.RegisterStream(23, false, kV3HighestPriority); + write_blocked_list_.RegisterStream(17, false, kV3HighestPriority); + write_blocked_list_.RegisterStream(1, true, kV3HighestPriority); + write_blocked_list_.RegisterStream(3, true, kV3HighestPriority); - write_blocked_list.AddStream(40); - EXPECT_TRUE(write_blocked_list.IsStreamBlocked(40)); - write_blocked_list.AddStream(23); - EXPECT_TRUE(write_blocked_list.IsStreamBlocked(23)); - write_blocked_list.AddStream(17); - EXPECT_TRUE(write_blocked_list.IsStreamBlocked(17)); - write_blocked_list.AddStream(3); - EXPECT_TRUE(write_blocked_list.IsStreamBlocked(3)); - write_blocked_list.AddStream(1); - EXPECT_TRUE(write_blocked_list.IsStreamBlocked(1)); + write_blocked_list_.AddStream(40); + EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(40)); + write_blocked_list_.AddStream(23); + EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(23)); + write_blocked_list_.AddStream(17); + EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(17)); + write_blocked_list_.AddStream(3); + EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(3)); + write_blocked_list_.AddStream(1); + EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(1)); - EXPECT_EQ(5u, write_blocked_list.NumBlockedStreams()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream()); - EXPECT_EQ(2u, write_blocked_list.NumBlockedSpecialStreams()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams()); + EXPECT_EQ(5u, write_blocked_list_.NumBlockedStreams()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream()); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedSpecialStreams()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedDataStreams()); // The Crypto stream is highest priority. - EXPECT_EQ(1u, write_blocked_list.PopFront()); - EXPECT_EQ(1u, write_blocked_list.NumBlockedSpecialStreams()); - EXPECT_FALSE(write_blocked_list.IsStreamBlocked(1)); + EXPECT_EQ(1u, write_blocked_list_.PopFront()); + EXPECT_EQ(1u, write_blocked_list_.NumBlockedSpecialStreams()); + EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(1)); // Followed by the Headers stream. - EXPECT_EQ(3u, write_blocked_list.PopFront()); - EXPECT_EQ(0u, write_blocked_list.NumBlockedSpecialStreams()); - EXPECT_FALSE(write_blocked_list.IsStreamBlocked(3)); + EXPECT_EQ(3u, write_blocked_list_.PopFront()); + EXPECT_EQ(0u, write_blocked_list_.NumBlockedSpecialStreams()); + EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(3)); // Streams with same priority are popped in the order they were inserted. - EXPECT_EQ(23u, write_blocked_list.PopFront()); - EXPECT_FALSE(write_blocked_list.IsStreamBlocked(23)); - EXPECT_EQ(17u, write_blocked_list.PopFront()); - EXPECT_FALSE(write_blocked_list.IsStreamBlocked(17)); + EXPECT_EQ(23u, write_blocked_list_.PopFront()); + EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(23)); + EXPECT_EQ(17u, write_blocked_list_.PopFront()); + EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(17)); // Low priority stream appears last. - EXPECT_EQ(40u, write_blocked_list.PopFront()); - EXPECT_FALSE(write_blocked_list.IsStreamBlocked(40)); + EXPECT_EQ(40u, write_blocked_list_.PopFront()); + EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(40)); - EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams()); + EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams()); } TEST_F(QuicWriteBlockedListTest, CryptoStream) { - QuicWriteBlockedList write_blocked_list; - write_blocked_list.RegisterStream(1, true, kV3HighestPriority); - write_blocked_list.AddStream(1); + write_blocked_list_.RegisterStream(1, true, kV3HighestPriority); + write_blocked_list_.AddStream(1); - EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream()); - EXPECT_EQ(1u, write_blocked_list.PopFront()); - EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream()); + EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream()); + EXPECT_EQ(1u, write_blocked_list_.PopFront()); + EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream()); } TEST_F(QuicWriteBlockedListTest, HeadersStream) { - QuicWriteBlockedList write_blocked_list; - write_blocked_list.RegisterStream(3, true, kV3HighestPriority); - write_blocked_list.AddStream(3); + write_blocked_list_.RegisterStream(3, true, kV3HighestPriority); + write_blocked_list_.AddStream(3); - EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream()); - EXPECT_EQ(3u, write_blocked_list.PopFront()); - EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream()); + EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream()); + EXPECT_EQ(3u, write_blocked_list_.PopFront()); + EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream()); } TEST_F(QuicWriteBlockedListTest, VerifyHeadersStream) { - QuicWriteBlockedList write_blocked_list; - write_blocked_list.RegisterStream(5, false, kV3HighestPriority); - write_blocked_list.RegisterStream(3, true, kV3HighestPriority); - write_blocked_list.AddStream(5); - write_blocked_list.AddStream(3); + write_blocked_list_.RegisterStream(5, false, kV3HighestPriority); + write_blocked_list_.RegisterStream(3, true, kV3HighestPriority); + write_blocked_list_.AddStream(5); + write_blocked_list_.AddStream(3); - EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams()); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedDataStreams()); // In newer QUIC versions, there is a headers stream which is // higher priority than data streams. - EXPECT_EQ(3u, write_blocked_list.PopFront()); - EXPECT_EQ(5u, write_blocked_list.PopFront()); - EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams()); + EXPECT_EQ(3u, write_blocked_list_.PopFront()); + EXPECT_EQ(5u, write_blocked_list_.PopFront()); + EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams()); } TEST_F(QuicWriteBlockedListTest, NoDuplicateEntries) { // Test that QuicWriteBlockedList doesn't allow duplicate entries. - QuicWriteBlockedList write_blocked_list; - // Try to add a stream to the write blocked list multiple times at the same // priority. const QuicStreamId kBlockedId = 3 + 2; - write_blocked_list.RegisterStream(kBlockedId, false, kV3HighestPriority); - write_blocked_list.AddStream(kBlockedId); - write_blocked_list.AddStream(kBlockedId); - write_blocked_list.AddStream(kBlockedId); + write_blocked_list_.RegisterStream(kBlockedId, false, kV3HighestPriority); + write_blocked_list_.AddStream(kBlockedId); + write_blocked_list_.AddStream(kBlockedId); + write_blocked_list_.AddStream(kBlockedId); // This should only result in one blocked stream being added. - EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams()); - EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams()); + EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams()); + EXPECT_TRUE(write_blocked_list_.HasWriteBlockedDataStreams()); // There should only be one stream to pop off the front. - EXPECT_EQ(kBlockedId, write_blocked_list.PopFront()); - EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams()); - EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams()); + EXPECT_EQ(kBlockedId, write_blocked_list_.PopFront()); + EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams()); + EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams()); } TEST_F(QuicWriteBlockedListTest, BatchingWrites) { - QuicWriteBlockedList write_blocked_list; - const QuicStreamId id1 = 3 + 2; const QuicStreamId id2 = id1 + 2; const QuicStreamId id3 = id2 + 2; - write_blocked_list.RegisterStream(id1, false, kV3LowestPriority); - write_blocked_list.RegisterStream(id2, false, kV3LowestPriority); - write_blocked_list.RegisterStream(id3, false, kV3HighestPriority); + write_blocked_list_.RegisterStream(id1, false, kV3LowestPriority); + write_blocked_list_.RegisterStream(id2, false, kV3LowestPriority); + write_blocked_list_.RegisterStream(id3, false, kV3HighestPriority); - write_blocked_list.AddStream(id1); - write_blocked_list.AddStream(id2); - EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams()); + write_blocked_list_.AddStream(id1); + write_blocked_list_.AddStream(id2); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams()); // The first stream we push back should stay at the front until 16k is // written. - EXPECT_EQ(id1, write_blocked_list.PopFront()); - write_blocked_list.UpdateBytesForStream(id1, 15999); - write_blocked_list.AddStream(id1); - EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams()); - EXPECT_EQ(id1, write_blocked_list.PopFront()); + EXPECT_EQ(id1, write_blocked_list_.PopFront()); + write_blocked_list_.UpdateBytesForStream(id1, 15999); + write_blocked_list_.AddStream(id1); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams()); + EXPECT_EQ(id1, write_blocked_list_.PopFront()); // Once 16k is written the first stream will yield to the next. - write_blocked_list.UpdateBytesForStream(id1, 1); - write_blocked_list.AddStream(id1); - EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams()); - EXPECT_EQ(id2, write_blocked_list.PopFront()); + write_blocked_list_.UpdateBytesForStream(id1, 1); + write_blocked_list_.AddStream(id1); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams()); + EXPECT_EQ(id2, write_blocked_list_.PopFront()); // Set the new stream to have written all but one byte. - write_blocked_list.UpdateBytesForStream(id2, 15999); - write_blocked_list.AddStream(id2); - EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams()); + write_blocked_list_.UpdateBytesForStream(id2, 15999); + write_blocked_list_.AddStream(id2); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams()); // Ensure higher priority streams are popped first. - write_blocked_list.AddStream(id3); - EXPECT_EQ(id3, write_blocked_list.PopFront()); + write_blocked_list_.AddStream(id3); + EXPECT_EQ(id3, write_blocked_list_.PopFront()); // Higher priority streams will always be popped first, even if using their // byte quota - write_blocked_list.UpdateBytesForStream(id3, 20000); - write_blocked_list.AddStream(id3); - EXPECT_EQ(id3, write_blocked_list.PopFront()); + write_blocked_list_.UpdateBytesForStream(id3, 20000); + write_blocked_list_.AddStream(id3); + EXPECT_EQ(id3, write_blocked_list_.PopFront()); // Once the higher priority stream is out of the way, id2 will resume its 16k // write, with only 1 byte remaining of its guaranteed write allocation. - EXPECT_EQ(id2, write_blocked_list.PopFront()); - write_blocked_list.UpdateBytesForStream(id2, 1); - write_blocked_list.AddStream(id2); - EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams()); - EXPECT_EQ(id1, write_blocked_list.PopFront()); + EXPECT_EQ(id2, write_blocked_list_.PopFront()); + write_blocked_list_.UpdateBytesForStream(id2, 1); + write_blocked_list_.AddStream(id2); + EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams()); + EXPECT_EQ(id1, write_blocked_list_.PopFront()); } TEST_F(QuicWriteBlockedListTest, Ceding) { - QuicWriteBlockedList write_blocked_list; - - write_blocked_list.RegisterStream(15, false, kV3HighestPriority); - write_blocked_list.RegisterStream(16, false, kV3HighestPriority); - write_blocked_list.RegisterStream(5, false, 5); - write_blocked_list.RegisterStream(4, false, 5); - write_blocked_list.RegisterStream(7, false, 7); - write_blocked_list.RegisterStream(1, true, kV3HighestPriority); - write_blocked_list.RegisterStream(3, true, kV3HighestPriority); + write_blocked_list_.RegisterStream(15, false, kV3HighestPriority); + write_blocked_list_.RegisterStream(16, false, kV3HighestPriority); + write_blocked_list_.RegisterStream(5, false, 5); + write_blocked_list_.RegisterStream(4, false, 5); + write_blocked_list_.RegisterStream(7, false, 7); + write_blocked_list_.RegisterStream(1, true, kV3HighestPriority); + write_blocked_list_.RegisterStream(3, true, kV3HighestPriority); // When nothing is on the list, nothing yields. - EXPECT_FALSE(write_blocked_list.ShouldYield(5)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(5)); - write_blocked_list.AddStream(5); + write_blocked_list_.AddStream(5); // 5 should not yield to itself. - EXPECT_FALSE(write_blocked_list.ShouldYield(5)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(5)); // 4 and 7 are equal or lower priority and should yield to 5. - EXPECT_TRUE(write_blocked_list.ShouldYield(4)); - EXPECT_TRUE(write_blocked_list.ShouldYield(7)); + EXPECT_TRUE(write_blocked_list_.ShouldYield(4)); + EXPECT_TRUE(write_blocked_list_.ShouldYield(7)); // 15, headers and crypto should preempt 5. - EXPECT_FALSE(write_blocked_list.ShouldYield(15)); - EXPECT_FALSE(write_blocked_list.ShouldYield(3)); - EXPECT_FALSE(write_blocked_list.ShouldYield(1)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(15)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(3)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(1)); // Block a high priority stream. - write_blocked_list.AddStream(15); + write_blocked_list_.AddStream(15); // 16 should yield (same priority) but headers and crypto will still not. - EXPECT_TRUE(write_blocked_list.ShouldYield(16)); - EXPECT_FALSE(write_blocked_list.ShouldYield(3)); - EXPECT_FALSE(write_blocked_list.ShouldYield(1)); + EXPECT_TRUE(write_blocked_list_.ShouldYield(16)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(3)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(1)); // Block the headers stream. All streams but crypto and headers should yield. - write_blocked_list.AddStream(3); - EXPECT_TRUE(write_blocked_list.ShouldYield(16)); - EXPECT_TRUE(write_blocked_list.ShouldYield(15)); - EXPECT_FALSE(write_blocked_list.ShouldYield(3)); - EXPECT_FALSE(write_blocked_list.ShouldYield(1)); + write_blocked_list_.AddStream(3); + EXPECT_TRUE(write_blocked_list_.ShouldYield(16)); + EXPECT_TRUE(write_blocked_list_.ShouldYield(15)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(3)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(1)); // Block the crypto stream. All streams but crypto should yield. - write_blocked_list.AddStream(1); - EXPECT_TRUE(write_blocked_list.ShouldYield(16)); - EXPECT_TRUE(write_blocked_list.ShouldYield(15)); - EXPECT_TRUE(write_blocked_list.ShouldYield(3)); - EXPECT_FALSE(write_blocked_list.ShouldYield(1)); + write_blocked_list_.AddStream(1); + EXPECT_TRUE(write_blocked_list_.ShouldYield(16)); + EXPECT_TRUE(write_blocked_list_.ShouldYield(15)); + EXPECT_TRUE(write_blocked_list_.ShouldYield(3)); + EXPECT_FALSE(write_blocked_list_.ShouldYield(1)); } } // namespace
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc index b9420bf..8b1bace 100644 --- a/quic/core/uber_quic_stream_id_manager_test.cc +++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -282,7 +282,7 @@ std::string error_details = GetParam() == Perspective::IS_SERVER - ? "Stream id 404 would exceed stream count limit 100" + ? "Stream id 400 would exceed stream count limit 100" : "Stream id 401 would exceed stream count limit 100"; EXPECT_CALL(*connection_,