Remove QuicSession from LegacyQuicStreamIdManager and pass in transport_version and perspective instead.

gfe-relnote: n/a (Refactor)
PiperOrigin-RevId: 284747835
Change-Id: I5baf02f87cf72cdc02d6b8ddbd6befcccca199f3
diff --git a/quic/core/legacy_quic_stream_id_manager.cc b/quic/core/legacy_quic_stream_id_manager.cc
index 157e375..b8498b3 100644
--- a/quic/core/legacy_quic_stream_id_manager.cc
+++ b/quic/core/legacy_quic_stream_id_manager.cc
@@ -4,47 +4,33 @@
 #include "net/third_party/quiche/src/quic/core/legacy_quic_stream_id_manager.h"
 
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 
 namespace quic {
 
-#define ENDPOINT \
-  (session_->perspective() == Perspective::IS_SERVER ? "Server: " : "Client: ")
-
 LegacyQuicStreamIdManager::LegacyQuicStreamIdManager(
-    QuicSession* session,
+    Perspective perspective,
+    QuicTransportVersion transport_version,
     size_t max_open_outgoing_streams,
     size_t max_open_incoming_streams)
-    : session_(session),
+    : perspective_(perspective),
+      transport_version_(transport_version),
       max_open_outgoing_streams_(max_open_outgoing_streams),
       max_open_incoming_streams_(max_open_incoming_streams),
       next_outgoing_stream_id_(
-          QuicUtils::GetFirstBidirectionalStreamId(session->transport_version(),
-                                                   session->perspective())),
+          QuicUtils::GetFirstBidirectionalStreamId(transport_version_,
+                                                   perspective_)),
       largest_peer_created_stream_id_(
-          session->perspective() == Perspective::IS_SERVER
-              ? (QuicVersionUsesCryptoFrames(session->transport_version())
-                     ? QuicUtils::GetInvalidStreamId(
-                           session->transport_version())
-                     : QuicUtils::GetCryptoStreamId(
-                           session->transport_version()))
-              : QuicUtils::GetInvalidStreamId(session->transport_version())) {}
+          perspective_ == Perspective::IS_SERVER
+              ? (QuicVersionUsesCryptoFrames(transport_version_)
+                     ? QuicUtils::GetInvalidStreamId(transport_version_)
+                     : QuicUtils::GetCryptoStreamId(transport_version_))
+              : QuicUtils::GetInvalidStreamId(transport_version_)) {}
 
-LegacyQuicStreamIdManager::~LegacyQuicStreamIdManager() {
-  QUIC_LOG_IF(WARNING,
-              session_->num_locally_closed_incoming_streams_highest_offset() >
-                  max_open_incoming_streams_)
-      << "Surprisingly high number of locally closed peer initiated streams"
-         "still waiting for final byte offset: "
-      << session_->num_locally_closed_incoming_streams_highest_offset();
-  QUIC_LOG_IF(WARNING,
-              session_->GetNumLocallyClosedOutgoingStreamsHighestOffset() >
-                  max_open_outgoing_streams_)
-      << "Surprisingly high number of locally closed self initiated streams"
-         "still waiting for final byte offset: "
-      << session_->GetNumLocallyClosedOutgoingStreamsHighestOffset();
-}
+LegacyQuicStreamIdManager::~LegacyQuicStreamIdManager() {}
 
 bool LegacyQuicStreamIdManager::CanOpenNextOutgoingStream(
     size_t current_num_open_outgoing_streams) const {
@@ -69,7 +55,7 @@
   available_streams_.erase(stream_id);
 
   if (largest_peer_created_stream_id_ !=
-          QuicUtils::GetInvalidStreamId(session_->transport_version()) &&
+          QuicUtils::GetInvalidStreamId(transport_version_) &&
       stream_id <= largest_peer_created_stream_id_) {
     return true;
   }
@@ -80,31 +66,26 @@
   size_t additional_available_streams =
       (stream_id - largest_peer_created_stream_id_) / 2 - 1;
   if (largest_peer_created_stream_id_ ==
-      QuicUtils::GetInvalidStreamId(session_->transport_version())) {
+      QuicUtils::GetInvalidStreamId(transport_version_)) {
     additional_available_streams = (stream_id + 1) / 2 - 1;
   }
   size_t new_num_available_streams =
       GetNumAvailableStreams() + additional_available_streams;
   if (new_num_available_streams > MaxAvailableStreams()) {
-    QUIC_DLOG(INFO) << ENDPOINT
+    QUIC_DLOG(INFO) << perspective_
                     << "Failed to create a new incoming stream with id:"
                     << stream_id << ".  There are already "
                     << GetNumAvailableStreams()
                     << " streams available, which would become "
                     << new_num_available_streams << ", which exceeds the limit "
                     << MaxAvailableStreams() << ".";
-    session_->connection()->CloseConnection(
-        QUIC_TOO_MANY_AVAILABLE_STREAMS,
-        QuicStrCat(new_num_available_streams, " above ", MaxAvailableStreams()),
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return false;
   }
   QuicStreamId first_available_stream = largest_peer_created_stream_id_ + 2;
   if (largest_peer_created_stream_id_ ==
-      QuicUtils::GetInvalidStreamId(session_->transport_version())) {
+      QuicUtils::GetInvalidStreamId(transport_version_)) {
     first_available_stream = QuicUtils::GetFirstBidirectionalStreamId(
-        session_->transport_version(),
-        QuicUtils::InvertPerspective(session_->perspective()));
+        transport_version_, QuicUtils::InvertPerspective(perspective_));
   }
   for (QuicStreamId id = first_available_stream; id < stream_id; id += 2) {
     available_streams_.insert(id);
@@ -128,7 +109,7 @@
   }
   // For peer created streams, we also need to consider available streams.
   return largest_peer_created_stream_id_ ==
-             QuicUtils::GetInvalidStreamId(session_->transport_version()) ||
+             QuicUtils::GetInvalidStreamId(transport_version_) ||
          id > largest_peer_created_stream_id_ ||
          QuicContainsKey(available_streams_, id);
 }