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_,
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index ed7043d..9eee494 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -181,19 +181,16 @@
// static
bool QuicSessionPeer::IsStreamClosed(QuicSession* session, QuicStreamId id) {
- DCHECK_NE(0u, id);
return session->IsClosedStream(id);
}
// static
bool QuicSessionPeer::IsStreamCreated(QuicSession* session, QuicStreamId id) {
- DCHECK_NE(0u, id);
return QuicContainsKey(session->dynamic_streams(), id);
}
// static
bool QuicSessionPeer::IsStreamAvailable(QuicSession* session, QuicStreamId id) {
- DCHECK_NE(0u, id);
if (session->connection()->transport_version() == QUIC_VERSION_99) {
if (id % QuicUtils::StreamIdDelta(QUIC_VERSION_99) < 2) {
return QuicContainsKey(
