Deprecate gfe2_reloadable_flag_quic_stop_sending_duplicate_max_streams.

PiperOrigin-RevId: 324608537
Change-Id: I32e566ff0a5ddf6bc511ded9c9fab3b259089b05

quic/core/quic_stream_id_manager.cc

diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index 528d955..8a54e31 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -55,13 +55,10 @@
         " 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;
-    }
+  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
@@ -112,10 +109,7 @@
 }
 
 void QuicStreamIdManager::SendMaxStreamsFrame() {
-  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
-    QUIC_BUG_IF(incoming_advertised_max_streams_ >=
-                incoming_actual_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_);
 }

quic/core/quic_stream_id_manager_test.cc

diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 689d411..e95f553 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -144,13 +144,9 @@
   QuicStreamCount stream_count =
       stream_id_manager_.incoming_initial_max_open_streams();
   QuicStreamsBlockedFrame frame(0, stream_count - 1, 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()));
-  }
+  // We have notified peer about current max.
+  EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()))
+      .Times(0);
   std::string error_details;
   EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 }
@@ -403,12 +399,8 @@
   // 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()));
-  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
-    QuicStreamIdManagerPeer::set_incoming_actual_max_streams(
-        &stream_id_manager_, 123);
-  } else {
-    stream_id_manager_.SetMaxOpenIncomingStreams(123);
-  }
+  QuicStreamIdManagerPeer::set_incoming_actual_max_streams(&stream_id_manager_,
+                                                           123);
   frame.stream_count = 0;
   EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 }

quic/core/uber_quic_stream_id_manager_test.cc

diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index b3dfedc..705a395 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -287,32 +287,20 @@
 
   QuicStreamsBlockedFrame frame(kInvalidControlFrameId, stream_count,
                                 /*unidirectional=*/false);
-  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_CALL(delegate_,
+              SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+                             frame.unidirectional))
+      .Times(0);
   EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
 
   stream_count = manager_.advertised_max_incoming_unidirectional_streams() - 1;
   frame.stream_count = stream_count;
   frame.unidirectional = true;
 
-  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_CALL(delegate_,
+              SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+                             frame.unidirectional))
+      .Times(0);
   EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
 }