diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 9d0c7bf..cfe7b3f 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -61,6 +61,8 @@
                          kDefaultMaxStreamsPerConnection,
                          config_.GetMaxIncomingBidirectionalStreamsToSend()),
       v99_streamid_manager_(
+          perspective(),
+          connection->version(),
           this,
           num_expected_unidirectional_static_streams,
           kDefaultMaxStreamsPerConnection,
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index 98c6e8c..f258384 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -10,24 +10,26 @@
 namespace quic {
 
 UberQuicStreamIdManager::UberQuicStreamIdManager(
-    QuicSession* session,
+    Perspective perspective,
+    ParsedQuicVersion version,
+    QuicStreamIdManager::DelegateInterface* delegate,
     QuicStreamCount num_expected_unidirectiona_static_streams,
     QuicStreamCount max_open_outgoing_bidirectional_streams,
     QuicStreamCount max_open_outgoing_unidirectional_streams,
     QuicStreamCount max_open_incoming_bidirectional_streams,
     QuicStreamCount max_open_incoming_unidirectional_streams)
-    : bidirectional_stream_id_manager_(session,
+    : bidirectional_stream_id_manager_(delegate,
                                        /*unidirectional=*/false,
-                                       session->perspective(),
-                                       session->transport_version(),
+                                       perspective,
+                                       version.transport_version,
                                        0,
                                        max_open_outgoing_bidirectional_streams,
                                        max_open_incoming_bidirectional_streams),
       unidirectional_stream_id_manager_(
-          session,
+          delegate,
           /*unidirectional=*/true,
-          session->perspective(),
-          session->transport_version(),
+          perspective,
+          version.transport_version,
           num_expected_unidirectiona_static_streams,
           max_open_outgoing_unidirectional_streams,
           max_open_incoming_unidirectional_streams) {}
diff --git a/quic/core/uber_quic_stream_id_manager.h b/quic/core/uber_quic_stream_id_manager.h
index dab571d..a725fdd 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -21,8 +21,10 @@
 class QUIC_EXPORT_PRIVATE UberQuicStreamIdManager {
  public:
   UberQuicStreamIdManager(
-      QuicSession* session,
-      QuicStreamCount num_expected_unidirectiona_static_streams,
+      Perspective perspective,
+      ParsedQuicVersion version,
+      QuicStreamIdManager::DelegateInterface* delegate,
+      QuicStreamCount num_expected_unidirectional_static_streams,
       QuicStreamCount max_open_outgoing_bidirectional_streams,
       QuicStreamCount max_open_outgoing_unidirectional_streams,
       QuicStreamCount max_open_incoming_bidirectional_streams,
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index b4ef1cc..265756f 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -6,7 +6,6 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_id_manager_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 
@@ -17,24 +16,28 @@
 namespace test {
 namespace {
 
-class UberQuicStreamIdManagerTest : public QuicTestWithParam<Perspective> {
+class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
-  bool SaveControlFrame(const QuicFrame& frame) {
-    frame_ = frame;
-    return true;
-  }
+  MOCK_METHOD1(OnCanCreateNewOutgoingStream, void(bool unidirectional));
+  MOCK_METHOD2(OnError,
+               void(QuicErrorCode error_code, std::string error_details));
+  MOCK_METHOD2(SendMaxStreams,
+               void(QuicStreamCount stream_count, bool unidirectional));
+  MOCK_METHOD2(SendStreamsBlocked,
+               void(QuicStreamCount stream_count, bool unidirectional));
+};
 
+class UberQuicStreamIdManagerTest : public QuicTestWithParam<Perspective> {
  protected:
   UberQuicStreamIdManagerTest()
-      : connection_(new MockQuicConnection(
-            &helper_,
-            &alarm_factory_,
-            GetParam(),
-            ParsedQuicVersionVector(
-                {{PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99}}))) {
-    session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
-    manager_ = QuicSessionPeer::v99_streamid_manager(session_.get());
-  }
+      : manager_(perspective(),
+                 version(),
+                 &delegate_,
+                 /*num_expected_unidirectional_static_streams=*/0,
+                 kDefaultMaxStreamsPerConnection,
+                 kDefaultMaxStreamsPerConnection,
+                 kDefaultMaxStreamsPerConnection,
+                 kDefaultMaxStreamsPerConnection) {}
 
   QuicStreamId GetNthClientInitiatedBidirectionalId(int n) {
     return QuicUtils::GetFirstBidirectionalStreamId(transport_version(),
@@ -92,16 +95,13 @@
            ((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
   }
 
-  QuicTransportVersion transport_version() {
-    return connection_->transport_version();
-  }
+  ParsedQuicVersion version() { return {PROTOCOL_TLS1_3, transport_version()}; }
+  QuicTransportVersion transport_version() { return QUIC_VERSION_99; }
 
-  MockQuicConnectionHelper helper_;
-  MockAlarmFactory alarm_factory_;
-  MockQuicConnection* connection_;
-  std::unique_ptr<StrictMock<MockQuicSession>> session_;
-  UberQuicStreamIdManager* manager_;
-  QuicFrame frame_;
+  Perspective perspective() { return GetParam(); }
+
+  testing::StrictMock<MockDelegate> delegate_;
+  UberQuicStreamIdManager manager_;
 };
 
 INSTANTIATE_TEST_SUITE_P(Tests,
@@ -111,16 +111,16 @@
                          ::testing::PrintToStringParamName());
 
 TEST_P(UberQuicStreamIdManagerTest, Initialization) {
-  if (GetParam() == Perspective::IS_SERVER) {
+  if (perspective() == Perspective::IS_SERVER) {
     EXPECT_EQ(GetNthServerInitiatedBidirectionalId(0),
-              manager_->next_outgoing_bidirectional_stream_id());
+              manager_.next_outgoing_bidirectional_stream_id());
     EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(0),
-              manager_->next_outgoing_unidirectional_stream_id());
+              manager_.next_outgoing_unidirectional_stream_id());
   } else {
     EXPECT_EQ(GetNthClientInitiatedBidirectionalId(0),
-              manager_->next_outgoing_bidirectional_stream_id());
+              manager_.next_outgoing_bidirectional_stream_id());
     EXPECT_EQ(GetNthClientInitiatedUnidirectionalId(0),
-              manager_->next_outgoing_unidirectional_stream_id());
+              manager_.next_outgoing_unidirectional_stream_id());
   }
 }
 
@@ -128,240 +128,240 @@
   const size_t kNumMaxOutgoingStream = 123;
   // Set the uni- and bi- directional limits to different values to ensure
   // that they are managed separately.
-  manager_->SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
-  manager_->SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(false));
+  manager_.SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(true));
+  manager_.SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
   EXPECT_EQ(kNumMaxOutgoingStream,
-            manager_->max_outgoing_bidirectional_streams());
+            manager_.max_outgoing_bidirectional_streams());
   EXPECT_EQ(kNumMaxOutgoingStream + 1,
-            manager_->max_outgoing_unidirectional_streams());
+            manager_.max_outgoing_unidirectional_streams());
   // Check that, for each directionality, we can open the correct number of
   // streams.
   int i = kNumMaxOutgoingStream;
   while (i) {
-    EXPECT_TRUE(manager_->CanOpenNextOutgoingBidirectionalStream());
-    manager_->GetNextOutgoingBidirectionalStreamId();
-    EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
-    manager_->GetNextOutgoingUnidirectionalStreamId();
+    EXPECT_TRUE(manager_.CanOpenNextOutgoingBidirectionalStream());
+    manager_.GetNextOutgoingBidirectionalStreamId();
+    EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+    manager_.GetNextOutgoingUnidirectionalStreamId();
     i--;
   }
   // One more unidirectional
-  EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
-  manager_->GetNextOutgoingUnidirectionalStreamId();
+  EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+  manager_.GetNextOutgoingUnidirectionalStreamId();
 
   // Both should be exhausted...
-  EXPECT_FALSE(manager_->CanOpenNextOutgoingUnidirectionalStream());
-  EXPECT_FALSE(manager_->CanOpenNextOutgoingBidirectionalStream());
+  EXPECT_FALSE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+  EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
 }
 
 TEST_P(UberQuicStreamIdManagerTest, SetMaxOpenIncomingStreams) {
   const size_t kNumMaxIncomingStreams = 456;
-  manager_->SetMaxOpenIncomingUnidirectionalStreams(kNumMaxIncomingStreams);
+  manager_.SetMaxOpenIncomingUnidirectionalStreams(kNumMaxIncomingStreams);
   // Do +1 for bidirectional to ensure that uni- and bi- get properly set.
-  manager_->SetMaxOpenIncomingBidirectionalStreams(kNumMaxIncomingStreams + 1);
+  manager_.SetMaxOpenIncomingBidirectionalStreams(kNumMaxIncomingStreams + 1);
   EXPECT_EQ(kNumMaxIncomingStreams + 1,
-            manager_->GetMaxAllowdIncomingBidirectionalStreams());
+            manager_.GetMaxAllowdIncomingBidirectionalStreams());
   EXPECT_EQ(kNumMaxIncomingStreams,
-            manager_->GetMaxAllowdIncomingUnidirectionalStreams());
-  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());
+            manager_.GetMaxAllowdIncomingUnidirectionalStreams());
+  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;
   for (i = 0; i < kNumMaxIncomingStreams; i++) {
-    EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+    EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
         GetNthPeerInitiatedUnidirectionalStreamId(i)));
-    EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+    EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
         GetNthPeerInitiatedBidirectionalStreamId(i)));
   }
   // Should be able to open the next bidirectional stream
-  EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+  EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
       GetNthPeerInitiatedBidirectionalStreamId(i)));
 
   // We should have exhausted the counts, the next streams should fail
-  EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, _));
+  EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
       GetNthPeerInitiatedUnidirectionalStreamId(i)));
-  EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, _));
+  EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
       GetNthPeerInitiatedBidirectionalStreamId(i + 1)));
 }
 
 TEST_P(UberQuicStreamIdManagerTest, GetNextOutgoingStreamId) {
-  if (GetParam() == Perspective::IS_SERVER) {
+  if (perspective() == Perspective::IS_SERVER) {
     EXPECT_EQ(GetNthServerInitiatedBidirectionalId(0),
-              manager_->GetNextOutgoingBidirectionalStreamId());
+              manager_.GetNextOutgoingBidirectionalStreamId());
     EXPECT_EQ(GetNthServerInitiatedBidirectionalId(1),
-              manager_->GetNextOutgoingBidirectionalStreamId());
+              manager_.GetNextOutgoingBidirectionalStreamId());
     EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(0),
-              manager_->GetNextOutgoingUnidirectionalStreamId());
+              manager_.GetNextOutgoingUnidirectionalStreamId());
     EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(1),
-              manager_->GetNextOutgoingUnidirectionalStreamId());
+              manager_.GetNextOutgoingUnidirectionalStreamId());
   } else {
     EXPECT_EQ(GetNthClientInitiatedBidirectionalId(0),
-              manager_->GetNextOutgoingBidirectionalStreamId());
+              manager_.GetNextOutgoingBidirectionalStreamId());
     EXPECT_EQ(GetNthClientInitiatedBidirectionalId(1),
-              manager_->GetNextOutgoingBidirectionalStreamId());
+              manager_.GetNextOutgoingBidirectionalStreamId());
     EXPECT_EQ(GetNthClientInitiatedUnidirectionalId(0),
-              manager_->GetNextOutgoingUnidirectionalStreamId());
+              manager_.GetNextOutgoingUnidirectionalStreamId());
     EXPECT_EQ(GetNthClientInitiatedUnidirectionalId(1),
-              manager_->GetNextOutgoingUnidirectionalStreamId());
+              manager_.GetNextOutgoingUnidirectionalStreamId());
   }
 }
 
 TEST_P(UberQuicStreamIdManagerTest, AvailableStreams) {
-  if (GetParam() == Perspective::IS_SERVER) {
-    EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+  if (perspective() == Perspective::IS_SERVER) {
+    EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
         GetNthClientInitiatedBidirectionalId(3)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthClientInitiatedBidirectionalId(1)));
+        manager_.IsAvailableStream(GetNthClientInitiatedBidirectionalId(1)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthClientInitiatedBidirectionalId(2)));
+        manager_.IsAvailableStream(GetNthClientInitiatedBidirectionalId(2)));
 
-    EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+    EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
         GetNthClientInitiatedUnidirectionalId(3)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthClientInitiatedUnidirectionalId(1)));
+        manager_.IsAvailableStream(GetNthClientInitiatedUnidirectionalId(1)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthClientInitiatedUnidirectionalId(2)));
+        manager_.IsAvailableStream(GetNthClientInitiatedUnidirectionalId(2)));
   } else {
-    EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+    EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
         GetNthServerInitiatedBidirectionalId(3)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthServerInitiatedBidirectionalId(1)));
+        manager_.IsAvailableStream(GetNthServerInitiatedBidirectionalId(1)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthServerInitiatedBidirectionalId(2)));
+        manager_.IsAvailableStream(GetNthServerInitiatedBidirectionalId(2)));
 
-    EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+    EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
         GetNthServerInitiatedUnidirectionalId(3)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthServerInitiatedUnidirectionalId(1)));
+        manager_.IsAvailableStream(GetNthServerInitiatedUnidirectionalId(1)));
     EXPECT_TRUE(
-        manager_->IsAvailableStream(GetNthServerInitiatedUnidirectionalId(2)));
+        manager_.IsAvailableStream(GetNthServerInitiatedUnidirectionalId(2)));
   }
 }
 
 TEST_P(UberQuicStreamIdManagerTest, MaybeIncreaseLargestPeerStreamId) {
-  EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
-  EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->max_incoming_bidirectional_streams(),
-      QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/true)));
-  EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->max_incoming_bidirectional_streams(),
-      QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/false)));
+  EXPECT_CALL(delegate_, OnError(_, _)).Times(0);
+  EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+      manager_.max_incoming_bidirectional_streams(),
+      QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/true)));
+  EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+      manager_.max_incoming_bidirectional_streams(),
+      QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/false)));
 
   std::string error_details =
-      GetParam() == Perspective::IS_SERVER
+      perspective() == Perspective::IS_SERVER
           ? "Stream id 400 would exceed stream count limit 100"
           : "Stream id 401 would exceed stream count limit 100";
 
-  EXPECT_CALL(*connection_,
-              CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
-  EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->max_incoming_bidirectional_streams() + 1,
-      QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/true)));
-  error_details = GetParam() == Perspective::IS_SERVER
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, error_details));
+  EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+      manager_.max_incoming_bidirectional_streams() + 1,
+      QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/true)));
+  error_details = perspective() == Perspective::IS_SERVER
                       ? "Stream id 402 would exceed stream count limit 100"
                       : "Stream id 403 would exceed stream count limit 100";
-  EXPECT_CALL(*connection_,
-              CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
-  EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_->max_incoming_bidirectional_streams() + 1,
-      QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/false)));
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, error_details));
+  EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+      manager_.max_incoming_bidirectional_streams() + 1,
+      QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/false)));
 }
 
 TEST_P(UberQuicStreamIdManagerTest, OnMaxStreamsFrame) {
   QuicStreamCount max_outgoing_bidirectional_stream_count =
-      manager_->max_outgoing_bidirectional_streams();
+      manager_.max_outgoing_bidirectional_streams();
 
   QuicStreamCount max_outgoing_unidirectional_stream_count =
-      manager_->max_outgoing_unidirectional_streams();
+      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_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
   EXPECT_EQ(max_outgoing_bidirectional_stream_count,
-            manager_->max_outgoing_bidirectional_streams());
+            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_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
   EXPECT_EQ(max_outgoing_unidirectional_stream_count,
-            manager_->max_outgoing_unidirectional_streams());
+            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_TRUE(manager_->OnMaxStreamsFrame(frame));
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
   EXPECT_EQ(max_outgoing_bidirectional_stream_count + 1,
-            manager_->max_outgoing_bidirectional_streams());
+            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());
+            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_TRUE(manager_->OnMaxStreamsFrame(frame));
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+  EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
   EXPECT_EQ(max_outgoing_bidirectional_stream_count + 1,
-            manager_->max_outgoing_bidirectional_streams());
+            manager_.max_outgoing_bidirectional_streams());
   EXPECT_EQ(max_outgoing_unidirectional_stream_count + 1,
-            manager_->max_outgoing_unidirectional_streams());
+            manager_.max_outgoing_unidirectional_streams());
 }
 
 TEST_P(UberQuicStreamIdManagerTest, OnStreamsBlockedFrame) {
   // Allow MAX_STREAMS frame transmission
-  manager_->OnConfigNegotiated();
-  // Set up to capture calls to SendControlFrame - when a STREAMS_BLOCKED
-  // frame is received, it will result in a a new MAX_STREAMS frame being
-  // sent (if new streams can be made available).
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillRepeatedly(
-          Invoke(this, &UberQuicStreamIdManagerTest::SaveControlFrame));
+  manager_.OnConfigNegotiated();
 
   QuicStreamCount stream_count =
-      manager_->advertised_max_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_->max_incoming_bidirectional_streams(),
-            frame_.max_streams_frame.stream_count);
+  EXPECT_CALL(delegate_,
+              SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+                             frame.unidirectional));
+  manager_.OnStreamsBlockedFrame(frame);
 
-  stream_count = manager_->advertised_max_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_->max_incoming_unidirectional_streams(),
-            frame_.max_streams_frame.stream_count);
+  EXPECT_CALL(delegate_,
+              SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+                             frame.unidirectional));
+  manager_.OnStreamsBlockedFrame(frame);
 }
 
 TEST_P(UberQuicStreamIdManagerTest, IsIncomingStream) {
-  if (GetParam() == Perspective::IS_SERVER) {
+  if (perspective() == Perspective::IS_SERVER) {
     EXPECT_TRUE(
-        manager_->IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
     EXPECT_TRUE(
-        manager_->IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
     EXPECT_FALSE(
-        manager_->IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
     EXPECT_FALSE(
-        manager_->IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
   } else {
     EXPECT_FALSE(
-        manager_->IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
     EXPECT_FALSE(
-        manager_->IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
     EXPECT_TRUE(
-        manager_->IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
     EXPECT_TRUE(
-        manager_->IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
+        manager_.IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
   }
 }
 
@@ -369,38 +369,41 @@
   const size_t kNumMaxOutgoingStream = 123;
   // Set the uni- and bi- directional limits to different values to ensure
   // that they are managed separately.
-  manager_->SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
-  manager_->SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(false));
+  manager_.SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(true));
+  manager_.SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
   EXPECT_EQ(kNumMaxOutgoingStream,
-            manager_->max_outgoing_bidirectional_streams());
+            manager_.max_outgoing_bidirectional_streams());
   EXPECT_EQ(kNumMaxOutgoingStream + 1,
-            manager_->max_outgoing_unidirectional_streams());
+            manager_.max_outgoing_unidirectional_streams());
   // Check that, for each directionality, we can open the correct number of
   // streams.
   int i = kNumMaxOutgoingStream;
   while (i) {
-    EXPECT_TRUE(manager_->CanOpenNextOutgoingBidirectionalStream());
-    manager_->GetNextOutgoingBidirectionalStreamId();
-    EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
-    manager_->GetNextOutgoingUnidirectionalStreamId();
+    EXPECT_TRUE(manager_.CanOpenNextOutgoingBidirectionalStream());
+    manager_.GetNextOutgoingBidirectionalStreamId();
+    EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+    manager_.GetNextOutgoingUnidirectionalStreamId();
     i--;
   }
   // One more unidirectional
-  EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
-  manager_->GetNextOutgoingUnidirectionalStreamId();
+  EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+  manager_.GetNextOutgoingUnidirectionalStreamId();
 
   // Both should be exhausted...
-  EXPECT_FALSE(manager_->CanOpenNextOutgoingUnidirectionalStream());
-  EXPECT_FALSE(manager_->CanOpenNextOutgoingBidirectionalStream());
+  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);
-  manager_->OnMaxStreamsFrame(frame);
+  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());
+  EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+  EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
 }
 
 }  // namespace