Simplify QuicUtils::GetMaxStreamCount() because it's never used in gQUIC.

gfe-relnote: not used in production. not protected.
PiperOrigin-RevId: 302031491
Change-Id: Ibd41f7fa0393b333e331429577cc475774c61ce3

quic/core/quic_framer.cc

diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 95589ca..725e947 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -5970,19 +5970,14 @@
     set_detailed_error("Can not read STREAMS_BLOCKED stream count.");
     return false;
   }
-  frame->unidirectional = (frame_type == IETF_STREAMS_BLOCKED_UNIDIRECTIONAL);
-  if (frame->stream_count >
-      QuicUtils::GetMaxStreamCount(
-          (frame_type == IETF_STREAMS_BLOCKED_UNIDIRECTIONAL),
-          ((perspective_ == Perspective::IS_CLIENT)
-               ? Perspective::IS_SERVER
-               : Perspective::IS_CLIENT))) {
+  if (frame->stream_count > QuicUtils::GetMaxStreamCount()) {
     // If stream count is such that the resulting stream ID would exceed our
     // implementation limit, generate an error.
     set_detailed_error(
         "STREAMS_BLOCKED stream count exceeds implementation limit.");
     return false;
   }
+  frame->unidirectional = (frame_type == IETF_STREAMS_BLOCKED_UNIDIRECTIONAL);
   return true;
 }
 

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 2a64118..fc05be0 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -97,8 +97,7 @@
   // This implementation only supports 32 bit Stream IDs, so limit max streams
   // if it would exceed the max 32 bits can express.
   outgoing_max_streams_ =
-      std::min(max_open_streams,
-               QuicUtils::GetMaxStreamCount(unidirectional_, perspective_));
+      std::min(max_open_streams, QuicUtils::GetMaxStreamCount());
 
   // Inform the higher layers that the stream limit has increased and that
   // new streams may be created.
@@ -109,17 +108,14 @@
 
 void QuicStreamIdManager::SetMaxOpenIncomingStreams(
     QuicStreamCount max_open_streams) {
-  QuicStreamCount implementation_max =
-      QuicUtils::GetMaxStreamCount(unidirectional_, perspective());
-  QuicStreamCount new_max = std::min(implementation_max, max_open_streams);
-  if (new_max < incoming_stream_count_) {
+  if (max_open_streams < incoming_stream_count_) {
     delegate_->OnStreamIdManagerError(
         QUIC_MAX_STREAMS_ERROR, "Stream limit less than existing stream count");
     return;
   }
-  incoming_actual_max_streams_ = new_max;
-  incoming_advertised_max_streams_ = new_max;
-  incoming_initial_max_open_streams_ = new_max;
+  incoming_actual_max_streams_ = max_open_streams;
+  incoming_advertised_max_streams_ = max_open_streams;
+  incoming_initial_max_open_streams_ = max_open_streams;
   CalculateIncomingMaxStreamsWindow();
 }
 
@@ -146,8 +142,7 @@
   // If the stream is inbound, we can increase the actual stream limit and maybe
   // advertise the new limit to the peer.  Have to check to make sure that we do
   // not exceed the maximum.
-  if (incoming_actual_max_streams_ ==
-      QuicUtils::GetMaxStreamCount(unidirectional_, perspective())) {
+  if (incoming_actual_max_streams_ == QuicUtils::GetMaxStreamCount()) {
     // Reached the maximum stream id value that the implementation
     // supports. Nothing can be done here.
     return;

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 e9a4948..17d76b2 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -135,8 +135,7 @@
 }
 
 TEST_P(QuicStreamIdManagerTest, CheckMaxStreamsBadValuesOverMaxFailsOutgoing) {
-  QuicStreamCount implementation_max =
-      QuicUtils::GetMaxStreamCount(IsUnidirectional(), perspective());
+  QuicStreamCount implementation_max = QuicUtils::GetMaxStreamCount();
   // Ensure that the limit is less than the implementation maximum.
   EXPECT_LT(stream_id_manager_.outgoing_max_streams(), implementation_max);
 
@@ -146,39 +145,6 @@
   EXPECT_EQ(implementation_max, stream_id_manager_.outgoing_max_streams());
 }
 
-// Now do the same for the incoming streams
-TEST_P(QuicStreamIdManagerTest, CheckMaxStreamsBadValuesIncoming) {
-  QuicStreamCount implementation_max =
-      QuicUtils::GetMaxStreamCount(IsUnidirectional(), perspective());
-  stream_id_manager_.SetMaxOpenIncomingStreams(implementation_max - 1u);
-  EXPECT_EQ(implementation_max - 1u,
-            stream_id_manager_.incoming_initial_max_open_streams());
-  EXPECT_EQ(implementation_max - 1u,
-            stream_id_manager_.incoming_actual_max_streams());
-  EXPECT_EQ((implementation_max - 1u) / 2u,
-            stream_id_manager_.max_streams_window());
-
-  stream_id_manager_.SetMaxOpenIncomingStreams(implementation_max);
-  EXPECT_EQ(implementation_max,
-            stream_id_manager_.incoming_initial_max_open_streams());
-  EXPECT_EQ(implementation_max,
-            stream_id_manager_.incoming_actual_max_streams());
-  EXPECT_EQ(implementation_max / 2, stream_id_manager_.max_streams_window());
-
-  // Reset to 1 so that we can detect the change.
-  stream_id_manager_.SetMaxOpenIncomingStreams(1u);
-  EXPECT_EQ(1u, stream_id_manager_.incoming_initial_max_open_streams());
-  EXPECT_EQ(1u, stream_id_manager_.incoming_actual_max_streams());
-  EXPECT_EQ(1u, stream_id_manager_.max_streams_window());
-  // Now try to exceed the max, without wrapping.
-  stream_id_manager_.SetMaxOpenIncomingStreams(implementation_max + 1);
-  EXPECT_EQ(implementation_max,
-            stream_id_manager_.incoming_initial_max_open_streams());
-  EXPECT_EQ(implementation_max,
-            stream_id_manager_.incoming_actual_max_streams());
-  EXPECT_EQ(implementation_max / 2u, stream_id_manager_.max_streams_window());
-}
-
 // 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.

quic/core/quic_utils.cc

diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 8057a7d..60354f3 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -586,12 +586,7 @@
 }
 
 // static
-QuicStreamCount QuicUtils::GetMaxStreamCount(bool unidirectional,
-                                             Perspective perspective) {
-  // gQUIC uses one client initiated bidi stream for the crypto stream.
-  if (!unidirectional && perspective == Perspective::IS_CLIENT) {
-    return kMaxQuicStreamCount >> 2;
-  }
+QuicStreamCount QuicUtils::GetMaxStreamCount() {
   return (kMaxQuicStreamCount >> 2) + 1;
 }
 

quic/core/quic_utils.h

diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index c143154..eec9a5f 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -219,8 +219,7 @@
   // Get the maximum value for a V99/IETF QUIC stream count. If a count
   // exceeds this value, it will result in a stream ID that exceeds the
   // implementation limit on stream ID size.
-  static QuicStreamCount GetMaxStreamCount(bool unidirectional,
-                                           Perspective perspective);
+  static QuicStreamCount GetMaxStreamCount();
 };
 
 template <typename Mask>