diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 27643c8..4e532de 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -1076,11 +1076,8 @@
 }
 
 bool QuicSpdySession::HasActiveRequestStreams() const {
-  DCHECK_GE(static_cast<size_t>(stream_map().size()),
-            num_incoming_static_streams() + num_outgoing_static_streams());
-  return stream_map().size() - num_incoming_static_streams() -
-             num_outgoing_static_streams() >
-         0;
+  DCHECK_GE(static_cast<size_t>(stream_map().size()), num_static_streams());
+  return stream_map().size() - num_static_streams() > 0;
 }
 
 bool QuicSpdySession::ProcessPendingStream(PendingStream* pending) {
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 218384f..cdb8b31 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -73,10 +73,8 @@
                             config_.GetMaxBidirectionalStreamsToSend(),
                             config_.GetMaxUnidirectionalStreamsToSend() +
                                 num_expected_unidirectional_static_streams),
-      num_draining_incoming_streams_(0),
-      num_draining_outgoing_streams_(0),
-      num_outgoing_static_streams_(0),
-      num_incoming_static_streams_(0),
+      num_draining_streams_(0),
+      num_static_streams_(0),
       flow_controller_(
           this,
           QuicUtils::GetInvalidStreamId(connection->transport_version()),
@@ -677,12 +675,6 @@
              QuicUtils::GetCryptoStreamId(transport_version()));
 }
 
-uint64_t QuicSession::GetNumOpenDynamicStreams() const {
-  return stream_map_.size() - GetNumDrainingStreams() +
-         locally_closed_streams_highest_offset_.size() -
-         num_incoming_static_streams_ - num_outgoing_static_streams_;
-}
-
 void QuicSession::ProcessUdpPacket(const QuicSocketAddress& self_address,
                                    const QuicSocketAddress& peer_address,
                                    const QuicReceivedPacket& packet) {
@@ -911,13 +903,8 @@
       << ENDPOINT << "Stream " << stream_id << " was draining";
   stream_map_.erase(it);
   if (stream_was_draining) {
-    if (IsIncomingStream(stream_id)) {
-      QUIC_BUG_IF(num_draining_incoming_streams_ == 0);
-      --num_draining_incoming_streams_;
-    } else {
-      QUIC_BUG_IF(num_draining_outgoing_streams_ == 0);
-      --num_draining_outgoing_streams_;
-    }
+    QUIC_BUG_IF(num_draining_streams_ == 0);
+    --num_draining_streams_;
     // Stream Id manager has been informed with draining streams.
     return;
   }
@@ -1565,8 +1552,7 @@
   DCHECK(!QuicContainsKey(stream_map_, stream_id));
   stream_map_[stream_id] = std::move(stream);
   if (is_static) {
-    IsIncomingStream(stream_id) ? ++num_incoming_static_streams_
-                                : ++num_outgoing_static_streams_;
+    ++num_static_streams_;
     return;
   }
   if (!VersionHasIetfQuicFrames(transport_version())) {
@@ -1676,12 +1662,10 @@
     stream_id_manager_.OnStreamClosed(
         /*is_incoming=*/IsIncomingStream(stream_id));
   }
-  if (IsIncomingStream(stream_id)) {
-    ++num_draining_incoming_streams_;
-    return;
+  ++num_draining_streams_;
+  if (!IsIncomingStream(stream_id)) {
+    OnCanCreateNewOutgoingStream(unidirectional);
   }
-  ++num_draining_outgoing_streams_;
-  OnCanCreateNewOutgoingStream(unidirectional);
 }
 
 bool QuicSession::MaybeIncreaseLargestPeerStreamId(
@@ -1806,12 +1790,7 @@
            stream_id_manager_.num_open_outgoing_streams() -
            locally_closed_streams_highest_offset_.size();
   }
-  return stream_map_.size() - GetNumDrainingStreams() -
-         num_incoming_static_streams_ - num_outgoing_static_streams_;
-}
-
-size_t QuicSession::GetNumDrainingStreams() const {
-  return num_draining_incoming_streams_ + num_draining_outgoing_streams_;
+  return stream_map_.size() - num_draining_streams_ - num_static_streams_;
 }
 
 void QuicSession::MarkConnectionLevelWriteBlocked(QuicStreamId id) {
@@ -1842,10 +1821,6 @@
   control_frame_manager_.WritePing();
 }
 
-size_t QuicSession::GetNumDrainingOutgoingStreams() const {
-  return num_draining_outgoing_streams_;
-}
-
 bool QuicSession::IsConnectionFlowControlBlocked() const {
   return flow_controller_.IsBlocked();
 }
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index c156a6e..32aad51 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -331,19 +331,6 @@
   // never counting unfinished streams.
   size_t GetNumActiveStreams() const;
 
-  // Returns the number of currently draining streams.
-  size_t GetNumDrainingStreams() const;
-
-  // Returns the number of open peer initiated static streams.
-  size_t num_incoming_static_streams() const {
-    return num_incoming_static_streams_;
-  }
-
-  // Returns the number of open self initiated static streams.
-  size_t num_outgoing_static_streams() const {
-    return num_outgoing_static_streams_;
-  }
-
   // Add the stream to the session's write-blocked list because it is blocked by
   // connection-level flow control but not by its own stream-level flow control.
   // The stream will be given a chance to write when a connection-level
@@ -528,9 +515,6 @@
   bool CanOpenNextOutgoingBidirectionalStream();
   bool CanOpenNextOutgoingUnidirectionalStream();
 
-  // Returns the number of open dynamic streams.
-  uint64_t GetNumOpenDynamicStreams() const;
-
   // Returns the maximum bidirectional streams parameter sent with the handshake
   // as a transport parameter, or in the most recent MAX_STREAMS frame.
   QuicStreamCount GetAdvertisedMaxIncomingBidirectionalStreams() const;
@@ -571,8 +555,6 @@
     return &write_blocked_streams_;
   }
 
-  size_t GetNumDrainingOutgoingStreams() const;
-
   // Returns true if the stream is still active.
   bool IsOpenStream(QuicStreamId id);
 
@@ -610,6 +592,8 @@
 
   QuicDatagramQueue* datagram_queue() { return &datagram_queue_; }
 
+  size_t num_static_streams() const { return num_static_streams_; }
+
   // Processes the stream type information of |pending| depending on
   // different kinds of sessions' own rules. Returns true if the pending stream
   // is converted into a normal stream.
@@ -750,25 +734,12 @@
   // Manages stream IDs for version99/IETF QUIC
   UberQuicStreamIdManager v99_streamid_manager_;
 
-  // A counter for peer initiated streams which have sent and received FIN but
-  // waiting for application to consume data.
-  // TODO(fayang): Merge num_draining_incoming_streams_ and
-  // num_draining_outgoing_streams_.
-  size_t num_draining_incoming_streams_;
+  // A counter for streams which have sent and received FIN but waiting for
+  // application to consume data.
+  size_t num_draining_streams_;
 
-  // A counter for self initiated streams which have sent and received FIN but
-  // waiting for application to consume data.
-  size_t num_draining_outgoing_streams_;
-
-  // A counter for self initiated static streams which are in
-  // stream_map_.
-  // TODO(fayang): Merge num_outgoing_static_streams_ and
-  // num_incoming_static_streams_.
-  size_t num_outgoing_static_streams_;
-
-  // A counter for peer initiated static streams which are in
-  // stream_map_.
-  size_t num_incoming_static_streams_;
+  // A counter for static streams which are in stream_map_.
+  size_t num_static_streams_;
 
   // Received information for a connection close.
   QuicConnectionCloseFrame on_closed_frame_;
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 700931c..62ffae8 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -750,7 +750,7 @@
                              nullptr);
   EXPECT_TRUE(stream_->write_side_closed());
 
-  EXPECT_EQ(1u, session_->GetNumDrainingStreams());
+  EXPECT_EQ(1u, QuicSessionPeer::GetNumDrainingStreams(session_.get()));
   EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
 }
 
@@ -778,7 +778,7 @@
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
   EXPECT_FALSE(stream_->reading_stopped());
 
-  EXPECT_EQ(1u, session_->GetNumDrainingStreams());
+  EXPECT_EQ(1u, QuicSessionPeer::GetNumDrainingStreams(session_.get()));
   EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
 }
 
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index 52ba763..98d8a51 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -94,8 +94,7 @@
     const ProofVerifyDetails& verify_details) {}
 
 bool QboneClientSession::HasActiveRequests() const {
-  return (stream_map().size() - num_incoming_static_streams() -
-          num_outgoing_static_streams()) > 0;
+  return (stream_map().size() - num_static_streams()) > 0;
 }
 
 }  // namespace quic
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index ab28828..ea9dc06 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -242,12 +242,17 @@
     }
   }
   // Exclude draining streams.
-  result -= session->GetNumDrainingStreams();
+  result -= session->num_draining_streams_;
   // Add locally closed streams.
   result += session->locally_closed_streams_highest_offset_.size();
 
   return result;
 }
 
+// static
+size_t QuicSessionPeer::GetNumDrainingStreams(QuicSession* session) {
+  return session->num_draining_streams_;
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/quic_session_peer.h b/quic/test_tools/quic_session_peer.h
index ffb6a46..061f16d 100644
--- a/quic/test_tools/quic_session_peer.h
+++ b/quic/test_tools/quic_session_peer.h
@@ -82,6 +82,7 @@
   static void set_is_configured(QuicSession* session, bool value);
   static void SetPerspective(QuicSession* session, Perspective perspective);
   static size_t GetNumOpenDynamicStreams(QuicSession* session);
+  static size_t GetNumDrainingStreams(QuicSession* session);
 };
 
 }  // namespace test
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 3c311a1..51cc7bf 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -801,7 +801,6 @@
   MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
 
   using QuicSession::ActivateStream;
-  using QuicSession::GetNumDrainingStreams;
 
   // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
   // if set) has been consumed.
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index f84a248..595fda7 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -243,9 +243,9 @@
 }
 
 void QuicSimpleServerSession::MaybeInitializeHttp3UnidirectionalStreams() {
-  size_t previous_static_stream_count = num_outgoing_static_streams();
+  size_t previous_static_stream_count = num_static_streams();
   QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams();
-  size_t current_static_stream_count = num_outgoing_static_streams();
+  size_t current_static_stream_count = num_static_streams();
   DCHECK_GE(current_static_stream_count, previous_static_stream_count);
   highest_promised_stream_id_ +=
       QuicUtils::StreamIdDelta(transport_version()) *