In quic, stop sending duplicate max_streams. protected by gfe2_reloadable_flag_quic_stop_sending_duplicate_max_streams.
PiperOrigin-RevId: 315729190
Change-Id: Ic5ad61858823706e563e860cc6096970156de4bc
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index ba31dec..5cde890 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -55,6 +55,14 @@
" exceeds incoming max stream ", incoming_advertised_max_streams_);
return false;
}
+ if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+ QUIC_RELOADABLE_FLAG_COUNT(quic_stop_sending_duplicate_max_streams);
+ DCHECK_LE(incoming_advertised_max_streams_, incoming_actual_max_streams_);
+ if (incoming_advertised_max_streams_ == incoming_actual_max_streams_) {
+ // We have told peer about current max.
+ return true;
+ }
+ }
if (frame.stream_count < incoming_actual_max_streams_) {
// Peer thinks it's blocked on a stream count that is less than our current
// max. Inform the peer of the correct stream count.
@@ -104,6 +112,10 @@
}
void QuicStreamIdManager::SendMaxStreamsFrame() {
+ if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+ QUIC_BUG_IF(incoming_advertised_max_streams_ >=
+ incoming_actual_max_streams_);
+ }
incoming_advertised_max_streams_ = incoming_actual_max_streams_;
delegate_->SendMaxStreams(incoming_advertised_max_streams_, unidirectional_);
}
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 2179ba2..689d411 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -139,13 +139,18 @@
}
// Check the case of the stream count in a STREAMS_BLOCKED frame is less than
-// the count most recently advertised in a MAX_STREAMS frame. This should cause
-// a MAX_STREAMS frame with the most recently advertised count to be sent.
+// the count most recently advertised in a MAX_STREAMS frame.
TEST_P(QuicStreamIdManagerTest, ProcessStreamsBlockedOk) {
QuicStreamCount stream_count =
stream_id_manager_.incoming_initial_max_open_streams();
QuicStreamsBlockedFrame frame(0, stream_count - 1, IsUnidirectional());
- EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()));
+ if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+ // We have notified peer about current max.
+ EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()))
+ .Times(0);
+ } else {
+ EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()));
+ }
std::string error_details;
EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
}
@@ -398,7 +403,12 @@
// Check that receipt of a STREAMS BLOCKED with stream-count = 0 invokes a
// MAX STREAMS, count = 123, when the MaxOpen... is set to 123.
EXPECT_CALL(delegate_, SendMaxStreams(123u, IsUnidirectional()));
- stream_id_manager_.SetMaxOpenIncomingStreams(123);
+ if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+ QuicStreamIdManagerPeer::set_incoming_actual_max_streams(
+ &stream_id_manager_, 123);
+ } else {
+ stream_id_manager_.SetMaxOpenIncomingStreams(123);
+ }
frame.stream_count = 0;
EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
}
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 7cae0a6..b3dfedc 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -287,18 +287,32 @@
QuicStreamsBlockedFrame frame(kInvalidControlFrameId, stream_count,
/*unidirectional=*/false);
- EXPECT_CALL(delegate_,
- SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
- frame.unidirectional));
+ if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+ EXPECT_CALL(delegate_,
+ SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+ frame.unidirectional))
+ .Times(0);
+ } else {
+ EXPECT_CALL(delegate_,
+ SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+ frame.unidirectional));
+ }
EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
stream_count = manager_.advertised_max_incoming_unidirectional_streams() - 1;
frame.stream_count = stream_count;
frame.unidirectional = true;
- EXPECT_CALL(delegate_,
- SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
- frame.unidirectional));
+ if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+ EXPECT_CALL(delegate_,
+ SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+ frame.unidirectional))
+ .Times(0);
+ } else {
+ EXPECT_CALL(delegate_,
+ SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+ frame.unidirectional));
+ }
EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
}
