Deprecate gfe2_reloadable_flag_quic_deprecate_http2_priority_experiment.
PiperOrigin-RevId: 354306841
Change-Id: I5ba23aaa35b5a375c5028d33f6baf4df01a4fd12
diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index 4704c4c..99f5372 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -28,7 +28,7 @@
// The following tags have been deprecated and should not be reused:
// "1CON", "BBQ4", "NCON", "RCID", "SREJ", "TBKP", "TB10", "SCLS", "SMHL",
-// "QNZR", "B2HI"
+// "QNZR", "B2HI", "H2PR", "FIFO", "LIFO", "RRWS"
// clang-format off
const QuicTag kCHLO = TAG('C', 'H', 'L', 'O'); // Client hello
@@ -337,14 +337,6 @@
const QuicTag kMTUH = TAG('M', 'T', 'U', 'H'); // High-target MTU discovery.
const QuicTag kMTUL = TAG('M', 'T', 'U', 'L'); // Low-target MTU discovery.
-// Enable Priority scheme experiment.
-const QuicTag kH2PR = TAG('H', '2', 'P', 'R'); // HTTP2 priorities.
-const QuicTag kFIFO = TAG('F', 'I', 'F', 'O'); // Stream with the smallest ID
- // has the highest priority.
-const QuicTag kLIFO = TAG('L', 'I', 'F', 'O'); // Stream with the largest ID
- // has the highest priority.
-const QuicTag kRRWS = TAG('R', 'R', 'W', 'S'); // Round robin write scheduling.
-
const QuicTag kNSLC = TAG('N', 'S', 'L', 'C'); // Always send connection close
// for idle timeout.
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index e35d622..8026ac2 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -324,8 +324,8 @@
void OnHeaders(SpdyStreamId stream_id,
bool has_priority,
int weight,
- SpdyStreamId parent_stream_id,
- bool exclusive,
+ SpdyStreamId /* parent_stream_id */,
+ bool /* exclusive */,
bool fin,
bool /*end*/) override {
if (!session_->IsConnected()) {
@@ -342,13 +342,6 @@
<< "QuicSpdyStream use after free. "
<< session_->destruction_indicator() << QuicStackTrace();
- if (session_->use_http2_priority_write_scheduler()) {
- session_->OnHeaders(
- stream_id, has_priority,
- spdy::SpdyStreamPrecedence(parent_stream_id, weight, exclusive), fin);
- return;
- }
-
SpdyPriority priority =
has_priority ? Http2WeightToSpdy3Priority(weight) : 0;
session_->OnHeaders(stream_id, has_priority,
@@ -379,18 +372,13 @@
void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
void OnPriority(SpdyStreamId stream_id,
- SpdyStreamId parent_id,
+ SpdyStreamId /* parent_id */,
int weight,
- bool exclusive) override {
+ bool /* exclusive */) override {
DCHECK(!VersionUsesHttp3(session_->transport_version()));
if (!session_->IsConnected()) {
return;
}
- if (session_->use_http2_priority_write_scheduler()) {
- session_->OnPriority(
- stream_id, spdy::SpdyStreamPrecedence(parent_id, weight, exclusive));
- return;
- }
SpdyPriority priority = Http2WeightToSpdy3Priority(weight);
session_->OnPriority(stream_id, spdy::SpdyStreamPrecedence(priority));
}
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 53b4e40..b30410b 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -28,7 +28,6 @@
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr_v2, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_delay_initial_ack, true)
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_deprecate_http2_priority_experiment, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_server_blackhole_detection, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_draft_29, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q043, false)
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index a50d7a6..5c308f0 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -111,9 +111,7 @@
datagram_queue_(this, std::move(datagram_observer)),
closed_streams_clean_up_alarm_(nullptr),
supported_versions_(supported_versions),
- use_http2_priority_write_scheduler_(false),
is_configured_(false),
- enable_round_robin_scheduling_(false),
was_zero_rtt_rejected_(false),
liveness_testing_in_progress_(false) {
closed_streams_clean_up_alarm_ =
@@ -613,9 +611,7 @@
<< ", finished_writes: " << i
<< ", connected: " << connection_->connected()
<< ", connection level flow control blocked: "
- << flow_controller_.IsBlocked() << ", scheduler type: "
- << spdy::WriteSchedulerTypeToString(
- write_blocked_streams_.scheduler_type());
+ << flow_controller_.IsBlocked();
for (QuicStreamId id : last_writing_stream_ids) {
QUIC_LOG(WARNING) << "last_writing_stream_id: " << id;
}
@@ -1271,32 +1267,6 @@
if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFWA)) {
AdjustInitialFlowControlWindows(1024 * 1024);
}
- if (GetQuicReloadableFlag(quic_deprecate_http2_priority_experiment)) {
- QUIC_CODE_COUNT(quic_deprecate_http2_priority_experiment);
- } else {
- if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kH2PR) &&
- !VersionHasIetfQuicFrames(transport_version())) {
- // Enable HTTP2 (tree-style) priority write scheduler.
- use_http2_priority_write_scheduler_ =
- write_blocked_streams_.SwitchWriteScheduler(
- spdy::WriteSchedulerType::HTTP2, transport_version());
- } else if (ContainsQuicTag(config_.ReceivedConnectionOptions(),
- kFIFO)) {
- // Enable FIFO write scheduler.
- write_blocked_streams_.SwitchWriteScheduler(
- spdy::WriteSchedulerType::FIFO, transport_version());
- } else if (ContainsQuicTag(config_.ReceivedConnectionOptions(),
- kLIFO)) {
- // Enable LIFO write scheduler.
- write_blocked_streams_.SwitchWriteScheduler(
- spdy::WriteSchedulerType::LIFO, transport_version());
- } else if (ContainsQuicTag(config_.ReceivedConnectionOptions(),
- kRRWS) &&
- write_blocked_streams_.scheduler_type() ==
- spdy::WriteSchedulerType::SPDY) {
- enable_round_robin_scheduling_ = true;
- }
- }
}
config_.SetStatelessResetTokenToSend(GetStatelessResetToken());
@@ -1807,13 +1777,6 @@
QuicStreamId id,
bool is_static,
const spdy::SpdyStreamPrecedence& precedence) {
- if (enable_round_robin_scheduling_) {
- // Ignore provided precedence, instead, put all streams at the same priority
- // bucket.
- write_blocked_streams()->RegisterStream(
- id, is_static, spdy::SpdyStreamPrecedence(spdy::kV3LowestPriority));
- return;
- }
write_blocked_streams()->RegisterStream(id, is_static, precedence);
}
@@ -1824,10 +1787,6 @@
void QuicSession::UpdateStreamPriority(
QuicStreamId id,
const spdy::SpdyStreamPrecedence& new_precedence) {
- if (enable_round_robin_scheduling_) {
- // Ignore updated precedence.
- return;
- }
write_blocked_streams()->UpdateStreamPriority(id, new_precedence);
}
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 2101c28..b995c5d 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -543,10 +543,6 @@
inline ParsedQuicVersion version() const { return connection_->version(); }
- bool use_http2_priority_write_scheduler() const {
- return use_http2_priority_write_scheduler_;
- }
-
bool is_configured() const { return is_configured_; }
// Called to neuter crypto data of encryption |level|.
@@ -941,17 +937,10 @@
absl::optional<std::string> user_agent_id_;
- // If true, write_blocked_streams_ uses HTTP2 (tree-style) priority write
- // scheduler.
- bool use_http2_priority_write_scheduler_;
-
// Initialized to false. Set to true when the session has been properly
// configured and is ready for general operation.
bool is_configured_;
- // If true, enables round robin scheduling.
- bool enable_round_robin_scheduling_;
-
// Whether the session has received a 0-RTT rejection (QUIC+TLS only).
bool was_zero_rtt_rejected_;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 3288047..7c5d9bb 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -1045,142 +1045,6 @@
session_.OnCanWrite();
}
-TEST_P(QuicSessionTestServer, Http2Priority) {
- if (GetQuicReloadableFlag(quic_deprecate_http2_priority_experiment)) {
- return;
- }
-
- if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
- // The test is using HTTP/2 priority which is not supported in IETF QUIC.
- return;
- }
- QuicTagVector copt;
- copt.push_back(kH2PR);
- QuicConfigPeer::SetReceivedConnectionOptions(session_.config(), copt);
- connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
- session_.OnConfigNegotiated();
- ASSERT_TRUE(session_.use_http2_priority_write_scheduler());
-
- session_.set_writev_consumes_all_data(true);
- TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
- TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
- TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
-
- session_.set_writev_consumes_all_data(true);
- /*
- 0
- /|\
- 2 4 6
- */
- session_.MarkConnectionLevelWriteBlocked(stream2->id());
- session_.MarkConnectionLevelWriteBlocked(stream4->id());
- session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
- // Verify streams are scheduled round robin.
- InSequence s;
- EXPECT_CALL(*stream2, OnCanWrite());
- EXPECT_CALL(*stream4, OnCanWrite());
- EXPECT_CALL(*stream6, OnCanWrite());
- session_.OnCanWrite();
-
- /*
- 0
- |
- 4
- / \
- 2 6
- */
- // Update stream 4's priority.
- stream4->SetPriority(
- spdy::SpdyStreamPrecedence(0, spdy::kHttp2DefaultStreamWeight, true));
- session_.MarkConnectionLevelWriteBlocked(stream2->id());
- session_.MarkConnectionLevelWriteBlocked(stream4->id());
- session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
- EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
- session_.MarkConnectionLevelWriteBlocked(stream4->id());
- }));
- EXPECT_CALL(*stream4, OnCanWrite());
- EXPECT_CALL(*stream2, OnCanWrite());
- session_.OnCanWrite();
- EXPECT_CALL(*stream6, OnCanWrite());
- session_.OnCanWrite();
-
- /*
- 0
- |
- 6
- |
- 4
- |
- 2
- */
- // Update stream 6's priority.
- stream6->SetPriority(
- spdy::SpdyStreamPrecedence(0, spdy::kHttp2DefaultStreamWeight, true));
- session_.MarkConnectionLevelWriteBlocked(stream2->id());
- session_.MarkConnectionLevelWriteBlocked(stream4->id());
- session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
- EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(Invoke([this, stream6]() {
- session_.MarkConnectionLevelWriteBlocked(stream6->id());
- }));
- EXPECT_CALL(*stream6, OnCanWrite());
- EXPECT_CALL(*stream4, OnCanWrite());
- session_.OnCanWrite();
- EXPECT_CALL(*stream2, OnCanWrite());
- session_.OnCanWrite();
-}
-
-TEST_P(QuicSessionTestServer, RoundRobinScheduling) {
- if (GetQuicReloadableFlag(quic_deprecate_http2_priority_experiment)) {
- return;
- }
-
- if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
- // IETF QUIC currently doesn't support PRIORITY.
- return;
- }
- QuicTagVector copt;
- copt.push_back(kRRWS);
- QuicConfigPeer::SetReceivedConnectionOptions(session_.config(), copt);
- connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
- session_.OnConfigNegotiated();
-
- session_.set_writev_consumes_all_data(true);
- TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
- TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
- TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
-
- session_.set_writev_consumes_all_data(true);
- session_.MarkConnectionLevelWriteBlocked(stream2->id());
- session_.MarkConnectionLevelWriteBlocked(stream4->id());
- session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
- // Verify streams are scheduled round robin.
- InSequence s;
- EXPECT_CALL(*stream2, OnCanWrite());
- EXPECT_CALL(*stream4, OnCanWrite());
- EXPECT_CALL(*stream6, OnCanWrite());
- session_.OnCanWrite();
-
- /* 2, 4, 6, 8 */
- TestStream* stream8 = session_.CreateOutgoingBidirectionalStream();
-
- // Verify updated priority is ignored.
- stream4->SetPriority(spdy::SpdyStreamPrecedence(spdy::kV3HighestPriority));
- session_.MarkConnectionLevelWriteBlocked(stream8->id());
- session_.MarkConnectionLevelWriteBlocked(stream4->id());
- session_.MarkConnectionLevelWriteBlocked(stream2->id());
- session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
- EXPECT_CALL(*stream8, OnCanWrite());
- EXPECT_CALL(*stream4, OnCanWrite());
- EXPECT_CALL(*stream2, OnCanWrite());
- EXPECT_CALL(*stream6, OnCanWrite());
- session_.OnCanWrite();
-}
-
TEST_P(QuicSessionTestServer, OnCanWriteBundlesStreams) {
// Encryption needs to be established before data can be sent.
CompleteHandshake();
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 5aa7150..b5cdd31 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -1458,16 +1458,10 @@
// static
spdy::SpdyStreamPrecedence QuicStream::CalculateDefaultPriority(
const QuicSession* session) {
- if (VersionUsesHttp3(session->transport_version())) {
- return spdy::SpdyStreamPrecedence(kDefaultUrgency);
- }
-
- if (session->use_http2_priority_write_scheduler()) {
- return spdy::SpdyStreamPrecedence(0, spdy::kHttp2DefaultStreamWeight,
- false);
- }
-
- return spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority);
+ return spdy::SpdyStreamPrecedence(
+ VersionUsesHttp3(session->transport_version())
+ ? kDefaultUrgency
+ : QuicStream::kDefaultPriority);
}
} // namespace quic
diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc
index 21e4fde..02b72e3 100644
--- a/quic/core/quic_write_blocked_list.cc
+++ b/quic/core/quic_write_blocked_list.cc
@@ -10,13 +10,10 @@
namespace quic {
QuicWriteBlockedList::QuicWriteBlockedList(QuicTransportVersion version)
- : priority_write_scheduler_(
- std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
- QuicVersionUsesCryptoFrames(version)
- ? std::numeric_limits<QuicStreamId>::max()
- : 0)),
- last_priority_popped_(0),
- scheduler_type_(spdy::WriteSchedulerType::SPDY) {
+ : 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_));
}
@@ -35,47 +32,7 @@
}
}
- return priority_write_scheduler_->ShouldYield(id);
-}
-
-bool QuicWriteBlockedList::SwitchWriteScheduler(spdy::WriteSchedulerType type,
- QuicTransportVersion version) {
- if (scheduler_type_ == type) {
- return true;
- }
- if (priority_write_scheduler_->NumRegisteredStreams() != 0) {
- QUIC_BUG << "Cannot switch scheduler with registered streams";
- return false;
- }
- QUIC_DVLOG(1) << "Switching to scheduler type: "
- << spdy::WriteSchedulerTypeToString(type);
- switch (type) {
- case spdy::WriteSchedulerType::LIFO:
- priority_write_scheduler_ =
- std::make_unique<spdy::LifoWriteScheduler<QuicStreamId>>();
- break;
- case spdy::WriteSchedulerType::SPDY:
- priority_write_scheduler_ =
- std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
- QuicVersionUsesCryptoFrames(version)
- ? std::numeric_limits<QuicStreamId>::max()
- : 0);
- break;
- case spdy::WriteSchedulerType::HTTP2:
- priority_write_scheduler_ =
- std::make_unique<spdy::Http2PriorityWriteScheduler<QuicStreamId>>();
- break;
- case spdy::WriteSchedulerType::FIFO:
- priority_write_scheduler_ =
- std::make_unique<spdy::FifoWriteScheduler<QuicStreamId>>();
- break;
- default:
- QUIC_BUG << "Scheduler is not supported for type: "
- << spdy::WriteSchedulerTypeToString(type);
- return false;
- }
- scheduler_type_ = type;
- return true;
+ return priority_write_scheduler_.ShouldYield(id);
}
QuicStreamId QuicWriteBlockedList::PopFront() {
@@ -85,16 +42,12 @@
}
const auto id_and_precedence =
- priority_write_scheduler_->PopNextReadyStreamAndPrecedence();
+ priority_write_scheduler_.PopNextReadyStreamAndPrecedence();
const QuicStreamId id = std::get<0>(id_and_precedence);
- if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
- // No batch writing logic for non-SPDY priority write scheduler.
- return id;
- }
const spdy::SpdyPriority priority =
std::get<1>(id_and_precedence).spdy3_priority();
- if (!priority_write_scheduler_->HasReadyStreams()) {
+ if (!priority_write_scheduler_.HasReadyStreams()) {
// If no streams are blocked, don't bother latching. This stream will be
// the first popped for its priority anyway.
batch_write_stream_id_[priority] = 0;
@@ -113,15 +66,15 @@
QuicStreamId stream_id,
bool is_static_stream,
const spdy::SpdyStreamPrecedence& precedence) {
- DCHECK(!priority_write_scheduler_->StreamRegistered(stream_id))
+ DCHECK(!priority_write_scheduler_.StreamRegistered(stream_id))
<< "stream " << stream_id << " already registered";
- DCHECK(PrecedenceMatchesSchedulerType(precedence));
+ DCHECK(precedence.is_spdy3_priority());
if (is_static_stream) {
static_stream_collection_.Register(stream_id);
return;
}
- priority_write_scheduler_->RegisterStream(stream_id, precedence);
+ priority_write_scheduler_.RegisterStream(stream_id, precedence);
}
void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id,
@@ -130,22 +83,19 @@
static_stream_collection_.Unregister(stream_id);
return;
}
- priority_write_scheduler_->UnregisterStream(stream_id);
+ priority_write_scheduler_.UnregisterStream(stream_id);
}
void QuicWriteBlockedList::UpdateStreamPriority(
QuicStreamId stream_id,
const spdy::SpdyStreamPrecedence& new_precedence) {
DCHECK(!static_stream_collection_.IsRegistered(stream_id));
- DCHECK(PrecedenceMatchesSchedulerType(new_precedence));
- priority_write_scheduler_->UpdateStreamPrecedence(stream_id, new_precedence);
+ DCHECK(new_precedence.is_spdy3_priority());
+ priority_write_scheduler_.UpdateStreamPrecedence(stream_id, new_precedence);
}
void QuicWriteBlockedList::UpdateBytesForStream(QuicStreamId stream_id,
size_t bytes) {
- if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
- return;
- }
if (batch_write_stream_id_[last_priority_popped_] == stream_id) {
// If this was the last data stream popped by PopFront, update the
// bytes remaining in its batch write.
@@ -160,10 +110,9 @@
}
bool push_front =
- scheduler_type_ == spdy::WriteSchedulerType::SPDY &&
stream_id == batch_write_stream_id_[last_priority_popped_] &&
bytes_left_for_batch_write_[last_priority_popped_] > 0;
- priority_write_scheduler_->MarkStreamReady(stream_id, push_front);
+ priority_write_scheduler_.MarkStreamReady(stream_id, push_front);
}
bool QuicWriteBlockedList::IsStreamBlocked(QuicStreamId stream_id) const {
@@ -173,25 +122,7 @@
}
}
- return priority_write_scheduler_->IsStreamReady(stream_id);
-}
-
-bool QuicWriteBlockedList::PrecedenceMatchesSchedulerType(
- const spdy::SpdyStreamPrecedence& precedence) {
- switch (scheduler_type_) {
- case spdy::WriteSchedulerType::LIFO:
- break;
- case spdy::WriteSchedulerType::SPDY:
- return precedence.is_spdy3_priority();
- case spdy::WriteSchedulerType::HTTP2:
- return !precedence.is_spdy3_priority();
- case spdy::WriteSchedulerType::FIFO:
- break;
- default:
- DCHECK(false);
- return false;
- }
- return true;
+ return priority_write_scheduler_.IsStreamReady(stream_id);
}
void QuicWriteBlockedList::StaticStreamCollection::Register(QuicStreamId id) {
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index 7b5f29f..2d87847 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -26,9 +26,6 @@
// priority. QUIC stream priority order is:
// Crypto stream > Headers stream > Data streams by requested priority.
class QUIC_EXPORT_PRIVATE QuicWriteBlockedList {
- private:
- using QuicPriorityWriteScheduler = spdy::WriteScheduler<QuicStreamId>;
-
public:
explicit QuicWriteBlockedList(QuicTransportVersion version);
QuicWriteBlockedList(const QuicWriteBlockedList&) = delete;
@@ -36,7 +33,7 @@
~QuicWriteBlockedList();
bool HasWriteBlockedDataStreams() const {
- return priority_write_scheduler_->HasReadyStreams();
+ return priority_write_scheduler_.HasReadyStreams();
}
bool HasWriteBlockedSpecialStream() const {
@@ -49,20 +46,15 @@
size_t NumBlockedStreams() const {
return NumBlockedSpecialStreams() +
- priority_write_scheduler_->NumReadyStreams();
+ priority_write_scheduler_.NumReadyStreams();
}
bool ShouldYield(QuicStreamId id) const;
spdy::SpdyPriority GetSpdyPriorityofStream(QuicStreamId id) const {
- return priority_write_scheduler_->GetStreamPrecedence(id).spdy3_priority();
+ return priority_write_scheduler_.GetStreamPrecedence(id).spdy3_priority();
}
- // Switches write scheduler. This can only be called before any stream is
- // registered.
- bool SwitchWriteScheduler(spdy::WriteSchedulerType type,
- QuicTransportVersion version);
-
// Pops the highest priority stream, special casing crypto and headers
// streams. Latches the most recently popped data stream for batch writing
// purposes.
@@ -88,13 +80,8 @@
// Returns true if stream with |stream_id| is write blocked.
bool IsStreamBlocked(QuicStreamId stream_id) const;
- spdy::WriteSchedulerType scheduler_type() const { return scheduler_type_; }
-
private:
- bool PrecedenceMatchesSchedulerType(
- const spdy::SpdyStreamPrecedence& precedence);
-
- std::unique_ptr<QuicPriorityWriteScheduler> priority_write_scheduler_;
+ spdy::PriorityWriteScheduler<QuicStreamId> priority_write_scheduler_;
// If performing batch writes, this will be the stream ID of the stream doing
// batch writes for this priority level. We will allow this stream to write
@@ -152,8 +139,6 @@
};
StaticStreamCollection static_stream_collection_;
-
- spdy::WriteSchedulerType scheduler_type_;
};
} // namespace quic
diff --git a/quic/core/quic_write_blocked_list_test.cc b/quic/core/quic_write_blocked_list_test.cc
index 9ce822d..7cf7797 100644
--- a/quic/core/quic_write_blocked_list_test.cc
+++ b/quic/core/quic_write_blocked_list_test.cc
@@ -15,73 +15,37 @@
namespace test {
namespace {
-const bool kExclusiveBit = true;
-
class QuicWriteBlockedListTest : public QuicTestWithParam<bool> {
public:
QuicWriteBlockedListTest()
- : write_blocked_list_(AllSupportedVersions()[0].transport_version) {
- if (GetParam()) {
- write_blocked_list_.SwitchWriteScheduler(
- spdy::WriteSchedulerType::HTTP2,
- AllSupportedVersions()[0].transport_version);
- }
- }
+ : write_blocked_list_(AllSupportedVersions()[0].transport_version) {}
protected:
QuicWriteBlockedList write_blocked_list_;
};
-INSTANTIATE_TEST_SUITE_P(Tests,
- QuicWriteBlockedListTest,
- ::testing::Bool(),
- ::testing::PrintToStringParamName());
-
-TEST_P(QuicWriteBlockedListTest, PriorityOrder) {
- if (GetParam()) {
- /*
- 0
- |
- 23
- |
- 17
- |
- 40
- */
- write_blocked_list_.RegisterStream(
- 17, false,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 40, false,
- spdy::SpdyStreamPrecedence(17, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 23, false,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 1, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 3, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
- // Mark streams blocked in roughly reverse priority order, and
- // verify that streams are sorted.
- write_blocked_list_.RegisterStream(
- 40, false, spdy::SpdyStreamPrecedence(kV3LowestPriority));
- write_blocked_list_.RegisterStream(
- 23, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(
- 17, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(
- 1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(
- 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- }
+TEST_F(QuicWriteBlockedListTest, PriorityOrder) {
+ /*
+ 0
+ |
+ 23
+ |
+ 17
+ |
+ 40
+ */
+ // Mark streams blocked in roughly reverse priority order, and
+ // verify that streams are sorted.
+ write_blocked_list_.RegisterStream(
+ 40, false, spdy::SpdyStreamPrecedence(kV3LowestPriority));
+ write_blocked_list_.RegisterStream(
+ 23, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(
+ 17, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(
+ 1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(
+ 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
write_blocked_list_.AddStream(40);
EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(40));
@@ -120,16 +84,9 @@
EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
}
-TEST_P(QuicWriteBlockedListTest, CryptoStream) {
- if (GetParam()) {
- write_blocked_list_.RegisterStream(
- 1, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
- write_blocked_list_.RegisterStream(
- 1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- }
+TEST_F(QuicWriteBlockedListTest, CryptoStream) {
+ write_blocked_list_.RegisterStream(
+ 1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
write_blocked_list_.AddStream(1);
EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
@@ -139,16 +96,9 @@
EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
}
-TEST_P(QuicWriteBlockedListTest, HeadersStream) {
- if (GetParam()) {
- write_blocked_list_.RegisterStream(
- 3, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
- write_blocked_list_.RegisterStream(
- 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- }
+TEST_F(QuicWriteBlockedListTest, HeadersStream) {
+ write_blocked_list_.RegisterStream(
+ 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
write_blocked_list_.AddStream(3);
EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
@@ -158,22 +108,11 @@
EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
}
-TEST_P(QuicWriteBlockedListTest, VerifyHeadersStream) {
- if (GetParam()) {
- write_blocked_list_.RegisterStream(
- 5, false,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 3, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
- write_blocked_list_.RegisterStream(
- 5, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(
- 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- }
+TEST_F(QuicWriteBlockedListTest, VerifyHeadersStream) {
+ write_blocked_list_.RegisterStream(
+ 5, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(
+ 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
write_blocked_list_.AddStream(5);
write_blocked_list_.AddStream(3);
@@ -189,20 +128,13 @@
EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
}
-TEST_P(QuicWriteBlockedListTest, NoDuplicateEntries) {
+TEST_F(QuicWriteBlockedListTest, NoDuplicateEntries) {
// Test that QuicWriteBlockedList doesn't allow duplicate entries.
// Try to add a stream to the write blocked list multiple times at the same
// priority.
const QuicStreamId kBlockedId = 3 + 2;
- if (GetParam()) {
- write_blocked_list_.RegisterStream(
- kBlockedId, false,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
write_blocked_list_.RegisterStream(
kBlockedId, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- }
write_blocked_list_.AddStream(kBlockedId);
write_blocked_list_.AddStream(kBlockedId);
write_blocked_list_.AddStream(kBlockedId);
@@ -217,10 +149,7 @@
EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
}
-TEST_P(QuicWriteBlockedListTest, BatchingWrites) {
- if (GetParam()) {
- return;
- }
+TEST_F(QuicWriteBlockedListTest, BatchingWrites) {
const QuicStreamId id1 = 3 + 2;
const QuicStreamId id2 = id1 + 2;
const QuicStreamId id3 = id2 + 2;
@@ -273,62 +202,31 @@
EXPECT_EQ(id1, write_blocked_list_.PopFront());
}
-TEST_P(QuicWriteBlockedListTest, Ceding) {
- if (GetParam()) {
- /*
- 0
- |
- 15
- |
- 16
- |
- 5
- |
- 4
- |
- 7
- */
- write_blocked_list_.RegisterStream(
- 15, false,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 16, false,
- spdy::SpdyStreamPrecedence(15, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 4, false,
- spdy::SpdyStreamPrecedence(16, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 5, false,
- spdy::SpdyStreamPrecedence(16, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 7, false,
- spdy::SpdyStreamPrecedence(4, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 1, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 3, true,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
- write_blocked_list_.RegisterStream(
- 15, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(
- 16, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(5, false, spdy::SpdyStreamPrecedence(5));
- write_blocked_list_.RegisterStream(4, false, spdy::SpdyStreamPrecedence(5));
- write_blocked_list_.RegisterStream(7, false, spdy::SpdyStreamPrecedence(7));
- write_blocked_list_.RegisterStream(
- 1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- write_blocked_list_.RegisterStream(
- 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
- }
+TEST_F(QuicWriteBlockedListTest, Ceding) {
+ /*
+ 0
+ |
+ 15
+ |
+ 16
+ |
+ 5
+ |
+ 4
+ |
+ 7
+ */
+ write_blocked_list_.RegisterStream(
+ 15, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(
+ 16, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(5, false, spdy::SpdyStreamPrecedence(5));
+ write_blocked_list_.RegisterStream(4, false, spdy::SpdyStreamPrecedence(5));
+ write_blocked_list_.RegisterStream(7, false, spdy::SpdyStreamPrecedence(7));
+ write_blocked_list_.RegisterStream(
+ 1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+ write_blocked_list_.RegisterStream(
+ 3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
// When nothing is on the list, nothing yields.
EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
@@ -366,66 +264,6 @@
EXPECT_FALSE(write_blocked_list_.ShouldYield(1));
}
-TEST_P(QuicWriteBlockedListTest, UpdateStreamPriority) {
- if (!GetParam()) {
- return;
- }
- /*
- 0
- |
- 5
- |
- 7
- |
- 9
- |
- 11
- */
- write_blocked_list_.RegisterStream(
- 5, false,
- spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight, kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 7, false,
- spdy::SpdyStreamPrecedence(5, kHttp2DefaultStreamWeight, kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 9, false,
- spdy::SpdyStreamPrecedence(7, kHttp2DefaultStreamWeight, kExclusiveBit));
- write_blocked_list_.RegisterStream(
- 11, false,
- spdy::SpdyStreamPrecedence(9, kHttp2DefaultStreamWeight, kExclusiveBit));
-
- write_blocked_list_.AddStream(7);
- EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
- EXPECT_TRUE(write_blocked_list_.ShouldYield(9));
- EXPECT_TRUE(write_blocked_list_.ShouldYield(11));
-
- // Update 9's priority.
- if (GetParam()) {
- /*
- 0
- |
- 5
- / \
- 7 9
- |
- 11
- */
- write_blocked_list_.UpdateStreamPriority(
- 9, spdy::SpdyStreamPrecedence(5, kHttp2DefaultStreamWeight,
- kExclusiveBit));
- } else {
- write_blocked_list_.UpdateStreamPriority(9, spdy::SpdyStreamPrecedence(1));
- }
- EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
- // Verify 9 now does not yield to 7.
- EXPECT_FALSE(write_blocked_list_.ShouldYield(9));
- EXPECT_FALSE(write_blocked_list_.ShouldYield(11));
-
- write_blocked_list_.AddStream(9);
- // Verify 11 yield to 9.
- EXPECT_TRUE(write_blocked_list_.ShouldYield(11));
-}
-
} // namespace
} // namespace test
} // namespace quic
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 33bad6b..740b591 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -65,7 +65,7 @@
const std::string& request_url,
const std::list<QuicBackendResponse::ServerPushInfo>& resources,
QuicStreamId original_stream_id,
- const spdy::SpdyStreamPrecedence& original_precedence,
+ const spdy::SpdyStreamPrecedence& /* original_precedence */,
const spdy::Http2HeaderBlock& original_request_headers) {
if (!server_push_enabled()) {
return;
@@ -85,11 +85,9 @@
highest_promised_stream_id_ = new_highest_promised_stream_id;
SendPushPromise(original_stream_id, highest_promised_stream_id_,
headers.Clone());
- promised_streams_.push_back(PromisedStreamInfo(
- std::move(headers), highest_promised_stream_id_,
- use_http2_priority_write_scheduler()
- ? original_precedence
- : spdy::SpdyStreamPrecedence(resource.priority)));
+ promised_streams_.push_back(
+ PromisedStreamInfo(std::move(headers), highest_promised_stream_id_,
+ spdy::SpdyStreamPrecedence(resource.priority)));
}
// Procese promised push request as many as possible.
