diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 7acae48..2d0fa34 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -1747,14 +1747,14 @@
       VersionHasIetfQuicFrames(
           client_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(client_session)
-                ->max_allowed_outgoing_bidirectional_streams()
+                ->max_outgoing_bidirectional_streams()
           : QuicSessionPeer::GetStreamIdManager(client_session)
                 ->max_open_outgoing_streams();
   size_t client_max_open_outgoing_unidirectional_streams =
       VersionHasIetfQuicFrames(
           client_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(client_session)
-                    ->max_allowed_outgoing_unidirectional_streams() -
+                    ->max_outgoing_unidirectional_streams() -
                 client_session->num_expected_unidirectional_static_streams()
           : QuicSessionPeer::GetStreamIdManager(client_session)
                 ->max_open_outgoing_streams();
@@ -1768,14 +1768,14 @@
       VersionHasIetfQuicFrames(
           server_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(server_session)
-                ->max_allowed_outgoing_bidirectional_streams()
+                ->max_outgoing_bidirectional_streams()
           : QuicSessionPeer::GetStreamIdManager(server_session)
                 ->max_open_outgoing_streams();
   size_t server_max_open_outgoing_unidirectional_streams =
       VersionHasIetfQuicFrames(
           server_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(server_session)
-                    ->max_allowed_outgoing_unidirectional_streams() -
+                    ->max_outgoing_unidirectional_streams() -
                 server_session->num_expected_unidirectional_static_streams()
           : QuicSessionPeer::GetStreamIdManager(server_session)
                 ->max_open_outgoing_streams();
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index f2362fc..cf49dd0 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -518,32 +518,30 @@
     // Get the max allowed stream ID, this should succeed.
     QuicStreamId stream_id = StreamCountToId(
         QuicSessionPeer::v99_streamid_manager(&session_)
-            ->actual_max_allowed_incoming_bidirectional_streams(),
+            ->max_incoming_bidirectional_streams(),
         Perspective::IS_CLIENT,  // Client initates stream, allocs stream id.
         /*bidirectional=*/true);
     EXPECT_NE(nullptr, session_.GetOrCreateStream(stream_id));
-    stream_id = StreamCountToId(
-        QuicSessionPeer::v99_streamid_manager(&session_)
-            ->actual_max_allowed_incoming_unidirectional_streams(),
-        Perspective::IS_CLIENT,
-        /*bidirectional=*/false);
+    stream_id = StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+                                    ->max_incoming_unidirectional_streams(),
+                                Perspective::IS_CLIENT,
+                                /*bidirectional=*/false);
     EXPECT_NE(nullptr, session_.GetOrCreateStream(stream_id));
     EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(2);
     // Get the (max allowed stream ID)++. These should all fail.
-    stream_id = StreamCountToId(
-        QuicSessionPeer::v99_streamid_manager(&session_)
-                ->actual_max_allowed_incoming_bidirectional_streams() +
-            1,
-        Perspective::IS_CLIENT,
-        /*bidirectional=*/true);
+    stream_id = StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+                                        ->max_incoming_bidirectional_streams() +
+                                    1,
+                                Perspective::IS_CLIENT,
+                                /*bidirectional=*/true);
     EXPECT_EQ(nullptr, session_.GetOrCreateStream(stream_id));
 
-    stream_id = StreamCountToId(
-        QuicSessionPeer::v99_streamid_manager(&session_)
-                ->actual_max_allowed_incoming_unidirectional_streams() +
-            1,
-        Perspective::IS_CLIENT,
-        /*bidirectional=*/false);
+    stream_id =
+        StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+                                ->max_incoming_unidirectional_streams() +
+                            1,
+                        Perspective::IS_CLIENT,
+                        /*bidirectional=*/false);
     EXPECT_EQ(nullptr, session_.GetOrCreateStream(stream_id));
   } else {
     QuicStreamId stream_id = GetNthClientInitiatedBidirectionalId(0);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 33f1396..7abd24d 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -2515,7 +2515,7 @@
   }
   QuicStreamId bidirectional_stream_id = StreamCountToId(
       QuicSessionPeer::v99_streamid_manager(&session_)
-              ->advertised_max_allowed_incoming_bidirectional_streams() -
+              ->advertised_max_incoming_bidirectional_streams() -
           1,
       Perspective::IS_CLIENT,
       /*bidirectional=*/true);
@@ -2527,7 +2527,7 @@
 
   QuicStreamId unidirectional_stream_id = StreamCountToId(
       QuicSessionPeer::v99_streamid_manager(&session_)
-              ->advertised_max_allowed_incoming_unidirectional_streams() -
+              ->advertised_max_incoming_unidirectional_streams() -
           1,
       Perspective::IS_CLIENT,
       /*bidirectional=*/false);
@@ -2543,19 +2543,19 @@
     // Applicable only to IETF QUIC
     return;
   }
-  QuicStreamId bidirectional_stream_id = StreamCountToId(
-      QuicSessionPeer::v99_streamid_manager(&session_)
-          ->advertised_max_allowed_incoming_bidirectional_streams(),
-      Perspective::IS_CLIENT, /*bidirectional=*/true);
+  QuicStreamId bidirectional_stream_id =
+      StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+                          ->advertised_max_incoming_bidirectional_streams(),
+                      Perspective::IS_CLIENT, /*bidirectional=*/true);
   QuicStreamFrame bidirectional_stream_frame(bidirectional_stream_id, false, 0,
                                              "Random String");
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
   session_.OnStreamFrame(bidirectional_stream_frame);
 
-  QuicStreamId unidirectional_stream_id = StreamCountToId(
-      QuicSessionPeer::v99_streamid_manager(&session_)
-          ->advertised_max_allowed_incoming_unidirectional_streams(),
-      Perspective::IS_CLIENT, /*bidirectional=*/false);
+  QuicStreamId unidirectional_stream_id =
+      StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+                          ->advertised_max_incoming_unidirectional_streams(),
+                      Perspective::IS_CLIENT, /*bidirectional=*/false);
   QuicStreamFrame unidirectional_stream_frame(unidirectional_stream_id, false,
                                               0, "Random String");
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
@@ -2571,7 +2571,7 @@
 
   QuicStreamId bidirectional_stream_id = StreamCountToId(
       QuicSessionPeer::v99_streamid_manager(&session_)
-              ->advertised_max_allowed_incoming_bidirectional_streams() +
+              ->advertised_max_incoming_bidirectional_streams() +
           1,
       Perspective::IS_CLIENT, /*bidirectional=*/true);
   QuicStreamFrame bidirectional_stream_frame(bidirectional_stream_id, false, 0,
@@ -2584,7 +2584,7 @@
 
   QuicStreamId unidirectional_stream_id = StreamCountToId(
       QuicSessionPeer::v99_streamid_manager(&session_)
-              ->advertised_max_allowed_incoming_unidirectional_streams() +
+              ->advertised_max_incoming_unidirectional_streams() +
           1,
       Perspective::IS_CLIENT, /*bidirectional=*/false);
   QuicStreamFrame unidirectional_stream_frame(unidirectional_stream_id, false,
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index a2b3b7a..fa42643 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -136,36 +136,32 @@
   return unidirectional_stream_id_manager_.next_outgoing_stream_id();
 }
 
-size_t UberQuicStreamIdManager::max_allowed_outgoing_bidirectional_streams()
-    const {
+size_t UberQuicStreamIdManager::max_outgoing_bidirectional_streams() const {
   return bidirectional_stream_id_manager_.outgoing_max_streams();
 }
 
-size_t UberQuicStreamIdManager::max_allowed_outgoing_unidirectional_streams()
-    const {
+size_t UberQuicStreamIdManager::max_outgoing_unidirectional_streams() const {
   return unidirectional_stream_id_manager_.outgoing_max_streams();
 }
 
-QuicStreamCount
-UberQuicStreamIdManager::actual_max_allowed_incoming_bidirectional_streams()
+QuicStreamCount UberQuicStreamIdManager::max_incoming_bidirectional_streams()
     const {
   return bidirectional_stream_id_manager_.incoming_actual_max_streams();
 }
 
-QuicStreamCount
-UberQuicStreamIdManager::actual_max_allowed_incoming_unidirectional_streams()
+QuicStreamCount UberQuicStreamIdManager::max_incoming_unidirectional_streams()
     const {
   return unidirectional_stream_id_manager_.incoming_actual_max_streams();
 }
 
 QuicStreamCount
-UberQuicStreamIdManager::advertised_max_allowed_incoming_bidirectional_streams()
-    const {
+UberQuicStreamIdManager::advertised_max_incoming_bidirectional_streams() const {
   return bidirectional_stream_id_manager_.incoming_advertised_max_streams();
 }
 
-QuicStreamCount UberQuicStreamIdManager::
-    advertised_max_allowed_incoming_unidirectional_streams() const {
+QuicStreamCount
+UberQuicStreamIdManager::advertised_max_incoming_unidirectional_streams()
+    const {
   return unidirectional_stream_id_manager_.incoming_advertised_max_streams();
 }
 
diff --git a/quic/core/uber_quic_stream_id_manager.h b/quic/core/uber_quic_stream_id_manager.h
index 4db221a..5505475 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -73,15 +73,14 @@
   QuicStreamId next_outgoing_bidirectional_stream_id() const;
   QuicStreamId next_outgoing_unidirectional_stream_id() const;
 
-  size_t max_allowed_outgoing_bidirectional_streams() const;
-  size_t max_allowed_outgoing_unidirectional_streams() const;
+  size_t max_outgoing_bidirectional_streams() const;
+  size_t max_outgoing_unidirectional_streams() const;
 
-  QuicStreamCount actual_max_allowed_incoming_bidirectional_streams() const;
-  QuicStreamCount actual_max_allowed_incoming_unidirectional_streams() const;
+  QuicStreamCount max_incoming_bidirectional_streams() const;
+  QuicStreamCount max_incoming_unidirectional_streams() const;
 
-  QuicStreamCount advertised_max_allowed_incoming_bidirectional_streams() const;
-  QuicStreamCount advertised_max_allowed_incoming_unidirectional_streams()
-      const;
+  QuicStreamCount advertised_max_incoming_bidirectional_streams() const;
+  QuicStreamCount advertised_max_incoming_unidirectional_streams() const;
 
   void OnConfigNegotiated() {
     bidirectional_stream_id_manager_.OnConfigNegotiated();
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index ef62bd8..7e3cc8c 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -131,9 +131,9 @@
   manager_->SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
   manager_->SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
   EXPECT_EQ(kNumMaxOutgoingStream,
-            manager_->max_allowed_outgoing_bidirectional_streams());
+            manager_->max_outgoing_bidirectional_streams());
   EXPECT_EQ(kNumMaxOutgoingStream + 1,
-            manager_->max_allowed_outgoing_unidirectional_streams());
+            manager_->max_outgoing_unidirectional_streams());
   // Check that, for each directionality, we can open the correct number of
   // streams.
   int i = kNumMaxOutgoingStream;
@@ -162,10 +162,10 @@
             manager_->GetMaxAllowdIncomingBidirectionalStreams());
   EXPECT_EQ(kNumMaxIncomingStreams,
             manager_->GetMaxAllowdIncomingUnidirectionalStreams());
-  EXPECT_EQ(manager_->actual_max_allowed_incoming_bidirectional_streams(),
-            manager_->advertised_max_allowed_incoming_bidirectional_streams());
-  EXPECT_EQ(manager_->actual_max_allowed_incoming_unidirectional_streams(),
-            manager_->advertised_max_allowed_incoming_unidirectional_streams());
+  EXPECT_EQ(manager_->max_incoming_bidirectional_streams(),
+            manager_->advertised_max_incoming_bidirectional_streams());
+  EXPECT_EQ(manager_->max_incoming_unidirectional_streams(),
+            manager_->advertised_max_incoming_unidirectional_streams());
   // Make sure that we can create kNumMaxIncomingStreams incoming unidirectional
   // streams and kNumMaxIncomingStreams+1 incoming bidirectional streams.
   size_t i;
@@ -243,10 +243,10 @@
 TEST_P(UberQuicStreamIdManagerTest, MaybeIncreaseLargestPeerStreamId) {
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
   EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->actual_max_allowed_incoming_bidirectional_streams(),
+      manager_->max_incoming_bidirectional_streams(),
       QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/true)));
   EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->actual_max_allowed_incoming_bidirectional_streams(),
+      manager_->max_incoming_bidirectional_streams(),
       QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/false)));
 
   std::string error_details =
@@ -257,7 +257,7 @@
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
   EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->actual_max_allowed_incoming_bidirectional_streams() + 1,
+      manager_->max_incoming_bidirectional_streams() + 1,
       QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/true)));
   error_details = GetParam() == Perspective::IS_SERVER
                       ? "Stream id 402 would exceed stream count limit 100"
@@ -265,52 +265,52 @@
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
   EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->actual_max_allowed_incoming_bidirectional_streams() + 1,
+      manager_->max_incoming_bidirectional_streams() + 1,
       QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/false)));
 }
 
 TEST_P(UberQuicStreamIdManagerTest, OnMaxStreamsFrame) {
-  QuicStreamCount max_allowed_outgoing_bidirectional_stream_count =
-      manager_->max_allowed_outgoing_bidirectional_streams();
+  QuicStreamCount max_outgoing_bidirectional_stream_count =
+      manager_->max_outgoing_bidirectional_streams();
 
-  QuicStreamCount max_allowed_outgoing_unidirectional_stream_count =
-      manager_->max_allowed_outgoing_unidirectional_streams();
+  QuicStreamCount max_outgoing_unidirectional_stream_count =
+      manager_->max_outgoing_unidirectional_streams();
 
   // Inject a MAX_STREAMS frame that does not increase the limit and then
   // check that there are no changes. First try the bidirectional manager.
   QuicMaxStreamsFrame frame(kInvalidControlFrameId,
-                            max_allowed_outgoing_bidirectional_stream_count,
+                            max_outgoing_bidirectional_stream_count,
                             /*unidirectional=*/false);
   EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
-  EXPECT_EQ(max_allowed_outgoing_bidirectional_stream_count,
-            manager_->max_allowed_outgoing_bidirectional_streams());
+  EXPECT_EQ(max_outgoing_bidirectional_stream_count,
+            manager_->max_outgoing_bidirectional_streams());
 
   // Now try the unidirectioanl manager
-  frame.stream_count = max_allowed_outgoing_unidirectional_stream_count;
+  frame.stream_count = max_outgoing_unidirectional_stream_count;
   frame.unidirectional = true;
   EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
-  EXPECT_EQ(max_allowed_outgoing_unidirectional_stream_count,
-            manager_->max_allowed_outgoing_unidirectional_streams());
+  EXPECT_EQ(max_outgoing_unidirectional_stream_count,
+            manager_->max_outgoing_unidirectional_streams());
 
   // Now try to increase the bidirectional stream count.
-  frame.stream_count = max_allowed_outgoing_bidirectional_stream_count + 1;
+  frame.stream_count = max_outgoing_bidirectional_stream_count + 1;
   frame.unidirectional = false;
   EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
-  EXPECT_EQ(max_allowed_outgoing_bidirectional_stream_count + 1,
-            manager_->max_allowed_outgoing_bidirectional_streams());
+  EXPECT_EQ(max_outgoing_bidirectional_stream_count + 1,
+            manager_->max_outgoing_bidirectional_streams());
   // Make sure that the unidirectional state does not change.
-  EXPECT_EQ(max_allowed_outgoing_unidirectional_stream_count,
-            manager_->max_allowed_outgoing_unidirectional_streams());
+  EXPECT_EQ(max_outgoing_unidirectional_stream_count,
+            manager_->max_outgoing_unidirectional_streams());
 
   // Now check that a MAX_STREAMS for the unidirectional manager increases
   // just the unidirectiomal manager's state.
-  frame.stream_count = max_allowed_outgoing_unidirectional_stream_count + 1;
+  frame.stream_count = max_outgoing_unidirectional_stream_count + 1;
   frame.unidirectional = true;
   EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
-  EXPECT_EQ(max_allowed_outgoing_bidirectional_stream_count + 1,
-            manager_->max_allowed_outgoing_bidirectional_streams());
-  EXPECT_EQ(max_allowed_outgoing_unidirectional_stream_count + 1,
-            manager_->max_allowed_outgoing_unidirectional_streams());
+  EXPECT_EQ(max_outgoing_bidirectional_stream_count + 1,
+            manager_->max_outgoing_bidirectional_streams());
+  EXPECT_EQ(max_outgoing_unidirectional_stream_count + 1,
+            manager_->max_outgoing_unidirectional_streams());
 }
 
 TEST_P(UberQuicStreamIdManagerTest, OnStreamsBlockedFrame) {
@@ -324,23 +324,22 @@
           Invoke(this, &UberQuicStreamIdManagerTest::SaveControlFrame));
 
   QuicStreamCount stream_count =
-      manager_->advertised_max_allowed_incoming_bidirectional_streams() - 1;
+      manager_->advertised_max_incoming_bidirectional_streams() - 1;
 
   QuicStreamsBlockedFrame frame(kInvalidControlFrameId, stream_count,
                                 /*unidirectional=*/false);
   session_->OnStreamsBlockedFrame(frame);
   EXPECT_EQ(MAX_STREAMS_FRAME, frame_.type);
-  EXPECT_EQ(manager_->actual_max_allowed_incoming_bidirectional_streams(),
+  EXPECT_EQ(manager_->max_incoming_bidirectional_streams(),
             frame_.max_streams_frame.stream_count);
 
-  stream_count =
-      manager_->advertised_max_allowed_incoming_unidirectional_streams() - 1;
+  stream_count = manager_->advertised_max_incoming_unidirectional_streams() - 1;
   frame.stream_count = stream_count;
   frame.unidirectional = true;
 
   session_->OnStreamsBlockedFrame(frame);
   EXPECT_EQ(MAX_STREAMS_FRAME, frame_.type);
-  EXPECT_EQ(manager_->actual_max_allowed_incoming_unidirectional_streams(),
+  EXPECT_EQ(manager_->max_incoming_unidirectional_streams(),
             frame_.max_streams_frame.stream_count);
 }
 
@@ -373,9 +372,9 @@
   manager_->SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
   manager_->SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
   EXPECT_EQ(kNumMaxOutgoingStream,
-            manager_->max_allowed_outgoing_bidirectional_streams());
+            manager_->max_outgoing_bidirectional_streams());
   EXPECT_EQ(kNumMaxOutgoingStream + 1,
-            manager_->max_allowed_outgoing_unidirectional_streams());
+            manager_->max_outgoing_unidirectional_streams());
   // Check that, for each directionality, we can open the correct number of
   // streams.
   int i = kNumMaxOutgoingStream;