Deprecate gfe2_reloadable_flag_quic_deprecate_draining_streams.

Remove draining_streams from QuicSession.

PiperOrigin-RevId: 314130389
Change-Id: If3ce6b7fba67faf3f044b6bcea7d63d42c7bf087
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index a1f20c6..6e0d894 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -101,8 +101,6 @@
       use_http2_priority_write_scheduler_(false),
       is_configured_(false),
       enable_round_robin_scheduling_(false),
-      deprecate_draining_streams_(
-          GetQuicReloadableFlag(quic_deprecate_draining_streams)),
       break_close_loop_(
           GetQuicReloadableFlag(quic_break_session_stream_close_loop)) {
   closed_streams_clean_up_alarm_ =
@@ -936,29 +934,21 @@
     InsertLocallyClosedStreamsHighestOffset(
         stream_id, stream->flow_controller()->highest_received_byte_offset());
   }
-  bool stream_was_draining = false;
-  if (deprecate_draining_streams_) {
-    stream_was_draining = stream->was_draining();
-    QUIC_DVLOG_IF(1, stream_was_draining)
-        << ENDPOINT << "Stream " << stream_id << " was draining";
-  }
+  const bool stream_was_draining = stream->was_draining();
+  QUIC_DVLOG_IF(1, stream_was_draining)
+      << ENDPOINT << "Stream " << stream_id << " was draining";
   stream_map_.erase(it);
   if (IsIncomingStream(stream_id)) {
     --num_dynamic_incoming_streams_;
   }
-  if (!deprecate_draining_streams_) {
-    stream_was_draining =
-        draining_streams_.find(stream_id) != draining_streams_.end();
-  }
   if (stream_was_draining) {
     if (IsIncomingStream(stream_id)) {
       QUIC_BUG_IF(num_draining_incoming_streams_ == 0);
       --num_draining_incoming_streams_;
-    } else if (deprecate_draining_streams_) {
+    } else {
       QUIC_BUG_IF(num_draining_outgoing_streams_ == 0);
       --num_draining_outgoing_streams_;
     }
-    draining_streams_.erase(stream_id);
   } else if (VersionHasIetfQuicFrames(transport_version())) {
     // Stream was not draining, but we did have a fin or rst, so we can now
     // free the stream ID if version 99.
@@ -1023,29 +1013,21 @@
     return;
   }
 
-  bool stream_was_draining = false;
-  if (deprecate_draining_streams_) {
-    stream_was_draining = stream->was_draining();
-    QUIC_DVLOG_IF(1, stream_was_draining)
-        << ENDPOINT << "Stream " << stream_id << " was draining";
-  }
+  const bool stream_was_draining = stream->was_draining();
+  QUIC_DVLOG_IF(1, stream_was_draining)
+      << ENDPOINT << "Stream " << stream_id << " was draining";
   stream_map_.erase(it);
   if (IsIncomingStream(stream_id)) {
     --num_dynamic_incoming_streams_;
   }
-  if (!deprecate_draining_streams_) {
-    stream_was_draining =
-        draining_streams_.find(stream_id) != draining_streams_.end();
-  }
   if (stream_was_draining) {
     if (IsIncomingStream(stream_id)) {
       QUIC_BUG_IF(num_draining_incoming_streams_ == 0);
       --num_draining_incoming_streams_;
-    } else if (deprecate_draining_streams_) {
+    } else {
       QUIC_BUG_IF(num_draining_outgoing_streams_ == 0);
       --num_draining_outgoing_streams_;
     }
-    draining_streams_.erase(stream_id);
     // Stream Id manager has been informed with draining streams.
     return;
   }
@@ -1812,49 +1794,19 @@
 
 void QuicSession::StreamDraining(QuicStreamId stream_id, bool unidirectional) {
   DCHECK(QuicContainsKey(stream_map_, stream_id));
-  if (deprecate_draining_streams_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_deprecate_draining_streams);
-    QUIC_DVLOG(1) << ENDPOINT << "Stream " << stream_id << " is draining";
-    if (VersionHasIetfQuicFrames(transport_version())) {
-      v99_streamid_manager_.OnStreamClosed(stream_id);
-    } else if (stream_id_manager_.handles_accounting()) {
-      stream_id_manager_.OnStreamClosed(
-          /*is_incoming=*/IsIncomingStream(stream_id));
-    }
-    if (IsIncomingStream(stream_id)) {
-      ++num_draining_incoming_streams_;
-      return;
-    }
-    ++num_draining_outgoing_streams_;
-    OnCanCreateNewOutgoingStream(unidirectional);
+  QUIC_DVLOG(1) << ENDPOINT << "Stream " << stream_id << " is draining";
+  if (VersionHasIetfQuicFrames(transport_version())) {
+    v99_streamid_manager_.OnStreamClosed(stream_id);
+  } else if (stream_id_manager_.handles_accounting()) {
+    stream_id_manager_.OnStreamClosed(
+        /*is_incoming=*/IsIncomingStream(stream_id));
+  }
+  if (IsIncomingStream(stream_id)) {
+    ++num_draining_incoming_streams_;
     return;
   }
-  if (!QuicContainsKey(draining_streams_, stream_id)) {
-    draining_streams_.insert(stream_id);
-    if (IsIncomingStream(stream_id)) {
-      ++num_draining_incoming_streams_;
-    }
-    if (VersionHasIetfQuicFrames(transport_version())) {
-      v99_streamid_manager_.OnStreamClosed(stream_id);
-    } else if (stream_id_manager_.handles_accounting()) {
-      stream_id_manager_.OnStreamClosed(
-          /*is_incoming=*/IsIncomingStream(stream_id));
-    }
-  }
-  if (!IsIncomingStream(stream_id)) {
-    // Inform application that a stream is available.
-    if (VersionHasIetfQuicFrames(transport_version())) {
-      OnCanCreateNewOutgoingStream(
-          !QuicUtils::IsBidirectionalStreamId(stream_id));
-    } else {
-      QuicStream* stream = GetStream(stream_id);
-      if (!stream) {
-        QUIC_BUG << "Stream doesn't exist when draining.";
-        return;
-      }
-      OnCanCreateNewOutgoingStream(stream->type() != BIDIRECTIONAL);
-    }
-  }
+  ++num_draining_outgoing_streams_;
+  OnCanCreateNewOutgoingStream(unidirectional);
 }
 
 bool QuicSession::MaybeIncreaseLargestPeerStreamId(
@@ -2007,10 +1959,7 @@
 }
 
 size_t QuicSession::GetNumDrainingStreams() const {
-  if (deprecate_draining_streams_) {
-    return num_draining_incoming_streams_ + num_draining_outgoing_streams_;
-  }
-  return draining_streams_.size();
+  return num_draining_incoming_streams_ + num_draining_outgoing_streams_;
 }
 
 void QuicSession::MarkConnectionLevelWriteBlocked(QuicStreamId id) {
@@ -2052,11 +2001,7 @@
 }
 
 size_t QuicSession::GetNumDrainingOutgoingStreams() const {
-  if (deprecate_draining_streams_) {
-    return num_draining_outgoing_streams_;
-  }
-  DCHECK_GE(draining_streams_.size(), num_draining_incoming_streams_);
-  return draining_streams_.size() - num_draining_incoming_streams_;
+  return num_draining_outgoing_streams_;
 }
 
 size_t QuicSession::GetNumLocallyClosedOutgoingStreamsHighestOffset() const {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index b4c3e98..47ccce6 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -491,10 +491,6 @@
   // uses TLS handshake.
   virtual void OnAlpnSelected(quiche::QuicheStringPiece alpn);
 
-  bool deprecate_draining_streams() const {
-    return deprecate_draining_streams_;
-  }
-
   bool break_close_loop() const { return break_close_loop_; }
 
   // Called on clients by the crypto handshaker to provide application state
@@ -772,13 +768,6 @@
   // which are waiting for the first byte of payload to arrive.
   PendingStreamMap pending_stream_map_;
 
-  // Set of stream ids that are "draining" -- a FIN has been sent and received,
-  // but the stream object still exists because not all the received data has
-  // been consumed.
-  // TODO(fayang): Remove draining_streams_ when deprecate
-  // quic_deprecate_draining_streams.
-  QuicHashSet<QuicStreamId> draining_streams_;
-
   // Set of stream ids that are waiting for acks excluding crypto stream id.
   QuicHashSet<QuicStreamId> streams_waiting_for_acks_;
 
@@ -802,8 +791,7 @@
   size_t num_draining_incoming_streams_;
 
   // A counter for self initiated streams which have sent and received FIN but
-  // waiting for application to consume data. Only used when
-  // deprecate_draining_streams_ is true.
+  // waiting for application to consume data.
   // TODO(fayang): Remove this when deprecating
   // quic_stream_id_manager_handles_accounting.
   size_t num_draining_outgoing_streams_;
@@ -869,9 +857,6 @@
   // If true, enables round robin scheduling.
   bool enable_round_robin_scheduling_;
 
-  // Latched value of quic_deprecate_draining_streams.
-  const bool deprecate_draining_streams_;
-
   // Latched value of quic_break_session_stream_close_loop.
   const bool break_close_loop_;
 };
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 40a67bb..6e5a5e9 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -432,15 +432,13 @@
     return;
   }
 
-  if (frame.fin) {
-    if (!session_->deprecate_draining_streams() || !fin_received_) {
-      fin_received_ = true;
-      if (fin_sent_) {
-        DCHECK(!was_draining_ || !session_->deprecate_draining_streams());
-        session_->StreamDraining(id_,
-                                 /*unidirectional=*/type_ != BIDIRECTIONAL);
-        was_draining_ = true;
-      }
+  if (frame.fin && !fin_received_) {
+    fin_received_ = true;
+    if (fin_sent_) {
+      DCHECK(!was_draining_);
+      session_->StreamDraining(id_,
+                               /*unidirectional=*/type_ != BIDIRECTIONAL);
+      was_draining_ = true;
     }
   }
 
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index fe9d04c..930fd17 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -539,8 +539,7 @@
   // If initialized, reset this stream at this deadline.
   QuicTime deadline_;
 
-  // True if this stream has entered draining state. Only used when
-  // quic_deprecate_draining_streams is true.
+  // True if this stream has entered draining state.
   bool was_draining_;
 
   // Indicates whether this stream is bidirectional, read unidirectional or