diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index abeed2b..3bd13bc 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -310,6 +310,8 @@
 
 Http3DebugVisitor::~Http3DebugVisitor() {}
 
+// Expected unidirectional static streams Requirement can be found at
+// https://tools.ietf.org/html/draft-ietf-quic-http-22#section-6.2.
 QuicSpdySession::QuicSpdySession(
     QuicConnection* connection,
     QuicSession::Visitor* visitor,
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 23873d0..9d0c7bf 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -62,6 +62,7 @@
                          config_.GetMaxIncomingBidirectionalStreamsToSend()),
       v99_streamid_manager_(
           this,
+          num_expected_unidirectional_static_streams,
           kDefaultMaxStreamsPerConnection,
           kDefaultMaxStreamsPerConnection,
           config_.GetMaxIncomingBidirectionalStreamsToSend(),
@@ -771,6 +772,12 @@
   control_frame_manager_.WriteOrBufferWindowUpdate(id, byte_offset);
 }
 
+void QuicSession::OnError(QuicErrorCode error_code, std::string error_details) {
+  connection_->CloseConnection(
+      error_code, error_details,
+      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+}
+
 void QuicSession::SendMaxStreams(QuicStreamCount stream_count,
                                  bool unidirectional) {
   control_frame_manager_.WriteOrBufferMaxStreams(stream_count, unidirectional);
@@ -1049,6 +1056,7 @@
   // STREAMS_BLOCKED or MAX_STREAMS frames against the config and either send
   // the frames or discard them.
   if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+    QuicConnection::ScopedPacketFlusher flusher(connection());
     v99_streamid_manager_.OnConfigNegotiated();
   }
 }
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 6fb4c8d..758106f 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -41,9 +41,11 @@
 class QuicSessionPeer;
 }  // namespace test
 
-class QUIC_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface,
-                                        public SessionNotifierInterface,
-                                        public QuicStreamFrameDataProducer {
+class QUIC_EXPORT_PRIVATE QuicSession
+    : public QuicConnectionVisitorInterface,
+      public SessionNotifierInterface,
+      public QuicStreamFrameDataProducer,
+      public QuicStreamIdManager::DelegateInterface {
  public:
   // An interface from the session to the entity owning the session.
   // This lets the session notify its owner (the Dispatcher) when the connection
@@ -147,6 +149,16 @@
   bool HasUnackedCryptoData() const override;
   bool HasUnackedStreamData() const override;
 
+  // QuicStreamIdManager::DelegateInterface methods:
+  void OnError(QuicErrorCode error_code, std::string error_details) override;
+  void SendMaxStreams(QuicStreamCount stream_count,
+                      bool unidirectional) override;
+  void SendStreamsBlocked(QuicStreamCount stream_count,
+                          bool unidirectional) override;
+  // The default implementation does nothing. Subclasses should override if
+  // for example they queue up stream requests.
+  void OnCanCreateNewOutgoingStream(bool unidirectional) override;
+
   // Called on every incoming packet. Passes |packet| through to |connection_|.
   virtual void ProcessUdpPacket(const QuicSocketAddress& self_address,
                                 const QuicSocketAddress& peer_address,
@@ -210,12 +222,6 @@
   // Sends a WINDOW_UPDATE frame.
   virtual void SendWindowUpdate(QuicStreamId id, QuicStreamOffset byte_offset);
 
-  // Send a MAX_STREAMS frame.
-  void SendMaxStreams(QuicStreamCount stream_count, bool unidirectional);
-
-  // Send a STREAMS_BLOCKED frame.
-  void SendStreamsBlocked(QuicStreamCount stream_count, bool unidirectional);
-
   // Create and transmit a STOP_SENDING frame
   virtual void SendStopSending(uint16_t code, QuicStreamId stream_id);
 
@@ -404,14 +410,6 @@
     return supported_versions_;
   }
 
-  // Called when new outgoing streams are available to be opened. This occurs
-  // when an extant, open, stream is moved to draining or closed. The default
-  // implementation does nothing. |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);
-
   QuicStreamId next_outgoing_bidirectional_stream_id() const;
   QuicStreamId next_outgoing_unidirectional_stream_id() const;
 
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index 9d94157..57fd0a4 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -16,17 +16,23 @@
 
 namespace quic {
 
-#define ENDPOINT                                                   \
-  (session_->perspective() == Perspective::IS_SERVER ? " Server: " \
-                                                     : " Client: ")
+#define ENDPOINT \
+  (perspective_ == Perspective::IS_SERVER ? " Server: " : " Client: ")
 
 QuicStreamIdManager::QuicStreamIdManager(
-    QuicSession* session,
+    DelegateInterface* delegate,
     bool unidirectional,
+    Perspective perspective,
+    QuicTransportVersion transport_version,
+    QuicStreamCount num_expected_static_streams,
     QuicStreamCount max_allowed_outgoing_streams,
     QuicStreamCount max_allowed_incoming_streams)
-    : session_(session),
+    : delegate_(delegate),
       unidirectional_(unidirectional),
+      perspective_(perspective),
+      transport_version_(transport_version),
+      num_expected_static_streams_(num_expected_static_streams),
+      is_config_negotiated_(false),
       outgoing_max_streams_(max_allowed_outgoing_streams),
       next_outgoing_stream_id_(GetFirstOutgoingStreamId()),
       outgoing_stream_count_(0),
@@ -38,16 +44,15 @@
       incoming_initial_max_open_streams_(max_allowed_incoming_streams),
       incoming_stream_count_(0),
       largest_peer_created_stream_id_(
-          QuicUtils::GetInvalidStreamId(transport_version())),
+          QuicUtils::GetInvalidStreamId(transport_version)),
       max_streams_window_(0),
       pending_max_streams_(false),
       pending_streams_blocked_(
-          QuicUtils::GetInvalidStreamId(transport_version())) {
+          QuicUtils::GetInvalidStreamId(transport_version)) {
   CalculateIncomingMaxStreamsWindow();
 }
 
-QuicStreamIdManager::~QuicStreamIdManager() {
-}
+QuicStreamIdManager::~QuicStreamIdManager() {}
 
 bool QuicStreamIdManager::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
   // Ensure that the frame has the correct directionality.
@@ -74,9 +79,8 @@
     // TODO(fkastenholz): revise when proper IETF Connection Close support is
     // done.
     QUIC_CODE_COUNT(quic_streams_blocked_too_big);
-    session_->connection()->CloseConnection(
-        QUIC_STREAMS_BLOCKED_ERROR, "Invalid stream count specified",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+    delegate_->OnError(QUIC_STREAMS_BLOCKED_ERROR,
+                       "Invalid stream count specified");
     return false;
   }
   if (frame.stream_count < incoming_actual_max_streams_) {
@@ -92,17 +96,14 @@
 // 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) {
-  if (unidirectional_ &&
-      max_open_streams <
-          session_->num_expected_unidirectional_static_streams()) {
-    // Requirement can be found at
-    // https://tools.ietf.org/html/draft-ietf-quic-http-22#section-6.2.
-    QUIC_DLOG(ERROR) << "Received max unidirectional stream "
-                     << max_open_streams << " < "
-                     << session_->num_expected_unidirectional_static_streams();
-    session_->connection()->CloseConnection(
-        QUIC_MAX_STREAMS_ERROR, "New unidirectional stream limit is too low.",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+  if (max_open_streams < num_expected_static_streams_) {
+    QUIC_DLOG(ERROR) << "Received max streams " << max_open_streams << " < "
+                     << num_expected_static_streams_;
+    delegate_->OnError(QUIC_MAX_STREAMS_ERROR,
+                       unidirectional_
+                           ? "New unidirectional stream limit is too low."
+                           : "New bidirectional stream limit is too low.");
+
     return false;
   }
   if (using_default_max_streams_) {
@@ -114,10 +115,8 @@
     // be less than the number of existing outgoing streams. If that happens,
     // close the connection.
     if (max_open_streams < outgoing_stream_count_) {
-      session_->connection()->CloseConnection(
-          QUIC_MAX_STREAMS_ERROR,
-          "Stream limit less than existing stream count",
-          ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+      delegate_->OnError(QUIC_MAX_STREAMS_ERROR,
+                         "Stream limit less than existing stream count");
       return false;
     }
     using_default_max_streams_ = false;
@@ -133,11 +132,11 @@
   // if it would exceed the max 32 bits can express.
   outgoing_max_streams_ = std::min<size_t>(
       max_open_streams,
-      QuicUtils::GetMaxStreamCount(unidirectional_, session_->perspective()));
+      QuicUtils::GetMaxStreamCount(unidirectional_, perspective_));
 
   // Inform the higher layers that the stream limit has increased and that
   // new streams may be created.
-  session_->OnCanCreateNewOutgoingStream(unidirectional_);
+  delegate_->OnCanCreateNewOutgoingStream(unidirectional_);
 
   return true;
 }
@@ -148,9 +147,8 @@
   QuicStreamCount new_max = std::min(
       implementation_max, static_cast<QuicStreamCount>(max_open_streams));
   if (new_max < incoming_stream_count_) {
-    session_->connection()->CloseConnection(
-        QUIC_MAX_STREAMS_ERROR, "Stream limit less than existing stream count",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+    delegate_->OnError(QUIC_MAX_STREAMS_ERROR,
+                       "Stream limit less than existing stream count");
     return;
   }
   incoming_actual_max_streams_ = new_max;
@@ -170,15 +168,16 @@
 }
 
 void QuicStreamIdManager::SendMaxStreamsFrame() {
-  if (!session_->is_configured()) {
-    // Session not configured, so we can not send the MAX STREAMS frame yet.
-    // Remember that we would have sent one and then return. A new frame will
-    // be generated once the configuration is received.
+  if (!is_config_negotiated_) {
+    // The config has not yet been negotiated, so we can not send the
+    // MAX STREAMS frame yet. Record that we would have sent one and then
+    // return. A new frame will be generated once the configuration is
+    // received.
     pending_max_streams_ = true;
     return;
   }
   incoming_advertised_max_streams_ = incoming_actual_max_streams_;
-  session_->SendMaxStreams(incoming_advertised_max_streams_, unidirectional_);
+  delegate_->SendMaxStreams(incoming_advertised_max_streams_, unidirectional_);
 }
 
 void QuicStreamIdManager::OnStreamClosed(QuicStreamId stream_id) {
@@ -220,15 +219,14 @@
   }
   // Next stream ID would exceed the limit, need to inform the peer.
 
-  if (!session_->is_configured()) {
-    // Session not configured, so we can not send the STREAMS_BLOCKED frame yet.
-    // Remember that we would have sent one, and what the limit was when we were
-    // blocked, and return.
+  if (!is_config_negotiated_) {
+    // The config is not negotiated, so we can not send the STREAMS_BLOCKED
+    // frame yet. Record that we would have sent one, and what the limit was
+    // when we were blocked, and return.
     pending_streams_blocked_ = outgoing_max_streams_;
     return false;
   }
-
-  session_->SendStreamsBlocked(outgoing_max_streams_, unidirectional_);
+  delegate_->SendStreamsBlocked(outgoing_max_streams_, unidirectional_);
   QUIC_CODE_COUNT(quic_reached_outgoing_stream_id_limit);
   return false;
 }
@@ -273,11 +271,10 @@
                     << "Failed to create a new incoming stream with id:"
                     << stream_id << ", reaching MAX_STREAMS limit: "
                     << incoming_advertised_max_streams_ << ".";
-    session_->connection()->CloseConnection(
+    delegate_->OnError(
         QUIC_INVALID_STREAM_ID,
         QuicStrCat("Stream id ", stream_id, " would exceed stream count limit ",
-                   incoming_advertised_max_streams_),
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+                   incoming_advertised_max_streams_));
     return false;
   }
 
@@ -335,7 +332,7 @@
 }
 
 Perspective QuicStreamIdManager::perspective() const {
-  return session_->perspective();
+  return perspective_;
 }
 
 Perspective QuicStreamIdManager::peer_perspective() const {
@@ -343,7 +340,7 @@
 }
 
 QuicTransportVersion QuicStreamIdManager::transport_version() const {
-  return session_->transport_version();
+  return transport_version_;
 }
 
 size_t QuicStreamIdManager::available_incoming_streams() {
@@ -358,7 +355,7 @@
 }
 
 void QuicStreamIdManager::OnConfigNegotiated() {
-  QuicConnection::ScopedPacketFlusher flusher(session_->connection());
+  is_config_negotiated_ = true;
   // If a STREAMS_BLOCKED or MAX_STREAMS is pending, send it and clear
   // the pending state.
   if (pending_streams_blocked_ !=
@@ -366,7 +363,7 @@
     if (pending_streams_blocked_ >= outgoing_max_streams_) {
       // There is a pending STREAMS_BLOCKED frame and the current limit does not
       // let new streams be formed. Regenerate and send the frame.
-      session_->SendStreamsBlocked(outgoing_max_streams_, unidirectional_);
+      delegate_->SendStreamsBlocked(outgoing_max_streams_, unidirectional_);
     }
     pending_streams_blocked_ =
         QuicUtils::GetInvalidStreamId(transport_version());
diff --git a/quic/core/quic_stream_id_manager.h b/quic/core/quic_stream_id_manager.h
index 51524ba..1ac2947 100644
--- a/quic/core/quic_stream_id_manager.h
+++ b/quic/core/quic_stream_id_manager.h
@@ -17,8 +17,6 @@
 class QuicStreamIdManagerPeer;
 }  // namespace test
 
-class QuicSession;
-
 // Amount to increment a stream ID value to get the next stream ID in
 // the stream ID space.
 const QuicStreamId kV99StreamIdIncrement = 4;
@@ -31,8 +29,36 @@
 // This class manages the stream ids for Version 99/IETF QUIC.
 class QUIC_EXPORT_PRIVATE QuicStreamIdManager {
  public:
-  QuicStreamIdManager(QuicSession* session,
+  class DelegateInterface {
+   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 OnError(QuicErrorCode error_code,
+                         std::string error_details) = 0;
+
+    // Send a MAX_STREAMS frame.
+    virtual void SendMaxStreams(QuicStreamCount stream_count,
+                                bool unidirectional) = 0;
+
+    // Send a STREAMS_BLOCKED frame.
+    virtual void SendStreamsBlocked(QuicStreamCount stream_count,
+                                    bool unidirectional) = 0;
+  };
+
+  QuicStreamIdManager(DelegateInterface* delegate,
                       bool unidirectional,
+                      Perspective perspective,
+                      QuicTransportVersion transport_version,
+                      QuicStreamCount num_expected_static_streams,
                       QuicStreamCount max_allowed_outgoing_streams,
                       QuicStreamCount max_allowed_incoming_streams);
 
@@ -171,11 +197,23 @@
 
   // Back reference to the session containing this Stream ID Manager.
   // needed to access various session methods, such as perspective()
-  QuicSession* session_;
+  DelegateInterface* delegate_;
 
   // Whether this stream id manager is for unidrectional (true) or bidirectional
   // (false) streams.
-  bool unidirectional_;
+  const bool unidirectional_;
+
+  // Is this manager a client or a server.
+  const Perspective perspective_;
+
+  // Transport version used for this manager.
+  const QuicTransportVersion transport_version_;
+
+  // Number of expected static streams.
+  const QuicStreamCount num_expected_static_streams_;
+
+  // True if the config has been negotiated_;
+  bool is_config_negotiated_;
 
   // This is the number of streams that this node can initiate.
   // This limit is:
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 7c1233b..748a10c 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -4,150 +4,68 @@
 #include "net/third_party/quiche/src/quic/core/quic_stream_id_manager.h"
 
 #include <cstdint>
-#include <set>
 #include <string>
 #include <utility>
 
-#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/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_packets.h"
-#include "net/third_party/quiche/src/quic/core/quic_session.h"
-#include "net/third_party/quiche/src/quic/core/quic_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_test_mem_slice_vector.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_flow_controller_peer.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_stream_peer.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 
 using testing::_;
 using testing::Invoke;
-using testing::Return;
 using testing::StrictMock;
 
 namespace quic {
 namespace test {
 namespace {
 
-class TestQuicStream : public QuicStream {
-  // TestQuicStream exists simply as a place to hang OnDataAvailable().
+class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
-  TestQuicStream(QuicStreamId id, QuicSession* session, StreamType type)
-      : QuicStream(id, session, /*is_static=*/false, type) {}
-
-  void OnDataAvailable() override {}
-};
-
-class TestQuicSession : public MockQuicSession {
- public:
-  TestQuicSession(QuicConnection* connection)
-      : MockQuicSession(connection, /*create_mock_crypto_stream=*/true) {
-    // Initialize to an invalid frame type to detect cases where the frame type
-    // is not set subsequently.
-    save_frame_.type = static_cast<QuicFrameType>(-1);
-    Initialize();
-  }
-
-  TestQuicStream* CreateIncomingStream(QuicStreamId id) override {
-    TestQuicStream* stream = new TestQuicStream(
-        id, this,
-        DetermineStreamType(id, transport_version(), perspective(),
-                            /*is_incoming=*/true, BIDIRECTIONAL));
-    ActivateStream(QuicWrapUnique(stream));
-    return stream;
-  }
-
-  bool SaveFrame(const QuicFrame& frame) {
-    save_frame_ = frame;
-    DeleteFrame(&const_cast<QuicFrame&>(frame));
-    return true;
-  }
-
-  const QuicFrame& save_frame() { return save_frame_; }
-
-  TestQuicStream* CreateOutgoingBidirectionalStream() {
-    if (!CanOpenNextOutgoingBidirectionalStream()) {
-      return nullptr;
-    }
-    QuicStreamId id = GetNextOutgoingBidirectionalStreamId();
-    TestQuicStream* stream = new TestQuicStream(id, this, BIDIRECTIONAL);
-    ActivateStream(QuicWrapUnique(stream));
-    return stream;
-  }
-
-  TestQuicStream* CreateOutgoingUnidirectionalStream() {
-    if (!CanOpenNextOutgoingUnidirectionalStream()) {
-      return nullptr;
-    }
-    QuicStreamId id = GetNextOutgoingUnidirectionalStreamId();
-    TestQuicStream* stream = new TestQuicStream(id, this, WRITE_UNIDIRECTIONAL);
-    ActivateStream(QuicWrapUnique(stream));
-    return stream;
-  }
-
- private:
-  QuicFrame save_frame_;
+  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 QuicStreamIdManagerTestBase : public QuicTestWithParam<bool> {
  protected:
   explicit QuicStreamIdManagerTestBase(Perspective perspective)
-      : connection_(new StrictMock<MockQuicConnection>(
-            &helper_,
-            &alarm_factory_,
-            perspective,
-            ParsedQuicVersionVector(
-                {{PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99}}))) {
-    connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
-    session_ = std::make_unique<TestQuicSession>(connection_);
-    stream_id_manager_ =
-        IsBidi() ? QuicSessionPeer::v99_bidirectional_stream_id_manager(
-                       session_.get())
-                 : QuicSessionPeer::v99_unidirectional_stream_id_manager(
-                       session_.get());
-  }
+      : stream_id_manager_(&delegate_,
+                           IsUnidi(),
+                           perspective,
+                           QUIC_VERSION_99,
+                           0,
+                           kDefaultMaxStreamsPerConnection,
+                           kDefaultMaxStreamsPerConnection) {}
 
-  QuicTransportVersion transport_version() const {
-    return connection_->transport_version();
-  }
-
-  void CloseStream(QuicStreamId id) { session_->CloseStream(id); }
+  QuicTransportVersion transport_version() const { return QUIC_VERSION_99; }
 
   QuicStreamId GetNthClientInitiatedBidirectionalId(int n) {
-    return QuicUtils::GetFirstBidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_CLIENT) +
+    return QuicUtils::GetFirstBidirectionalStreamId(transport_version(),
+                                                    Perspective::IS_CLIENT) +
            kV99StreamIdIncrement * n;
   }
 
   QuicStreamId GetNthClientInitiatedUnidirectionalId(int n) {
-    return QuicUtils::GetFirstUnidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_CLIENT) +
+    return QuicUtils::GetFirstUnidirectionalStreamId(transport_version(),
+                                                     Perspective::IS_CLIENT) +
            kV99StreamIdIncrement * n;
   }
 
   QuicStreamId GetNthServerInitiatedBidirectionalId(int n) {
-    return QuicUtils::GetFirstBidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_SERVER) +
+    return QuicUtils::GetFirstBidirectionalStreamId(transport_version(),
+                                                    Perspective::IS_SERVER) +
            kV99StreamIdIncrement * n;
   }
 
   QuicStreamId GetNthServerInitiatedUnidirectionalId(int n) {
-    return QuicUtils::GetFirstUnidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_SERVER) +
+    return QuicUtils::GetFirstUnidirectionalStreamId(transport_version(),
+                                                     Perspective::IS_SERVER) +
            kV99StreamIdIncrement * n;
   }
 
@@ -172,11 +90,8 @@
   bool IsUnidi() { return GetParam() ? false : true; }
   bool IsBidi() { return GetParam(); }
 
-  MockQuicConnectionHelper helper_;
-  MockAlarmFactory alarm_factory_;
-  StrictMock<MockQuicConnection>* connection_;
-  std::unique_ptr<TestQuicSession> session_;
-  QuicStreamIdManager* stream_id_manager_;
+  StrictMock<MockDelegate> delegate_;
+  QuicStreamIdManager stream_id_manager_;
 };
 
 // Following tests are either client-specific (they depend, in some way, on
@@ -200,29 +115,29 @@
   // These fields are inited via the QuicSession constructor to default
   // values defined as a constant.
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->outgoing_max_streams());
+            stream_id_manager_.outgoing_max_streams());
 
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->incoming_actual_max_streams());
+            stream_id_manager_.incoming_actual_max_streams());
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->incoming_advertised_max_streams());
+            stream_id_manager_.incoming_advertised_max_streams());
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->incoming_initial_max_open_streams());
+            stream_id_manager_.incoming_initial_max_open_streams());
 
   // The window for advertising updates to the MAX STREAM ID is half the number
   // of streams allowed.
   EXPECT_EQ(kDefaultMaxStreamsPerConnection / kMaxStreamsWindowDivisor,
-            stream_id_manager_->max_streams_window());
+            stream_id_manager_.max_streams_window());
 }
 
 // This test checks that the stream advertisement window is set to 1
 // if the number of stream ids is 1. This is a special case in the code.
 TEST_P(QuicStreamIdManagerTestClient, CheckMaxStreamsWindow1) {
-  stream_id_manager_->SetMaxOpenIncomingStreams(1);
-  EXPECT_EQ(1u, stream_id_manager_->incoming_initial_max_open_streams());
-  EXPECT_EQ(1u, stream_id_manager_->incoming_actual_max_streams());
+  stream_id_manager_.SetMaxOpenIncomingStreams(1);
+  EXPECT_EQ(1u, stream_id_manager_.incoming_initial_max_open_streams());
+  EXPECT_EQ(1u, stream_id_manager_.incoming_actual_max_streams());
   // If streamid_count/2==0 (integer math) force it to 1.
-  EXPECT_EQ(1u, stream_id_manager_->max_streams_window());
+  EXPECT_EQ(1u, stream_id_manager_.max_streams_window());
 }
 
 // Now check that setting to a value larger than the maximum fails.
@@ -232,12 +147,13 @@
       QuicUtils::GetMaxStreamCount(!GetParam(), /* GetParam==true for bidi */
                                    Perspective::IS_CLIENT);
   // Ensure that the limit is less than the implementation maximum.
-  EXPECT_LT(stream_id_manager_->outgoing_max_streams(), implementation_max);
+  EXPECT_LT(stream_id_manager_.outgoing_max_streams(), implementation_max);
 
   // Try to go over.
-  stream_id_manager_->SetMaxOpenOutgoingStreams(implementation_max + 1);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  stream_id_manager_.SetMaxOpenOutgoingStreams(implementation_max + 1);
   // Should be pegged at the max.
-  EXPECT_EQ(implementation_max, stream_id_manager_->outgoing_max_streams());
+  EXPECT_EQ(implementation_max, stream_id_manager_.outgoing_max_streams());
 }
 
 // Now do the same for the incoming streams
@@ -245,79 +161,70 @@
   QuicStreamCount implementation_max =
       QuicUtils::GetMaxStreamCount(!GetParam(), /* GetParam==true for bidi */
                                    Perspective::IS_CLIENT);
-  stream_id_manager_->SetMaxOpenIncomingStreams(implementation_max - 1u);
+  stream_id_manager_.SetMaxOpenIncomingStreams(implementation_max - 1u);
   EXPECT_EQ(implementation_max - 1u,
-            stream_id_manager_->incoming_initial_max_open_streams());
+            stream_id_manager_.incoming_initial_max_open_streams());
   EXPECT_EQ(implementation_max - 1u,
-            stream_id_manager_->incoming_actual_max_streams());
+            stream_id_manager_.incoming_actual_max_streams());
   EXPECT_EQ((implementation_max - 1u) / 2u,
-            stream_id_manager_->max_streams_window());
+            stream_id_manager_.max_streams_window());
 
-  stream_id_manager_->SetMaxOpenIncomingStreams(implementation_max);
+  stream_id_manager_.SetMaxOpenIncomingStreams(implementation_max);
   EXPECT_EQ(implementation_max,
-            stream_id_manager_->incoming_initial_max_open_streams());
+            stream_id_manager_.incoming_initial_max_open_streams());
   EXPECT_EQ(implementation_max,
-            stream_id_manager_->incoming_actual_max_streams());
-  EXPECT_EQ(implementation_max / 2, stream_id_manager_->max_streams_window());
+            stream_id_manager_.incoming_actual_max_streams());
+  EXPECT_EQ(implementation_max / 2, stream_id_manager_.max_streams_window());
 
   // Reset to 1 so that we can detect the change.
-  stream_id_manager_->SetMaxOpenIncomingStreams(1u);
-  EXPECT_EQ(1u, stream_id_manager_->incoming_initial_max_open_streams());
-  EXPECT_EQ(1u, stream_id_manager_->incoming_actual_max_streams());
-  EXPECT_EQ(1u, stream_id_manager_->max_streams_window());
+  stream_id_manager_.SetMaxOpenIncomingStreams(1u);
+  EXPECT_EQ(1u, stream_id_manager_.incoming_initial_max_open_streams());
+  EXPECT_EQ(1u, stream_id_manager_.incoming_actual_max_streams());
+  EXPECT_EQ(1u, stream_id_manager_.max_streams_window());
   // Now try to exceed the max, without wrapping.
-  stream_id_manager_->SetMaxOpenIncomingStreams(implementation_max + 1);
+  stream_id_manager_.SetMaxOpenIncomingStreams(implementation_max + 1);
   EXPECT_EQ(implementation_max,
-            stream_id_manager_->incoming_initial_max_open_streams());
+            stream_id_manager_.incoming_initial_max_open_streams());
   EXPECT_EQ(implementation_max,
-            stream_id_manager_->incoming_actual_max_streams());
-  EXPECT_EQ(implementation_max / 2u, stream_id_manager_->max_streams_window());
+            stream_id_manager_.incoming_actual_max_streams());
+  EXPECT_EQ(implementation_max / 2u, stream_id_manager_.max_streams_window());
 }
 
 // Check the case of the stream count in a STREAMS_BLOCKED frame is less than
 // the count most recently advertised in a MAX_STREAMS frame. This should cause
 // a MAX_STREAMS frame with the most recently advertised count to be sent.
 TEST_P(QuicStreamIdManagerTestClient, ProcessStreamsBlockedOk) {
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillRepeatedly(Invoke(session_.get(), &TestQuicSession::SaveFrame));
+  // Set the config negotiated so that the MAX_STREAMS is transmitted.
+  stream_id_manager_.OnConfigNegotiated();
+
   QuicStreamCount stream_count =
-      stream_id_manager_->incoming_initial_max_open_streams() - 1;
-  QuicStreamsBlockedFrame frame(0, stream_count, /*unidirectional=*/false);
-
-  // Simulate being configured so that the MAX_STREAMS is transmitted.
-  session_->OnConfigNegotiated();
-
-  session_->OnStreamsBlockedFrame(frame);
-
-  // We should see a MAX_STREAMS frame.
-  EXPECT_EQ(MAX_STREAMS_FRAME, session_->save_frame().type);
-
-  // and it should advertise the current max-allowed value.
-  EXPECT_EQ(stream_id_manager_->incoming_initial_max_open_streams(),
-            session_->save_frame().max_streams_frame.stream_count);
+      stream_id_manager_.incoming_initial_max_open_streams();
+  QuicStreamsBlockedFrame frame(0, stream_count - 1, IsUnidi());
+  EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidi()));
+  stream_id_manager_.OnStreamsBlockedFrame(frame);
 }
 
 // Check the case of the stream count in a STREAMS_BLOCKED frame is equal to the
 // count most recently advertised in a MAX_STREAMS frame. No MAX_STREAMS
 // should be generated.
 TEST_P(QuicStreamIdManagerTestClient, ProcessStreamsBlockedNoOp) {
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
   QuicStreamCount stream_count =
-      stream_id_manager_->incoming_initial_max_open_streams();
-  QuicStreamsBlockedFrame frame(0, stream_count, /*unidirectional=*/false);
-  session_->OnStreamsBlockedFrame(frame);
+      stream_id_manager_.incoming_initial_max_open_streams();
+  QuicStreamsBlockedFrame frame(0, stream_count, IsUnidi());
+  EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
 }
 
 // Check the case of the stream count in a STREAMS_BLOCKED frame is greater than
 // the count most recently advertised in a MAX_STREAMS frame. Expect a
 // connection close with an error.
 TEST_P(QuicStreamIdManagerTestClient, ProcessStreamsBlockedTooBig) {
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAMS_BLOCKED_ERROR, _, _));
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
+  EXPECT_CALL(delegate_, OnError(QUIC_STREAMS_BLOCKED_ERROR, _));
+  EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, _)).Times(0);
   QuicStreamCount stream_count =
-      stream_id_manager_->incoming_initial_max_open_streams() + 1;
-  QuicStreamsBlockedFrame frame(0, stream_count, /*unidirectional=*/false);
-  session_->OnStreamsBlockedFrame(frame);
+      stream_id_manager_.incoming_initial_max_open_streams() + 1;
+  QuicStreamsBlockedFrame frame(0, stream_count, IsUnidi());
+  stream_id_manager_.OnStreamsBlockedFrame(frame);
 }
 
 // Same basic tests as above, but calls
@@ -328,33 +235,31 @@
 // First test make sure that streams with ids below the limit are accepted.
 TEST_P(QuicStreamIdManagerTestClient, IsIncomingStreamIdValidBelowLimit) {
   QuicStreamId stream_id =
-      StreamCountToId(stream_id_manager_->incoming_actual_max_streams() - 1,
+      StreamCountToId(stream_id_manager_.incoming_actual_max_streams() - 1,
                       Perspective::IS_CLIENT);
-  EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
-  EXPECT_TRUE(stream_id_manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
+  EXPECT_CALL(delegate_, OnError(_, _)).Times(0);
+  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
 }
 
 // Accept a stream with an ID that equals the limit.
 TEST_P(QuicStreamIdManagerTestClient, IsIncomingStreamIdValidAtLimit) {
-  QuicStreamId stream_id =
-      StreamCountToId(stream_id_manager_->incoming_actual_max_streams(),
-                      Perspective::IS_CLIENT);
-  EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
-  EXPECT_TRUE(stream_id_manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
+  QuicStreamId stream_id = StreamCountToId(
+      stream_id_manager_.incoming_actual_max_streams(), Perspective::IS_CLIENT);
+  EXPECT_CALL(delegate_, OnError(_, _)).Times(0);
+  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
 }
 
 // Close the connection if the id exceeds the limit.
 TEST_P(QuicStreamIdManagerTestClient, IsIncomingStreamIdInValidAboveLimit) {
   QuicStreamId stream_id = StreamCountToId(
-      stream_id_manager_->incoming_actual_max_streams() + 1,
+      stream_id_manager_.incoming_actual_max_streams() + 1,
       Perspective::IS_SERVER);  // This node is a client, incoming
                                 // stream ids must be server-originated.
   std::string error_details =
       GetParam() ? "Stream id 401 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(stream_id_manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, error_details));
+  EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
 }
 
 // Test functionality for reception of a MAX_STREAMS frame. This code is
@@ -365,7 +270,7 @@
       // need to know the number of request/response streams.
       // This is the total number of outgoing streams (which includes both
       // req/resp and statics).
-      stream_id_manager_->outgoing_max_streams();
+      stream_id_manager_.outgoing_max_streams();
 
   QuicMaxStreamsFrame frame;
 
@@ -376,27 +281,29 @@
   frame.stream_count = initial_stream_count - 1;
 
   frame.unidirectional = IsUnidi();
-  EXPECT_TRUE(stream_id_manager_->OnMaxStreamsFrame(frame));
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  EXPECT_TRUE(stream_id_manager_.OnMaxStreamsFrame(frame));
   EXPECT_EQ(initial_stream_count - 1u,
-            stream_id_manager_->outgoing_max_streams());
+            stream_id_manager_.outgoing_max_streams());
 
   QuicStreamCount save_outgoing_max_streams =
-      stream_id_manager_->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 = initial_stream_count - 2;
   frame.unidirectional = IsUnidi();
-  EXPECT_TRUE(stream_id_manager_->OnMaxStreamsFrame(frame));
+  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());
+            stream_id_manager_.outgoing_max_streams());
 
   // A stream count greater than the current limit should increase the limit.
   frame.stream_count = initial_stream_count + 1;
-  EXPECT_TRUE(stream_id_manager_->OnMaxStreamsFrame(frame));
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  EXPECT_TRUE(stream_id_manager_.OnMaxStreamsFrame(frame));
 
   EXPECT_EQ(initial_stream_count + 1u,
-            stream_id_manager_->outgoing_max_streams());
+            stream_id_manager_.outgoing_max_streams());
 }
 
 // Test functionality for reception of a STREAMS_BLOCKED frame.
@@ -404,9 +311,10 @@
 TEST_P(QuicStreamIdManagerTestClient, StreamIdManagerOnStreamsBlockedFrame) {
   // Get the current maximum allowed incoming stream count.
   QuicStreamCount advertised_stream_count =
-      stream_id_manager_->incoming_advertised_max_streams();
-  // Simulate receiving a config to allow frame transmission
-  session_->OnConfigNegotiated();
+      stream_id_manager_.incoming_advertised_max_streams();
+
+  // Set the config negotiated to allow frame transmission.
+  stream_id_manager_.OnConfigNegotiated();
 
   QuicStreamsBlockedFrame frame;
 
@@ -415,14 +323,14 @@
   // If the peer is saying it's blocked on the stream count that
   // we've advertised, it's a noop since the peer has the correct information.
   frame.stream_count = advertised_stream_count;
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
-  EXPECT_TRUE(stream_id_manager_->OnStreamsBlockedFrame(frame));
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, _)).Times(0);
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame));
 
   // If the peer is saying it's blocked on a stream count that is larger
   // than what we've advertised, the connection should get closed.
   frame.stream_count = advertised_stream_count + 1;
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAMS_BLOCKED_ERROR, _, _));
-  EXPECT_FALSE(stream_id_manager_->OnStreamsBlockedFrame(frame));
+  EXPECT_CALL(delegate_, OnError(QUIC_STREAMS_BLOCKED_ERROR, _));
+  EXPECT_FALSE(stream_id_manager_.OnStreamsBlockedFrame(frame));
 
   // If the peer is saying it's blocked on a count that is less than
   // our actual count, we send a MAX_STREAMS frame and update
@@ -430,16 +338,16 @@
   // First, need to bump up the actual max so there is room for the MAX
   // STREAMS frame to send a larger ID.
   QuicStreamCount actual_stream_count =
-      stream_id_manager_->incoming_actual_max_streams();
+      stream_id_manager_.incoming_actual_max_streams();
 
   // Closing a stream will result in the ability to initiate one more
   // stream
-  stream_id_manager_->OnStreamClosed(
-      QuicStreamIdManagerPeer::GetFirstIncomingStreamId(stream_id_manager_));
+  stream_id_manager_.OnStreamClosed(
+      QuicStreamIdManagerPeer::GetFirstIncomingStreamId(&stream_id_manager_));
   EXPECT_EQ(actual_stream_count + 1u,
-            stream_id_manager_->incoming_actual_max_streams());
-  EXPECT_EQ(stream_id_manager_->incoming_actual_max_streams(),
-            stream_id_manager_->incoming_advertised_max_streams() + 1u);
+            stream_id_manager_.incoming_actual_max_streams());
+  EXPECT_EQ(stream_id_manager_.incoming_actual_max_streams(),
+            stream_id_manager_.incoming_advertised_max_streams() + 1u);
 
   // Now simulate receiving a STREAMS_BLOCKED frame...
   // Changing the actual maximum, above, forces a MAX_STREAMS frame to be
@@ -450,19 +358,14 @@
   // MAX_STREAMS sent earler.
   frame.stream_count = advertised_stream_count;
 
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .Times(1)
-      .WillRepeatedly(Invoke(session_.get(), &TestQuicSession::SaveFrame));
+  EXPECT_CALL(delegate_,
+              SendMaxStreams(stream_id_manager_.incoming_actual_max_streams(),
+                             IsUnidi()));
 
-  EXPECT_TRUE(stream_id_manager_->OnStreamsBlockedFrame(frame));
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame));
   // Check that the saved frame is correct.
-  EXPECT_EQ(stream_id_manager_->incoming_actual_max_streams(),
-            stream_id_manager_->incoming_advertised_max_streams());
-  EXPECT_EQ(MAX_STREAMS_FRAME, session_->save_frame().type);
-  EXPECT_EQ(stream_id_manager_->incoming_advertised_max_streams(),
-            session_->save_frame().max_streams_frame.stream_count);
-  // Make sure that this is the only MAX_STREAMS
-  EXPECT_EQ(1u, GetControlFrameId(session_->save_frame()));
+  EXPECT_EQ(stream_id_manager_.incoming_actual_max_streams(),
+            stream_id_manager_.incoming_advertised_max_streams());
 }
 
 // Test GetNextOutgoingStream. This is client/server agnostic.
@@ -471,41 +374,34 @@
   // opening...
   size_t number_of_streams = kDefaultMaxStreamsPerConnection;
 
-  // Set up config to allow the default stream limit and then
-  // simulate receiving a config to allow frame transmission
-  QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
-      session_->config(), kDefaultMaxStreamsPerConnection);
-  QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
-      session_->config(), kDefaultMaxStreamsPerConnection);
-  session_->OnConfigNegotiated();
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  stream_id_manager_.SetMaxOpenOutgoingStreams(100);
+
+  stream_id_manager_.OnConfigNegotiated();
 
   QuicStreamId stream_id =
-      IsUnidi() ? session_->next_outgoing_unidirectional_stream_id()
-                : session_->next_outgoing_bidirectional_stream_id();
+      IsUnidi() ? QuicUtils::GetFirstUnidirectionalStreamId(
+                      QUIC_VERSION_99, stream_id_manager_.perspective())
+                : QuicUtils::GetFirstBidirectionalStreamId(
+                      QUIC_VERSION_99, stream_id_manager_.perspective());
 
-  EXPECT_EQ(number_of_streams, stream_id_manager_->outgoing_max_streams());
+  EXPECT_EQ(number_of_streams, stream_id_manager_.outgoing_max_streams());
   while (number_of_streams) {
-    EXPECT_TRUE(stream_id_manager_->CanOpenNextOutgoingStream());
-    EXPECT_EQ(stream_id, stream_id_manager_->GetNextOutgoingStreamId());
+    EXPECT_TRUE(stream_id_manager_.CanOpenNextOutgoingStream());
+    EXPECT_EQ(stream_id, stream_id_manager_.GetNextOutgoingStreamId());
     stream_id += kV99StreamIdIncrement;
     number_of_streams--;
   }
 
   // If we try to check that the next outgoing stream id is available it should
   // A) fail and B) generate a STREAMS_BLOCKED frame.
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .Times(1)
-      .WillRepeatedly(Invoke(session_.get(), &TestQuicSession::SaveFrame));
-  EXPECT_FALSE(stream_id_manager_->CanOpenNextOutgoingStream());
-  EXPECT_EQ(STREAMS_BLOCKED_FRAME, session_->save_frame().type);
-  // If bidi, Crypto stream default created  at start up, it is one
-  // more stream to account for since initialization is "number of
-  // request/responses" & crypto is added in to that, not streams.
-  EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            session_->save_frame().max_streams_frame.stream_count);
+  EXPECT_CALL(delegate_,
+              SendStreamsBlocked(kDefaultMaxStreamsPerConnection, IsUnidi()));
+  EXPECT_FALSE(stream_id_manager_.CanOpenNextOutgoingStream());
+
   // If we try to get the next id (above the limit), it should cause a quic-bug.
   EXPECT_QUIC_BUG(
-      stream_id_manager_->GetNextOutgoingStreamId(),
+      stream_id_manager_.GetNextOutgoingStreamId(),
       "Attempt to allocate a new outgoing stream that would exceed the limit");
 }
 
@@ -513,27 +409,26 @@
 // server/client agnostic.
 TEST_P(QuicStreamIdManagerTestClient,
        StreamIdManagerServerMaybeIncreaseLargestPeerStreamId) {
-  QuicStreamId max_stream_id =
-      StreamCountToId(stream_id_manager_->incoming_actual_max_streams(),
-                      Perspective::IS_SERVER);
+  QuicStreamId max_stream_id = StreamCountToId(
+      stream_id_manager_.incoming_actual_max_streams(), Perspective::IS_SERVER);
   EXPECT_TRUE(
-      stream_id_manager_->MaybeIncreaseLargestPeerStreamId(max_stream_id));
+      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(max_stream_id));
 
   QuicStreamId server_initiated_stream_id =
       StreamCountToId(1u,  // get 1st id
                       Perspective::IS_SERVER);
-  EXPECT_TRUE(stream_id_manager_->MaybeIncreaseLargestPeerStreamId(
+  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
       server_initiated_stream_id));
   // A bad stream ID results in a closed connection.
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _));
-  EXPECT_FALSE(stream_id_manager_->MaybeIncreaseLargestPeerStreamId(
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, _));
+  EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
       max_stream_id + kV99StreamIdIncrement));
 }
 
 // Test the MAX STREAMS Window functionality.
 TEST_P(QuicStreamIdManagerTestClient, StreamIdManagerServerMaxStreams) {
-  // Simulate completed config to allow frame transmission
-  session_->OnConfigNegotiated();
+  // Set the config negotiated to allow frame transmission.
+  stream_id_manager_.OnConfigNegotiated();
 
   // Test that a MAX_STREAMS frame is generated when the peer has less than
   // |max_streams_window_| streams left that it can initiate.
@@ -543,96 +438,89 @@
   // should be sent. The -1 is because the check in
   // QuicStreamIdManager::MaybeSendMaxStreamsFrame sends a MAX_STREAMS if the
   // number of available streams at the peer is <= |max_streams_window_|
-  int stream_count = stream_id_manager_->max_streams_window() - 1;
+  int stream_count = stream_id_manager_.max_streams_window() - 1;
 
   // Should not get a control-frame transmission since the peer should have
   // "plenty" of stream IDs to use.
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, _)).Times(0);
+  EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
 
   // Get the first incoming stream ID to try and allocate.
   QuicStreamId stream_id = IsBidi() ? GetNthServerInitiatedBidirectionalId(0)
                                     : GetNthServerInitiatedUnidirectionalId(0);
   size_t old_available_incoming_streams =
-      stream_id_manager_->available_incoming_streams();
+      stream_id_manager_.available_incoming_streams();
   while (stream_count) {
-    EXPECT_TRUE(
-        stream_id_manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
+    EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
 
     // This node should think that the peer believes it has one fewer
     // stream it can create.
     old_available_incoming_streams--;
     EXPECT_EQ(old_available_incoming_streams,
-              stream_id_manager_->available_incoming_streams());
+              stream_id_manager_.available_incoming_streams());
 
     stream_count--;
     stream_id += kV99StreamIdIncrement;
   }
 
   // Now close them, still should get no MAX_STREAMS
-  stream_count = stream_id_manager_->max_streams_window();
+  stream_count = stream_id_manager_.max_streams_window();
   stream_id = IsBidi() ? GetNthServerInitiatedBidirectionalId(0)
                        : GetNthServerInitiatedUnidirectionalId(0);
   QuicStreamCount expected_actual_max =
-      stream_id_manager_->incoming_actual_max_streams();
+      stream_id_manager_.incoming_actual_max_streams();
   QuicStreamCount expected_advertised_max_streams =
-      stream_id_manager_->incoming_advertised_max_streams();
+      stream_id_manager_.incoming_advertised_max_streams();
   while (stream_count) {
-    stream_id_manager_->OnStreamClosed(stream_id);
+    stream_id_manager_.OnStreamClosed(stream_id);
     stream_count--;
     stream_id += kV99StreamIdIncrement;
     expected_actual_max++;
     EXPECT_EQ(expected_actual_max,
-              stream_id_manager_->incoming_actual_max_streams());
+              stream_id_manager_.incoming_actual_max_streams());
     // Advertised maximum should remain the same.
     EXPECT_EQ(expected_advertised_max_streams,
-              stream_id_manager_->incoming_advertised_max_streams());
+              stream_id_manager_.incoming_advertised_max_streams());
   }
 
   // This should not change.
   EXPECT_EQ(old_available_incoming_streams,
-            stream_id_manager_->available_incoming_streams());
+            stream_id_manager_.available_incoming_streams());
 
   // Now whenever we close a stream we should get a MAX_STREAMS frame.
   // Above code closed all the open streams, so we have to open/close
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .Times(1)
-      .WillRepeatedly(Invoke(session_.get(), &TestQuicSession::SaveFrame));
-  EXPECT_TRUE(stream_id_manager_->MaybeIncreaseLargestPeerStreamId(stream_id));
-  stream_id_manager_->OnStreamClosed(stream_id);
-  stream_id += kV99StreamIdIncrement;
-
-  // Check that the MAX STREAMS was sent and has the correct values.
-  EXPECT_EQ(MAX_STREAMS_FRAME, session_->save_frame().type);
-  EXPECT_EQ(stream_id_manager_->incoming_advertised_max_streams(),
-            session_->save_frame().max_streams_frame.stream_count);
+  //  EXPECT_CALL(delegate_,
+  //  SendMaxStreams(stream_id_manager_.incoming_actual_max_streams(),
+  //  IsUnidi()));
+  EXPECT_CALL(delegate_, SendMaxStreams(_, IsUnidi()));
+  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
+  stream_id_manager_.OnStreamClosed(stream_id);
 }
 
 // Check that edge conditions of the stream count in a STREAMS_BLOCKED frame
 // are. properly handled.
 TEST_P(QuicStreamIdManagerTestClient, StreamsBlockedEdgeConditions) {
-  // Simulate completed config to allow frame transmission
-  session_->OnConfigNegotiated();
+  // Set the config negotiated to allow frame transmission.
+  stream_id_manager_.OnConfigNegotiated();
 
   QuicStreamsBlockedFrame frame;
   frame.unidirectional = IsUnidi();
 
   // Check that receipt of a STREAMS BLOCKED with stream-count = 0 does nothing
   // when max_allowed_incoming_streams is 0.
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
-  stream_id_manager_->SetMaxOpenIncomingStreams(0);
+  EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, _)).Times(0);
+  stream_id_manager_.SetMaxOpenIncomingStreams(0);
   frame.stream_count = 0;
-  stream_id_manager_->OnStreamsBlockedFrame(frame);
+  stream_id_manager_.OnStreamsBlockedFrame(frame);
 
   // Check that receipt of a STREAMS BLOCKED with stream-count = 0 invokes a
   // MAX STREAMS, count = 123, when the MaxOpen... is set to 123.
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .Times(1)
-      .WillOnce(Invoke(session_.get(), &TestQuicSession::SaveFrame));
-  stream_id_manager_->SetMaxOpenIncomingStreams(123);
+  EXPECT_CALL(delegate_, SendMaxStreams(123u, IsUnidi()));
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, _)).Times(0);
+  stream_id_manager_.SetMaxOpenIncomingStreams(123);
   frame.stream_count = 0;
-  stream_id_manager_->OnStreamsBlockedFrame(frame);
-  EXPECT_EQ(MAX_STREAMS_FRAME, session_->save_frame().type);
-  EXPECT_EQ(123u, session_->save_frame().max_streams_frame.stream_count);
+  stream_id_manager_.OnStreamsBlockedFrame(frame);
 }
 
 TEST_P(QuicStreamIdManagerTestClient, HoldMaxStreamsFrame) {
@@ -640,21 +528,18 @@
     return;
   }
 
-  // The session has not been configured so frame transmission will not be
-  // allowed.
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
+  // The config has not been negotiated so the MAX_STREAMS frame will not be
+  // sent.
+  EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
 
-  QuicStreamsBlockedFrame frame(
-      1u, 0u, QuicStreamIdManagerPeer::get_unidirectional(stream_id_manager_));
+  QuicStreamsBlockedFrame frame(1u, 0u, IsUnidi());
   // Should cause change in pending_max_streams.
-  stream_id_manager_->OnStreamsBlockedFrame(frame);
-  // Will do OnConfig. We should see a control frame pop out now.
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
+  stream_id_manager_.OnStreamsBlockedFrame(frame);
 
-  // Now allow frame transmission -- which happens when the QuicSession
-  // receives the configuration and calls
-  // QuicStreamIdManager::OnConfigNegotiated()
-  session_->OnConfigNegotiated();
+  EXPECT_CALL(delegate_, SendMaxStreams(_, IsUnidi()));
+
+  // MAX_STREAMS will be sent now that the config has been negotiated.
+  stream_id_manager_.OnConfigNegotiated();
 }
 
 // Following tests all are server-specific. They depend, in some way, on
@@ -673,25 +558,21 @@
 
   // set outgoing limit to 0, will cause the CanOpenNext... to fail
   // leading to a STREAMS_BLOCKED.
-  QuicStreamIdManagerPeer::set_outgoing_max_streams(stream_id_manager_, 0);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  stream_id_manager_.SetMaxOpenOutgoingStreams(0);
 
-  // We should not see a STREAMS-BLOCKED frame because we're not configured..
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
+  // We should not see a STREAMS_BLOCKED frame because we're not configured..
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, _)).Times(0);
 
   // Since the stream limit is 0 and no sreams can be created this should return
-  // false and have forced a streams-blocked to be queued up, with the
+  // false and have forced a STREAMS_BLOCKED to be queued up, with the
   // blocked stream id == 0.
-  EXPECT_FALSE(stream_id_manager_->CanOpenNextOutgoingStream());
+  EXPECT_FALSE(stream_id_manager_.CanOpenNextOutgoingStream());
 
-  // Simulate receipt of the configuration; This case does not update the
-  // outgoing stream limit, so the on-config should result in a streams-blocked
-  // being sent.
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
-  QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
-      session_->config(), 0);
-  QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(session_->config(),
-                                                             0);
-  session_->OnConfigNegotiated();
+  // Since the steam limit has not been increased when the config was negotiated
+  // a STREAMS_BLOCKED frame should be sent.
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, IsUnidi()));
+  stream_id_manager_.OnConfigNegotiated();
 }
 
 TEST_P(QuicStreamIdManagerTestClient, HoldStreamsBlockedFrameNoXmit) {
@@ -700,28 +581,22 @@
   }
   // Set outgoing limit to 0, will cause the CanOpenNext... to fail
   // leading to a STREAMS_BLOCKED.
-  QuicStreamIdManagerPeer::set_outgoing_max_streams(stream_id_manager_, 0);
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  stream_id_manager_.SetMaxOpenOutgoingStreams(0);
 
-  // We should not see a STREAMS-BLOCKED frame because we're not configured..
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
+  // We should not see a STREAMS_BLOCKED frame because we're not configured..
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, IsUnidi())).Times(0);
 
   // Since the stream limit is 0 and no sreams can be created this should return
-  // false and have forced a streams-blocked to be queued up, with the
+  // false and have forced a STREAMS_BLOCKED to be queued up, with the
   // blocked stream id == 0.
-  EXPECT_FALSE(stream_id_manager_->CanOpenNextOutgoingStream());
+  EXPECT_FALSE(stream_id_manager_.CanOpenNextOutgoingStream());
 
-  // Since the config gives some streams to create, we should not see
-  // a STREAMS-BLOCKED frame.
-  EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
-
-  // Do the configuration.  The stream limits are increased, allowing this
-  // node to create more streams, so we should not see the pending
-  // STREAMS-BLOCKED frame get transmitted.
-  QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
-      session_->config(), 10);
-  QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(session_->config(),
-                                                             10);
-  session_->OnConfigNegotiated();
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  stream_id_manager_.SetMaxOpenOutgoingStreams(10);
+  // Since the stream limit has been increase which allows streams to be created
+  // no STREAMS_BLOCKED should be send.
+  stream_id_manager_.OnConfigNegotiated();
 }
 
 INSTANTIATE_TEST_SUITE_P(Tests,
@@ -733,86 +608,64 @@
 // stream id is correct.
 TEST_P(QuicStreamIdManagerTestServer, CheckMaxAllowedOutgoing) {
   const size_t kIncomingStreamCount = 123;
-  stream_id_manager_->SetMaxOpenOutgoingStreams(kIncomingStreamCount);
-  EXPECT_EQ(kIncomingStreamCount, stream_id_manager_->outgoing_max_streams());
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  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.
 TEST_P(QuicStreamIdManagerTestServer, MaxStreamsSlidingWindow) {
-  // Ignore OnStreamReset calls.
-  EXPECT_CALL(*connection_, OnStreamReset(_, _)).WillRepeatedly(Return());
-  // Capture control frames for analysis.
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillRepeatedly(Invoke(session_.get(), &TestQuicSession::SaveFrame));
   // Simulate config being negotiated, causing the limits all to be initialized.
-  session_->OnConfigNegotiated();
+  stream_id_manager_.OnConfigNegotiated();
+
   QuicStreamCount first_advert =
-      stream_id_manager_->incoming_advertised_max_streams();
+      stream_id_manager_.incoming_advertised_max_streams();
 
   // Open/close enough streams to shrink the window without causing a MAX
   // STREAMS to be generated. The window will open (and a MAX STREAMS generated)
   // when max_streams_window() stream IDs have been made available. The loop
   // will make that many stream IDs available, so the last CloseStream should
+
   // cause a MAX STREAMS frame to be generated.
-  int i = static_cast<int>(stream_id_manager_->max_streams_window());
+  int i = static_cast<int>(stream_id_manager_.max_streams_window());
   QuicStreamId id =
-      QuicStreamIdManagerPeer::GetFirstIncomingStreamId(stream_id_manager_);
+      QuicStreamIdManagerPeer::GetFirstIncomingStreamId(&stream_id_manager_);
+  EXPECT_CALL(
+      delegate_,
+      SendMaxStreams(first_advert + stream_id_manager_.max_streams_window(),
+                     IsUnidi()));
   while (i) {
-    QuicStream* stream = session_->GetOrCreateStream(id);
-    EXPECT_NE(nullptr, stream);
-    // have to set the stream's fin-received flag to true so that it
-    // does not go into the has-not-received-byte-offset state, leading
-    // to the stream being added to the locally_closed_streams_highest_offset_
-    // map, and therefore not counting as truly being closed. The test requires
-    // that the stream truly close, so that new streams become available,
-    // causing the MAX_STREAMS to be sent.
-    stream->set_fin_received(true);
-    EXPECT_EQ(id, stream->id());
-    if (IsBidi()) {
-      // Only send reset for incoming bidirectional streams.
-      EXPECT_CALL(*session_, SendRstStream(_, _, _));
-    }
-    CloseStream(stream->id());
+    EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(id));
+    stream_id_manager_.OnStreamClosed(id);
     i--;
     id += kV99StreamIdIncrement;
   }
-  EXPECT_EQ(MAX_STREAMS_FRAME, session_->save_frame().type);
-  QuicStreamCount second_advert =
-      session_->save_frame().max_streams_frame.stream_count;
-  EXPECT_EQ(first_advert + stream_id_manager_->max_streams_window(),
-            second_advert);
 }
 
 // Tast that an attempt to create an outgoing stream does not exceed the limit
 // and that it generates an appropriate STREAMS_BLOCKED frame.
 TEST_P(QuicStreamIdManagerTestServer, NewStreamDoesNotExceedLimit) {
-  // Configure with some number of streams, and allow frame transmission
-  QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
-      session_->config(), 100);
-  QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(session_->config(),
-                                                             100);
-  session_->OnConfigNegotiated();
+  EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(IsUnidi()));
+  stream_id_manager_.SetMaxOpenOutgoingStreams(100);
+  stream_id_manager_.OnConfigNegotiated();
 
-  size_t stream_count = stream_id_manager_->outgoing_max_streams();
+  size_t stream_count = stream_id_manager_.outgoing_max_streams();
   EXPECT_NE(0u, stream_count);
-  TestQuicStream* stream;
+
   while (stream_count) {
-    stream = IsBidi() ? session_->CreateOutgoingBidirectionalStream()
-                      : session_->CreateOutgoingUnidirectionalStream();
-    EXPECT_NE(stream, nullptr);
+    EXPECT_TRUE(stream_id_manager_.CanOpenNextOutgoingStream());
+    stream_id_manager_.GetNextOutgoingStreamId();
     stream_count--;
   }
 
-  EXPECT_EQ(stream_id_manager_->outgoing_stream_count(),
-            stream_id_manager_->outgoing_max_streams());
+  EXPECT_EQ(stream_id_manager_.outgoing_stream_count(),
+            stream_id_manager_.outgoing_max_streams());
   // Create another, it should fail. Should also send a STREAMS_BLOCKED
   // control frame.
-  EXPECT_CALL(*connection_, SendControlFrame(_));
-  stream = IsBidi() ? session_->CreateOutgoingBidirectionalStream()
-                    : session_->CreateOutgoingUnidirectionalStream();
-  EXPECT_EQ(nullptr, stream);
+  EXPECT_CALL(delegate_, SendStreamsBlocked(_, IsUnidi()));
+  EXPECT_FALSE(stream_id_manager_.CanOpenNextOutgoingStream());
 }
 
 // Check that the parameters used by the stream ID manager are properly
@@ -821,27 +674,27 @@
   // These fields are inited via the QuicSession constructor to default
   // values defined as a constant.
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->incoming_initial_max_open_streams());
+            stream_id_manager_.incoming_initial_max_open_streams());
 
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->incoming_actual_max_streams());
+            stream_id_manager_.incoming_actual_max_streams());
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            stream_id_manager_->outgoing_max_streams());
+            stream_id_manager_.outgoing_max_streams());
 
   // The window for advertising updates to the MAX STREAM ID is half the number
   // of stream allowed.
   EXPECT_EQ(kDefaultMaxStreamsPerConnection / kMaxStreamsWindowDivisor,
-            stream_id_manager_->max_streams_window());
+            stream_id_manager_.max_streams_window());
 }
 
 TEST_P(QuicStreamIdManagerTestServer, AvailableStreams) {
-  stream_id_manager_->MaybeIncreaseLargestPeerStreamId(
+  stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
       IsBidi() ? GetNthClientInitiatedBidirectionalId(3)
                : GetNthClientInitiatedUnidirectionalId(3));
-  EXPECT_TRUE(stream_id_manager_->IsAvailableStream(
+  EXPECT_TRUE(stream_id_manager_.IsAvailableStream(
       IsBidi() ? GetNthClientInitiatedBidirectionalId(1)
                : GetNthClientInitiatedUnidirectionalId(1)));
-  EXPECT_TRUE(stream_id_manager_->IsAvailableStream(
+  EXPECT_TRUE(stream_id_manager_.IsAvailableStream(
       IsBidi() ? GetNthClientInitiatedBidirectionalId(2)
                : GetNthClientInitiatedUnidirectionalId(2)));
 }
@@ -851,7 +704,7 @@
 // This is a regression for Chromium bugs 909987 and 910040
 TEST_P(QuicStreamIdManagerTestServer, ExtremeMaybeIncreaseLargestPeerStreamId) {
   QuicStreamId too_big_stream_id = StreamCountToId(
-      stream_id_manager_->incoming_actual_max_streams() + 20,
+      stream_id_manager_.incoming_actual_max_streams() + 20,
       Perspective::IS_CLIENT);  // This node is a server, incoming stream
                                 // ids must be client-originated.
   std::string error_details;
@@ -865,10 +718,9 @@
     error_details = "Stream id 478 would exceed stream count limit 100";
   }
 
-  EXPECT_CALL(*connection_,
-              CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
+  EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, error_details));
   EXPECT_FALSE(
-      stream_id_manager_->MaybeIncreaseLargestPeerStreamId(too_big_stream_id));
+      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(too_big_stream_id));
 }
 
 }  // namespace
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index fa42643..98c6e8c 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -11,17 +11,24 @@
 
 UberQuicStreamIdManager::UberQuicStreamIdManager(
     QuicSession* session,
+    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,
                                        /*unidirectional=*/false,
+                                       session->perspective(),
+                                       session->transport_version(),
+                                       0,
                                        max_open_outgoing_bidirectional_streams,
                                        max_open_incoming_bidirectional_streams),
       unidirectional_stream_id_manager_(
           session,
           /*unidirectional=*/true,
+          session->perspective(),
+          session->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 5505475..dab571d 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -22,6 +22,7 @@
  public:
   UberQuicStreamIdManager(
       QuicSession* session,
+      QuicStreamCount num_expected_unidirectiona_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 7e3cc8c..b4ef1cc 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -315,7 +315,7 @@
 
 TEST_P(UberQuicStreamIdManagerTest, OnStreamsBlockedFrame) {
   // Allow MAX_STREAMS frame transmission
-  QuicSessionPeer::set_is_configured(session_.get(), true);
+  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).