diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index 366cfaa..14aa8e9 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -89,7 +89,8 @@
 
 // Used when configuration has been done and we have an initial
 // maximum stream count from the peer.
-bool QuicStreamIdManager::SetMaxOpenOutgoingStreams(size_t max_open_streams) {
+bool QuicStreamIdManager::SetMaxOpenOutgoingStreams(
+    QuicStreamCount max_open_streams) {
   if (using_default_max_streams_) {
     // This is the first MAX_STREAMS/transport negotiation we've received. Treat
     // this a bit differently than later ones. The difference is that
@@ -114,9 +115,9 @@
 
   // 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<size_t>(
-      max_open_streams,
-      QuicUtils::GetMaxStreamCount(unidirectional_, perspective_));
+  outgoing_max_streams_ =
+      std::min(max_open_streams,
+               QuicUtils::GetMaxStreamCount(unidirectional_, perspective_));
 
   // Inform the higher layers that the stream limit has increased and that
   // new streams may be created.
@@ -125,11 +126,11 @@
   return true;
 }
 
-void QuicStreamIdManager::SetMaxOpenIncomingStreams(size_t max_open_streams) {
+void QuicStreamIdManager::SetMaxOpenIncomingStreams(
+    QuicStreamCount max_open_streams) {
   QuicStreamCount implementation_max =
       QuicUtils::GetMaxStreamCount(unidirectional_, perspective());
-  QuicStreamCount new_max = std::min(
-      implementation_max, static_cast<QuicStreamCount>(max_open_streams));
+  QuicStreamCount new_max = std::min(implementation_max, max_open_streams);
   if (new_max < incoming_stream_count_) {
     delegate_->OnError(QUIC_MAX_STREAMS_ERROR,
                        "Stream limit less than existing stream count");
@@ -138,7 +139,7 @@
   incoming_actual_max_streams_ = new_max;
   incoming_advertised_max_streams_ = new_max;
   incoming_initial_max_open_streams_ =
-      std::min(max_open_streams, static_cast<size_t>(implementation_max));
+      std::min(max_open_streams, implementation_max);
   CalculateIncomingMaxStreamsWindow();
 }
 
@@ -327,7 +328,7 @@
   return QuicUtils::InvertPerspective(perspective());
 }
 
-size_t QuicStreamIdManager::available_incoming_streams() {
+QuicStreamCount QuicStreamIdManager::available_incoming_streams() {
   return incoming_advertised_max_streams_ - incoming_stream_count_;
 }
 
diff --git a/quic/core/quic_stream_id_manager.h b/quic/core/quic_stream_id_manager.h
index fe7979b..92d9a06 100644
--- a/quic/core/quic_stream_id_manager.h
+++ b/quic/core/quic_stream_id_manager.h
@@ -111,14 +111,14 @@
   // allocates a stream ID past the peer specified limit.
   QuicStreamId GetNextOutgoingStreamId();
 
-  void SetMaxOpenIncomingStreams(size_t max_open_streams);
+  void SetMaxOpenIncomingStreams(QuicStreamCount max_open_streams);
 
   // Sets the maximum number of outgoing streams to max_open_streams.
   // Used when configuration has been done and we have an initial
   // maximum stream count from the peer. Note that if the stream count is such
   // that it would result in stream ID values that are greater than the
   // implementation limit, it pegs the count at the implementation limit.
-  bool SetMaxOpenOutgoingStreams(size_t max_open_streams);
+  bool SetMaxOpenOutgoingStreams(QuicStreamCount max_open_streams);
 
   // Checks if the incoming stream ID exceeds the MAX_STREAMS limit.  If the
   // limit is exceeded, closes the connection and returns false.  Uses the
@@ -134,7 +134,7 @@
   // Return true if given stream is peer initiated.
   bool IsIncomingStream(QuicStreamId id) const;
 
-  size_t incoming_initial_max_open_streams() const {
+  QuicStreamCount incoming_initial_max_open_streams() const {
     return incoming_initial_max_open_streams_;
   }
 
@@ -145,7 +145,7 @@
   }
 
   // Number of streams that the peer believes that it can still create.
-  size_t available_incoming_streams();
+  QuicStreamCount available_incoming_streams();
 
   void set_largest_peer_created_stream_id(
       QuicStreamId largest_peer_created_stream_id) {
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index 6d1121a..27b8873 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -32,19 +32,19 @@
           max_open_incoming_unidirectional_streams) {}
 
 void UberQuicStreamIdManager::SetMaxOpenOutgoingBidirectionalStreams(
-    size_t max_open_streams) {
+    QuicStreamCount max_open_streams) {
   bidirectional_stream_id_manager_.SetMaxOpenOutgoingStreams(max_open_streams);
 }
 void UberQuicStreamIdManager::SetMaxOpenOutgoingUnidirectionalStreams(
-    size_t max_open_streams) {
+    QuicStreamCount max_open_streams) {
   unidirectional_stream_id_manager_.SetMaxOpenOutgoingStreams(max_open_streams);
 }
 void UberQuicStreamIdManager::SetMaxOpenIncomingBidirectionalStreams(
-    size_t max_open_streams) {
+    QuicStreamCount max_open_streams) {
   bidirectional_stream_id_manager_.SetMaxOpenIncomingStreams(max_open_streams);
 }
 void UberQuicStreamIdManager::SetMaxOpenIncomingUnidirectionalStreams(
-    size_t max_open_streams) {
+    QuicStreamCount max_open_streams) {
   unidirectional_stream_id_manager_.SetMaxOpenIncomingStreams(max_open_streams);
 }
 
@@ -111,13 +111,13 @@
   return unidirectional_stream_id_manager_.IsAvailableStream(id);
 }
 
-size_t UberQuicStreamIdManager::GetMaxAllowdIncomingBidirectionalStreams()
-    const {
+QuicStreamCount
+UberQuicStreamIdManager::GetMaxAllowdIncomingBidirectionalStreams() const {
   return bidirectional_stream_id_manager_.incoming_initial_max_open_streams();
 }
 
-size_t UberQuicStreamIdManager::GetMaxAllowdIncomingUnidirectionalStreams()
-    const {
+QuicStreamCount
+UberQuicStreamIdManager::GetMaxAllowdIncomingUnidirectionalStreams() const {
   return unidirectional_stream_id_manager_.incoming_initial_max_open_streams();
 }
 
@@ -150,11 +150,13 @@
   return unidirectional_stream_id_manager_.next_outgoing_stream_id();
 }
 
-size_t UberQuicStreamIdManager::max_outgoing_bidirectional_streams() const {
+QuicStreamCount UberQuicStreamIdManager::max_outgoing_bidirectional_streams()
+    const {
   return bidirectional_stream_id_manager_.outgoing_max_streams();
 }
 
-size_t UberQuicStreamIdManager::max_outgoing_unidirectional_streams() const {
+QuicStreamCount UberQuicStreamIdManager::max_outgoing_unidirectional_streams()
+    const {
   return unidirectional_stream_id_manager_.outgoing_max_streams();
 }
 
diff --git a/quic/core/uber_quic_stream_id_manager.h b/quic/core/uber_quic_stream_id_manager.h
index 13aa1b5..2ea743f 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_CORE_UBER_QUIC_STREAM_ID_MANAGER_H_
 
 #include "net/third_party/quiche/src/quic/core/quic_stream_id_manager.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
 
 namespace quic {
 
@@ -30,10 +31,12 @@
       QuicStreamCount max_open_incoming_unidirectional_streams);
 
   // Sets the limits to max_open_streams.
-  void SetMaxOpenOutgoingBidirectionalStreams(size_t max_open_streams);
-  void SetMaxOpenOutgoingUnidirectionalStreams(size_t max_open_streams);
-  void SetMaxOpenIncomingBidirectionalStreams(size_t max_open_streams);
-  void SetMaxOpenIncomingUnidirectionalStreams(size_t max_open_streams);
+  void SetMaxOpenOutgoingBidirectionalStreams(QuicStreamCount max_open_streams);
+  void SetMaxOpenOutgoingUnidirectionalStreams(
+      QuicStreamCount max_open_streams);
+  void SetMaxOpenIncomingBidirectionalStreams(QuicStreamCount max_open_streams);
+  void SetMaxOpenIncomingUnidirectionalStreams(
+      QuicStreamCount max_open_streams);
 
   // Returns true if next outgoing bidirectional stream ID can be allocated.
   bool CanOpenNextOutgoingBidirectionalStream();
@@ -65,9 +68,9 @@
   // Returns true if |id| is still available.
   bool IsAvailableStream(QuicStreamId id) const;
 
-  size_t GetMaxAllowdIncomingBidirectionalStreams() const;
+  QuicStreamCount GetMaxAllowdIncomingBidirectionalStreams() const;
 
-  size_t GetMaxAllowdIncomingUnidirectionalStreams() const;
+  QuicStreamCount GetMaxAllowdIncomingUnidirectionalStreams() const;
 
   void SetLargestPeerCreatedStreamId(
       QuicStreamId largest_peer_created_stream_id);
@@ -77,8 +80,8 @@
   QuicStreamId next_outgoing_bidirectional_stream_id() const;
   QuicStreamId next_outgoing_unidirectional_stream_id() const;
 
-  size_t max_outgoing_bidirectional_streams() const;
-  size_t max_outgoing_unidirectional_streams() const;
+  QuicStreamCount max_outgoing_bidirectional_streams() const;
+  QuicStreamCount max_outgoing_unidirectional_streams() const;
 
   QuicStreamCount max_incoming_bidirectional_streams() const;
   QuicStreamCount max_incoming_unidirectional_streams() const;