diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index d925fea..22252ae 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -1013,7 +1013,10 @@
     QUIC_DVLOG(1) << ENDPOINT
                   << "Setting Bidirectional outgoing_max_streams_ to "
                   << max_streams;
-    v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(max_streams);
+    if (v99_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+            max_streams)) {
+      OnCanCreateNewOutgoingStream(/*unidirectional = */ false);
+    }
 
     max_streams = 0;
     if (config_.HasReceivedMaxUnidirectionalStreams()) {
@@ -1031,7 +1034,10 @@
     QUIC_DVLOG(1) << ENDPOINT
                   << "Setting Unidirectional outgoing_max_streams_ to "
                   << max_streams;
-    v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(max_streams);
+    if (v99_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+            max_streams)) {
+      OnCanCreateNewOutgoingStream(/*unidirectional = */ true);
+    }
   } else {
     uint32_t max_streams = 0;
     if (config_.HasReceivedMaxBidirectionalStreams()) {
@@ -2188,8 +2194,6 @@
   control_frame_manager_.WriteOrBufferStopSending(code, stream_id);
 }
 
-void QuicSession::OnCanCreateNewOutgoingStream(bool /*unidirectional*/) {}
-
 QuicStreamId QuicSession::next_outgoing_bidirectional_stream_id() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.next_outgoing_bidirectional_stream_id();
@@ -2205,7 +2209,17 @@
 }
 
 bool QuicSession::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
-  return v99_streamid_manager_.OnMaxStreamsFrame(frame);
+  const bool allow_new_streams =
+      frame.unidirectional
+          ? v99_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+                frame.stream_count)
+          : v99_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+                frame.stream_count);
+  if (allow_new_streams) {
+    OnCanCreateNewOutgoingStream(frame.unidirectional);
+  }
+
+  return true;
 }
 
 bool QuicSession::OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 06dfd0a..567126a 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -156,7 +156,7 @@
                       bool unidirectional) override;
   // The default implementation does nothing. Subclasses should override if
   // for example they queue up stream requests.
-  void OnCanCreateNewOutgoingStream(bool unidirectional) override;
+  virtual void OnCanCreateNewOutgoingStream(bool /*unidirectional*/) {}
 
   // Called on every incoming packet. Passes |packet| through to |connection_|.
   virtual void ProcessUdpPacket(const QuicSocketAddress& self_address,
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 25237c4..36e0b53 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -12,6 +12,7 @@
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/transport_parameters.h"
+#include "net/third_party/quiche/src/quic/core/frames/quic_max_streams_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
@@ -364,6 +365,10 @@
         kInitialSessionFlowControlWindowForTest);
 
     if (configure_session) {
+      if (VersionHasIetfQuicFrames(transport_version())) {
+        EXPECT_CALL(session_, OnCanCreateNewOutgoingStream(false)).Times(1);
+        EXPECT_CALL(session_, OnCanCreateNewOutgoingStream(true)).Times(1);
+      }
       QuicConfigPeer::SetReceivedMaxBidirectionalStreams(
           session_.config(), kDefaultMaxStreamsPerConnection);
       QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(
@@ -382,6 +387,7 @@
     TestCryptoStream* crypto_stream = session_.GetMutableCryptoStream();
     EXPECT_CALL(*crypto_stream, HasPendingRetransmission())
         .Times(testing::AnyNumber());
+    testing::Mock::VerifyAndClearExpectations(&session_);
   }
 
   ~QuicSessionTestBase() {
@@ -2049,6 +2055,23 @@
       &session_, GetNthClientInitiatedBidirectionalId(1)));
 }
 
+TEST_P(QuicSessionTestClient, OnMaxStreamFrame) {
+  if (!VersionUsesHttp3(transport_version())) {
+    return;
+  }
+  QuicMaxStreamsFrame frame;
+  frame.unidirectional = false;
+  frame.stream_count = 120;
+  EXPECT_CALL(session_, OnCanCreateNewOutgoingStream(false)).Times(1);
+  session_.OnMaxStreamsFrame(frame);
+
+  QuicMaxStreamsFrame frame2;
+  frame2.unidirectional = false;
+  frame2.stream_count = 110;
+  EXPECT_CALL(session_, OnCanCreateNewOutgoingStream(false)).Times(0);
+  session_.OnMaxStreamsFrame(frame2);
+}
+
 TEST_P(QuicSessionTestClient, AvailableUnidirectionalStreamsClient) {
   ASSERT_TRUE(session_.GetOrCreateStream(
                   GetNthServerInitiatedUnidirectionalId(2)) != nullptr);
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index ec0cda9..2878a9b 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -48,17 +48,6 @@
 
 QuicStreamIdManager::~QuicStreamIdManager() {}
 
-bool QuicStreamIdManager::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
-  // Ensure that the frame has the correct directionality.
-  DCHECK_EQ(frame.unidirectional, unidirectional_);
-  QUIC_CODE_COUNT_N(quic_max_streams_received, 2, 2);
-
-  // Set the limit to be exactly the stream count in the frame.
-  // Also informs the higher layers that they can create more
-  // streams if the limit is increased.
-  return SetMaxOpenOutgoingStreams(frame.stream_count);
-}
-
 // The peer sends a streams blocked frame when it can not open any more
 // streams because it has runs into the limit.
 bool QuicStreamIdManager::OnStreamsBlockedFrame(
@@ -83,15 +72,11 @@
   return true;
 }
 
-// Used when configuration has been done and we have an initial
-// maximum stream count from the peer.
-bool QuicStreamIdManager::SetMaxOpenOutgoingStreams(
+bool QuicStreamIdManager::MaybeAllowNewOutgoingStreams(
     QuicStreamCount max_open_streams) {
   if (max_open_streams <= outgoing_max_streams_) {
     // Only update the stream count if it would increase the limit.
-    // If it decreases the limit, or doesn't change it, then do not update.
-    // Note that this handles the case of receiving a count of 0 in the frame
-    return true;
+    return false;
   }
 
   // This implementation only supports 32 bit Stream IDs, so limit max streams
@@ -99,10 +84,6 @@
   outgoing_max_streams_ =
       std::min(max_open_streams, QuicUtils::GetMaxStreamCount());
 
-  // Inform the higher layers that the stream limit has increased and that
-  // new streams may be created.
-  delegate_->OnCanCreateNewOutgoingStream(unidirectional_);
-
   return true;
 }
 
diff --git a/quic/core/quic_stream_id_manager.h b/quic/core/quic_stream_id_manager.h
index da94233..b3079b2 100644
--- a/quic/core/quic_stream_id_manager.h
+++ b/quic/core/quic_stream_id_manager.h
@@ -33,14 +33,6 @@
    public:
     virtual ~DelegateInterface() = default;
 
-    // Called when new outgoing streams are available to be opened. This occurs
-    // when an extant, open, stream is moved to draining or closed.
-    // |unidirectional| indicates whether unidirectional or bidirectional
-    // streams are now available. If both become available at the same time then
-    // there will be two calls to this method, one with unidirectional==true,
-    // the other with it ==false.
-    virtual void OnCanCreateNewOutgoingStream(bool unidirectional) = 0;
-
     // Closes the connection when an error is encountered.
     virtual void OnStreamIdManagerError(QuicErrorCode error_code,
                                         std::string error_details) = 0;
@@ -77,12 +69,6 @@
         ", max_streams_window_: ", max_streams_window_, " }");
   }
 
-  // Processes the MAX_STREAMS frame, invoked from
-  // QuicSession::OnMaxStreamsFrame. It has the same semantics as the
-  // QuicFramerVisitorInterface, returning true if the framer should continue
-  // processing the packet, false if not.
-  bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame);
-
   // Processes the STREAMS_BLOCKED frame, invoked from
   // QuicSession::OnStreamsBlockedFrame. It has the same semantics as the
   // QuicFramerVisitorInterface, returning true if the framer should continue
@@ -108,12 +94,10 @@
 
   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(QuicStreamCount max_open_streams);
+  // Called on |max_open_streams| outgoing streams can be created because of 1)
+  // config negotiated or 2) MAX_STREAMS received. Returns true if new
+  // streams can be created.
+  bool MaybeAllowNewOutgoingStreams(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
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 17d76b2..73a4ff9 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -139,8 +139,8 @@
   // Ensure that the limit is less than the implementation maximum.
   EXPECT_LT(stream_id_manager_.outgoing_max_streams(), implementation_max);
 
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidirectional()));
-  stream_id_manager_.SetMaxOpenOutgoingStreams(implementation_max + 1);
+  EXPECT_TRUE(
+      stream_id_manager_.MaybeAllowNewOutgoingStreams(implementation_max + 1));
   // Should be pegged at the max.
   EXPECT_EQ(implementation_max, stream_id_manager_.outgoing_max_streams());
 }
@@ -210,34 +210,6 @@
   EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
 }
 
-TEST_P(QuicStreamIdManagerTest, OnMaxStreamsFrame) {
-  QuicMaxStreamsFrame frame;
-  frame.stream_count = 10;
-
-  frame.unidirectional = IsUnidirectional();
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidirectional()));
-  EXPECT_TRUE(stream_id_manager_.OnMaxStreamsFrame(frame));
-  EXPECT_EQ(10u, stream_id_manager_.outgoing_max_streams());
-
-  QuicStreamCount save_outgoing_max_streams =
-      stream_id_manager_.outgoing_max_streams();
-  // Now that there has been one MAX STREAMS frame, we should not
-  // accept a MAX_STREAMS that reduces the limit...
-  frame.stream_count = 8;
-  frame.unidirectional = IsUnidirectional();
-  EXPECT_TRUE(stream_id_manager_.OnMaxStreamsFrame(frame));
-  // should not change from previous setting.
-  EXPECT_EQ(save_outgoing_max_streams,
-            stream_id_manager_.outgoing_max_streams());
-
-  // A stream count greater than the current limit should increase the limit.
-  frame.stream_count = 12;
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidirectional()));
-  EXPECT_TRUE(stream_id_manager_.OnMaxStreamsFrame(frame));
-
-  EXPECT_EQ(12u, stream_id_manager_.outgoing_max_streams());
-}
-
 TEST_P(QuicStreamIdManagerTest, OnStreamsBlockedFrame) {
   // Get the current maximum allowed incoming stream count.
   QuicStreamCount advertised_stream_count =
@@ -299,8 +271,8 @@
   // opening...
   size_t number_of_streams = kDefaultMaxStreamsPerConnection;
 
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidirectional()));
-  stream_id_manager_.SetMaxOpenOutgoingStreams(kDefaultMaxStreamsPerConnection);
+  EXPECT_TRUE(
+      stream_id_manager_.MaybeAllowNewOutgoingStreams(number_of_streams));
 
   QuicStreamId stream_id =
       IsUnidirectional()
@@ -426,13 +398,6 @@
   stream_id_manager_.OnStreamsBlockedFrame(frame);
 }
 
-TEST_P(QuicStreamIdManagerTest, CheckMaxAllowedOutgoingInitialization) {
-  const size_t kIncomingStreamCount = 123;
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidirectional()));
-  stream_id_manager_.SetMaxOpenOutgoingStreams(kIncomingStreamCount);
-  EXPECT_EQ(kIncomingStreamCount, stream_id_manager_.outgoing_max_streams());
-}
-
 // Test that a MAX_STREAMS frame is generated when half the stream ids become
 // available. This has a useful side effect of testing that when streams are
 // closed, the number of available stream ids increases.
@@ -462,8 +427,7 @@
 }
 
 TEST_P(QuicStreamIdManagerTest, NewStreamDoesNotExceedLimit) {
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidirectional()));
-  stream_id_manager_.SetMaxOpenOutgoingStreams(100);
+  EXPECT_TRUE(stream_id_manager_.MaybeAllowNewOutgoingStreams(100));
 
   size_t stream_count = stream_id_manager_.outgoing_max_streams();
   EXPECT_NE(0u, stream_count);
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index e85336f..7ef5688 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -31,13 +31,15 @@
           max_open_outgoing_unidirectional_streams,
           max_open_incoming_unidirectional_streams) {}
 
-void UberQuicStreamIdManager::SetMaxOpenOutgoingBidirectionalStreams(
+bool UberQuicStreamIdManager::MaybeAllowNewOutgoingBidirectionalStreams(
     QuicStreamCount max_open_streams) {
-  bidirectional_stream_id_manager_.SetMaxOpenOutgoingStreams(max_open_streams);
+  return bidirectional_stream_id_manager_.MaybeAllowNewOutgoingStreams(
+      max_open_streams);
 }
-void UberQuicStreamIdManager::SetMaxOpenOutgoingUnidirectionalStreams(
+bool UberQuicStreamIdManager::MaybeAllowNewOutgoingUnidirectionalStreams(
     QuicStreamCount max_open_streams) {
-  unidirectional_stream_id_manager_.SetMaxOpenOutgoingStreams(max_open_streams);
+  return unidirectional_stream_id_manager_.MaybeAllowNewOutgoingStreams(
+      max_open_streams);
 }
 void UberQuicStreamIdManager::SetMaxOpenIncomingBidirectionalStreams(
     QuicStreamCount max_open_streams) {
@@ -81,14 +83,6 @@
   unidirectional_stream_id_manager_.OnStreamClosed(id);
 }
 
-bool UberQuicStreamIdManager::OnMaxStreamsFrame(
-    const QuicMaxStreamsFrame& frame) {
-  if (frame.unidirectional) {
-    return unidirectional_stream_id_manager_.OnMaxStreamsFrame(frame);
-  }
-  return bidirectional_stream_id_manager_.OnMaxStreamsFrame(frame);
-}
-
 bool UberQuicStreamIdManager::OnStreamsBlockedFrame(
     const QuicStreamsBlockedFrame& frame) {
   if (frame.unidirectional) {
diff --git a/quic/core/uber_quic_stream_id_manager.h b/quic/core/uber_quic_stream_id_manager.h
index bc76be3..b505487 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -30,10 +30,15 @@
       QuicStreamCount max_open_incoming_bidirectional_streams,
       QuicStreamCount max_open_incoming_unidirectional_streams);
 
-  // Sets the limits to max_open_streams.
-  void SetMaxOpenOutgoingBidirectionalStreams(QuicStreamCount max_open_streams);
-  void SetMaxOpenOutgoingUnidirectionalStreams(
+  // Called on |max_open_streams| outgoing streams can be created because of 1)
+  // config negotiated or 2) MAX_STREAMS received. Returns true if new
+  // streams can be created.
+  bool MaybeAllowNewOutgoingBidirectionalStreams(
       QuicStreamCount max_open_streams);
+  bool MaybeAllowNewOutgoingUnidirectionalStreams(
+      QuicStreamCount max_open_streams);
+
+  // Sets the limits to max_open_streams.
   void SetMaxOpenIncomingBidirectionalStreams(QuicStreamCount max_open_streams);
   void SetMaxOpenIncomingUnidirectionalStreams(
       QuicStreamCount max_open_streams);
@@ -56,9 +61,6 @@
   // Called when |id| is released.
   void OnStreamClosed(QuicStreamId id);
 
-  // Called when a MAX_STREAMS frame is received.
-  bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame);
-
   // Called when a STREAMS_BLOCKED frame is received.
   bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame);
 
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index a8f86a6..3522008 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -146,10 +146,10 @@
   const size_t kNumMaxOutgoingStream = 123;
   // Set the uni- and bi- directional limits to different values to ensure
   // that they are managed separately.
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(false));
-  manager_.SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(true));
-  manager_.SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
+  EXPECT_TRUE(manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+      kNumMaxOutgoingStream));
+  EXPECT_TRUE(manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+      kNumMaxOutgoingStream + 1));
   EXPECT_EQ(kNumMaxOutgoingStream,
             manager_.max_outgoing_bidirectional_streams());
   EXPECT_EQ(kNumMaxOutgoingStream + 1,
@@ -209,9 +209,8 @@
 }
 
 TEST_P(UberQuicStreamIdManagerTest, GetNextOutgoingStreamId) {
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(_)).Times(2);
-  manager_.SetMaxOpenOutgoingBidirectionalStreams(10);
-  manager_.SetMaxOpenOutgoingUnidirectionalStreams(10);
+  EXPECT_TRUE(manager_.MaybeAllowNewOutgoingBidirectionalStreams(10));
+  EXPECT_TRUE(manager_.MaybeAllowNewOutgoingUnidirectionalStreams(10));
   EXPECT_EQ(GetNthSelfInitiatedBidirectionalStreamId(0),
             manager_.GetNextOutgoingBidirectionalStreamId());
   EXPECT_EQ(GetNthSelfInitiatedBidirectionalStreamId(1),
@@ -267,52 +266,6 @@
       QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/false)));
 }
 
-TEST_P(UberQuicStreamIdManagerTest, OnMaxStreamsFrame) {
-  QuicStreamCount max_outgoing_bidirectional_stream_count =
-      manager_.max_outgoing_bidirectional_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_outgoing_bidirectional_stream_count,
-                            /*unidirectional=*/false);
-  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
-  EXPECT_EQ(max_outgoing_bidirectional_stream_count,
-            manager_.max_outgoing_bidirectional_streams());
-
-  // Now try the unidirectioanl manager
-  frame.stream_count = max_outgoing_unidirectional_stream_count;
-  frame.unidirectional = true;
-  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
-  EXPECT_EQ(max_outgoing_unidirectional_stream_count,
-            manager_.max_outgoing_unidirectional_streams());
-
-  // Now try to increase the bidirectional stream count.
-  frame.stream_count = max_outgoing_bidirectional_stream_count + 1;
-  frame.unidirectional = false;
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
-  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
-  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_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_outgoing_unidirectional_stream_count + 1;
-  frame.unidirectional = true;
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
-  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
-  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) {
   QuicStreamCount stream_count =
       manager_.advertised_max_incoming_bidirectional_streams() - 1;
@@ -349,10 +302,10 @@
   const size_t kNumMaxOutgoingStream = 123;
   // Set the uni- and bi- directional limits to different values to ensure
   // that they are managed separately.
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(false));
-  manager_.SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(true));
-  manager_.SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
+  EXPECT_TRUE(manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+      kNumMaxOutgoingStream));
+  EXPECT_TRUE(manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+      kNumMaxOutgoingStream + 1));
   EXPECT_EQ(kNumMaxOutgoingStream,
             manager_.max_outgoing_bidirectional_streams());
   EXPECT_EQ(kNumMaxOutgoingStream + 1,
@@ -374,16 +327,6 @@
   // Both should be exhausted...
   EXPECT_FALSE(manager_.CanOpenNextOutgoingUnidirectionalStream());
   EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
-
-  // Now cons a MAX STREAMS frame for unidirectional streams to raise
-  // the limit.
-  QuicMaxStreamsFrame frame(1, kNumMaxOutgoingStream + 10,
-                            /*unidirectional=*/true);
-  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
-  manager_.OnMaxStreamsFrame(frame);
-  // We now should be able to get another uni- stream, but not a bi.
-  EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
-  EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
 }
 
 }  // namespace
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 70f6e5c..cbaf5d6 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -75,10 +75,6 @@
                                                 uint32_t max_streams) {
   if (VersionHasIetfQuicFrames(session->transport_version())) {
     QUIC_BUG << "SetmaxOpenOutgoingStreams deprecated for IETF QUIC";
-    session->v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(
-        max_streams);
-    session->v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(
-        max_streams);
     return;
   }
   session->stream_id_manager_.set_max_open_outgoing_streams(max_streams);
@@ -91,7 +87,7 @@
   DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
          "QUIC";
-  session->v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(
+  session->v99_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
       max_streams);
 }
 // static
@@ -101,7 +97,7 @@
   DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
          "QUIC";
-  session->v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(
+  session->v99_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
       max_streams);
 }