diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 22252ae..5376bfd 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -825,13 +825,6 @@
   control_frame_manager_.WriteOrBufferWindowUpdate(id, byte_offset);
 }
 
-void QuicSession::OnStreamIdManagerError(QuicErrorCode error_code,
-                                         std::string error_details) {
-  connection_->CloseConnection(
-      error_code, error_details,
-      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-}
-
 void QuicSession::OnStreamError(QuicErrorCode error_code,
                                 std::string error_details) {
   connection_->CloseConnection(
@@ -1630,7 +1623,15 @@
 bool QuicSession::MaybeIncreaseLargestPeerStreamId(
     const QuicStreamId stream_id) {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.MaybeIncreaseLargestPeerStreamId(stream_id);
+    std::string error_details;
+    if (v99_streamid_manager_.MaybeIncreaseLargestPeerStreamId(
+            stream_id, &error_details)) {
+      return true;
+    }
+    connection()->CloseConnection(
+        QUIC_INVALID_STREAM_ID, error_details,
+        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+    return false;
   }
   if (!stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id)) {
     connection()->CloseConnection(
@@ -2223,7 +2224,14 @@
 }
 
 bool QuicSession::OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) {
-  return v99_streamid_manager_.OnStreamsBlockedFrame(frame);
+  std::string error_details;
+  if (v99_streamid_manager_.OnStreamsBlockedFrame(frame, &error_details)) {
+    return true;
+  }
+  connection_->CloseConnection(
+      QUIC_STREAMS_BLOCKED_ERROR, error_details,
+      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+  return false;
 }
 
 size_t QuicSession::max_open_incoming_bidirectional_streams() const {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 567126a..ac99a3f 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -149,9 +149,6 @@
   bool HasUnackedCryptoData() const override;
   bool HasUnackedStreamData() const override;
 
-  // QuicStreamIdManager::DelegateInterface methods:
-  void OnStreamIdManagerError(QuicErrorCode error_code,
-                              std::string error_details) override;
   void SendMaxStreams(QuicStreamCount stream_count,
                       bool unidirectional) override;
   // The default implementation does nothing. Subclasses should override if
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 443af09..4da502d 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -815,9 +815,7 @@
         *connection_,
         CloseConnection(QUIC_INVALID_STREAM_ID,
                         "Stream id 798 would exceed stream count limit 50",
-                        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET
-
-                        ))
+                        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET))
         .Times(1);
     EXPECT_EQ(nullptr, session_.GetOrCreateStream(
                            GetNthClientInitiatedUnidirectionalId(199)));
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index 9a52ff3..c6869a2 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -51,15 +51,16 @@
 // The peer sends a streams blocked frame when it can not open any more
 // streams because it has runs into the limit.
 bool QuicStreamIdManager::OnStreamsBlockedFrame(
-    const QuicStreamsBlockedFrame& frame) {
+    const QuicStreamsBlockedFrame& frame,
+    std::string* error_details) {
   // Ensure that the frame has the correct directionality.
   DCHECK_EQ(frame.unidirectional, unidirectional_);
   if (frame.stream_count > incoming_advertised_max_streams_) {
     // Peer thinks it can send more streams that we've told it.
     // This is a protocol error.
-    QUIC_CODE_COUNT(quic_streams_blocked_too_big);
-    delegate_->OnStreamIdManagerError(QUIC_STREAMS_BLOCKED_ERROR,
-                                      "Invalid stream count specified");
+    *error_details = quiche::QuicheStrCat(
+        "StreamsBlockedFrame's stream count ", frame.stream_count,
+        " exceeds incoming max stream ", incoming_advertised_max_streams_);
     return false;
   }
   if (frame.stream_count < incoming_actual_max_streams_) {
@@ -68,7 +69,6 @@
     // frame in this case is not controlled by the window.
     SendMaxStreamsFrame();
   }
-  QUIC_CODE_COUNT(quic_streams_blocked_id_correct);
   return true;
 }
 
@@ -155,7 +155,8 @@
 }
 
 bool QuicStreamIdManager::MaybeIncreaseLargestPeerStreamId(
-    const QuicStreamId stream_id) {
+    const QuicStreamId stream_id,
+    std::string* error_details) {
   // |stream_id| must be an incoming stream of the right directionality.
   DCHECK_NE(QuicUtils::IsBidirectionalStreamId(stream_id), unidirectional_);
   DCHECK_NE(QuicUtils::IsServerInitiatedStreamId(transport_version_, stream_id),
@@ -186,11 +187,9 @@
                     << "Failed to create a new incoming stream with id:"
                     << stream_id << ", reaching MAX_STREAMS limit: "
                     << incoming_advertised_max_streams_ << ".";
-    delegate_->OnStreamIdManagerError(
-        QUIC_INVALID_STREAM_ID,
-        quiche::QuicheStrCat("Stream id ", stream_id,
-                             " would exceed stream count limit ",
-                             incoming_advertised_max_streams_));
+    *error_details = quiche::QuicheStrCat("Stream id ", stream_id,
+                                          " would exceed stream count limit ",
+                                          incoming_advertised_max_streams_);
     return false;
   }
 
diff --git a/quic/core/quic_stream_id_manager.h b/quic/core/quic_stream_id_manager.h
index b3079b2..fa4b1a0 100644
--- a/quic/core/quic_stream_id_manager.h
+++ b/quic/core/quic_stream_id_manager.h
@@ -33,10 +33,6 @@
    public:
     virtual ~DelegateInterface() = default;
 
-    // Closes the connection when an error is encountered.
-    virtual void OnStreamIdManagerError(QuicErrorCode error_code,
-                                        std::string error_details) = 0;
-
     // Send a MAX_STREAMS frame.
     virtual void SendMaxStreams(QuicStreamCount stream_count,
                                 bool unidirectional) = 0;
@@ -69,11 +65,10 @@
         ", max_streams_window_: ", max_streams_window_, " }");
   }
 
-  // Processes the STREAMS_BLOCKED frame, invoked from
-  // QuicSession::OnStreamsBlockedFrame. It has the same semantics as the
-  // QuicFramerVisitorInterface, returning true if the framer should continue
-  // processing the packet, false if not.
-  bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame);
+  // Processes the STREAMS_BLOCKED frame. If error is encountered, populates
+  // |error_details| and returns false.
+  bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame,
+                             std::string* error_details);
 
   // Indicates whether the next outgoing stream ID can be allocated or not.
   bool CanOpenNextOutgoingStream() const;
@@ -100,12 +95,13 @@
   bool MaybeAllowNewOutgoingStreams(QuicStreamCount max_open_streams);
 
   // Checks if the incoming stream ID exceeds the MAX_STREAMS limit.  If the
-  // limit is exceeded, closes the connection and returns false.  Uses the
+  // limit is exceeded, populates |error_detials| and returns false.  Uses the
   // actual maximium, not the most recently advertised value, in order to
   // enforce the Google-QUIC number of open streams behavior.
   // This method should be called exactly once for each incoming stream
   // creation.
-  bool MaybeIncreaseLargestPeerStreamId(const QuicStreamId stream_id);
+  bool MaybeIncreaseLargestPeerStreamId(const QuicStreamId stream_id,
+                                        std::string* error_details);
 
   // Returns true if |id| is still available.
   bool IsAvailableStream(QuicStreamId id) const;
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 73a4ff9..3207e59 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -24,9 +24,6 @@
 
 class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
-  MOCK_METHOD1(OnCanCreateNewOutgoingStream, void(bool unidirectional));
-  MOCK_METHOD2(OnStreamIdManagerError,
-               void(QuicErrorCode error_code, std::string error_details));
   MOCK_METHOD2(SendMaxStreams,
                void(QuicStreamCount stream_count, bool unidirectional));
 };
@@ -153,7 +150,8 @@
       stream_id_manager_.incoming_initial_max_open_streams();
   QuicStreamsBlockedFrame frame(0, stream_count - 1, IsUnidirectional());
   EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()));
-  stream_id_manager_.OnStreamsBlockedFrame(frame);
+  std::string error_details;
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 }
 
 // Check the case of the stream count in a STREAMS_BLOCKED frame is equal to the
@@ -170,12 +168,15 @@
 // the count most recently advertised in a MAX_STREAMS frame. Expect a
 // connection close with an error.
 TEST_P(QuicStreamIdManagerTest, ProcessStreamsBlockedTooBig) {
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(QUIC_STREAMS_BLOCKED_ERROR, _));
   EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
   QuicStreamCount stream_count =
       stream_id_manager_.incoming_initial_max_open_streams() + 1;
   QuicStreamsBlockedFrame frame(0, stream_count, IsUnidirectional());
-  stream_id_manager_.OnStreamsBlockedFrame(frame);
+  std::string error_details;
+  EXPECT_FALSE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
+  EXPECT_EQ(
+      error_details,
+      "StreamsBlockedFrame's stream count 101 exceeds incoming max stream 100");
 }
 
 // Same basic tests as above, but calls
@@ -187,27 +188,28 @@
 TEST_P(QuicStreamIdManagerTest, IsIncomingStreamIdValidBelowLimit) {
   QuicStreamId stream_id = GetNthIncomingStreamId(
       stream_id_manager_.incoming_actual_max_streams() - 2);
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(_, _)).Times(0);
-  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
+  EXPECT_TRUE(
+      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id, nullptr));
 }
 
 // Accept a stream with an ID that equals the limit.
 TEST_P(QuicStreamIdManagerTest, IsIncomingStreamIdValidAtLimit) {
   QuicStreamId stream_id = GetNthIncomingStreamId(
       stream_id_manager_.incoming_actual_max_streams() - 1);
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(_, _)).Times(0);
-  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
+  EXPECT_TRUE(
+      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id, nullptr));
 }
 
 // Close the connection if the id exceeds the limit.
 TEST_P(QuicStreamIdManagerTest, IsIncomingStreamIdInValidAboveLimit) {
   QuicStreamId stream_id =
       GetNthIncomingStreamId(stream_id_manager_.incoming_actual_max_streams());
-  std::string error_details = quiche::QuicheStrCat(
-      "Stream id ", stream_id, " would exceed stream count limit 100");
-  EXPECT_CALL(delegate_,
-              OnStreamIdManagerError(QUIC_INVALID_STREAM_ID, error_details));
-  EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
+  std::string error_details;
+  EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
+      stream_id, &error_details));
+  EXPECT_EQ(error_details,
+            quiche::QuicheStrCat("Stream id ", stream_id,
+                                 " would exceed stream count limit 100"));
 }
 
 TEST_P(QuicStreamIdManagerTest, OnStreamsBlockedFrame) {
@@ -222,13 +224,16 @@
   // 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_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame));
+  std::string error_details;
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 
   // 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(delegate_, OnStreamIdManagerError(QUIC_STREAMS_BLOCKED_ERROR, _));
-  EXPECT_FALSE(stream_id_manager_.OnStreamsBlockedFrame(frame));
+  EXPECT_FALSE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
+  EXPECT_EQ(
+      error_details,
+      "StreamsBlockedFrame's stream count 101 exceeds incoming max stream 100");
 
   // 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
@@ -260,7 +265,7 @@
               SendMaxStreams(stream_id_manager_.incoming_actual_max_streams(),
                              IsUnidirectional()));
 
-  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame));
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
   // Check that the saved frame is correct.
   EXPECT_EQ(stream_id_manager_.incoming_actual_max_streams(),
             stream_id_manager_.incoming_advertised_max_streams());
@@ -302,16 +307,20 @@
 TEST_P(QuicStreamIdManagerTest, MaybeIncreaseLargestPeerStreamId) {
   QuicStreamId max_stream_id = GetNthIncomingStreamId(
       stream_id_manager_.incoming_actual_max_streams() - 1);
-  EXPECT_TRUE(
-      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(max_stream_id));
+  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(max_stream_id,
+                                                                  nullptr));
 
   QuicStreamId first_stream_id = GetNthIncomingStreamId(0);
-  EXPECT_TRUE(
-      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(first_stream_id));
+  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
+      first_stream_id, nullptr));
   // A bad stream ID results in a closed connection.
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(QUIC_INVALID_STREAM_ID, _));
+  std::string error_details;
   EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
-      max_stream_id + kV99StreamIdIncrement));
+      max_stream_id + kV99StreamIdIncrement, &error_details));
+  EXPECT_EQ(
+      error_details,
+      quiche::QuicheStrCat("Stream id ", max_stream_id + kV99StreamIdIncrement,
+                           " would exceed stream count limit 100"));
 }
 
 TEST_P(QuicStreamIdManagerTest, MaxStreamsWindow) {
@@ -334,7 +343,8 @@
   size_t old_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,
+                                                                    nullptr));
 
     // This node should think that the peer believes it has one fewer
     // stream it can create.
@@ -375,7 +385,8 @@
   //  SendMaxStreams(stream_id_manager_.incoming_actual_max_streams(),
   //  IsUnidirectional()));
   EXPECT_CALL(delegate_, SendMaxStreams(_, IsUnidirectional()));
-  EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id));
+  EXPECT_TRUE(
+      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id, nullptr));
   stream_id_manager_.OnStreamClosed(stream_id);
 }
 
@@ -388,14 +399,15 @@
   EXPECT_CALL(delegate_, SendMaxStreams(_, _)).Times(0);
   stream_id_manager_.SetMaxOpenIncomingStreams(0);
   frame.stream_count = 0;
-  stream_id_manager_.OnStreamsBlockedFrame(frame);
+  std::string error_details;
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 
   // 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(delegate_, SendMaxStreams(123u, IsUnidirectional()));
   stream_id_manager_.SetMaxOpenIncomingStreams(123);
   frame.stream_count = 0;
-  stream_id_manager_.OnStreamsBlockedFrame(frame);
+  EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 }
 
 // Test that a MAX_STREAMS frame is generated when half the stream ids become
@@ -419,7 +431,8 @@
       SendMaxStreams(first_advert + stream_id_manager_.max_streams_window(),
                      IsUnidirectional()));
   while (i) {
-    EXPECT_TRUE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(id));
+    EXPECT_TRUE(
+        stream_id_manager_.MaybeIncreaseLargestPeerStreamId(id, nullptr));
     stream_id_manager_.OnStreamClosed(id);
     i--;
     id += kV99StreamIdIncrement;
@@ -445,8 +458,8 @@
 }
 
 TEST_P(QuicStreamIdManagerTest, AvailableStreams) {
-  stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
-      GetNthIncomingStreamId(3));
+  stream_id_manager_.MaybeIncreaseLargestPeerStreamId(GetNthIncomingStreamId(3),
+                                                      nullptr);
 
   EXPECT_TRUE(stream_id_manager_.IsAvailableStream(GetNthIncomingStreamId(1)));
   EXPECT_TRUE(stream_id_manager_.IsAvailableStream(GetNthIncomingStreamId(2)));
@@ -460,13 +473,13 @@
 TEST_P(QuicStreamIdManagerTest, ExtremeMaybeIncreaseLargestPeerStreamId) {
   QuicStreamId too_big_stream_id = GetNthIncomingStreamId(
       stream_id_manager_.incoming_actual_max_streams() + 20);
-  std::string error_details = quiche::QuicheStrCat(
-      "Stream id ", too_big_stream_id, " would exceed stream count limit 100");
 
-  EXPECT_CALL(delegate_,
-              OnStreamIdManagerError(QUIC_INVALID_STREAM_ID, error_details));
-  EXPECT_FALSE(
-      stream_id_manager_.MaybeIncreaseLargestPeerStreamId(too_big_stream_id));
+  std::string error_details;
+  EXPECT_FALSE(stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
+      too_big_stream_id, &error_details));
+  EXPECT_EQ(error_details,
+            quiche::QuicheStrCat("Stream id ", too_big_stream_id,
+                                 " would exceed stream count limit 100"));
 }
 
 }  // namespace
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index 7ef5688..daa5630 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -67,12 +67,14 @@
 }
 
 bool UberQuicStreamIdManager::MaybeIncreaseLargestPeerStreamId(
-    QuicStreamId id) {
+    QuicStreamId id,
+    std::string* error_details) {
   if (QuicUtils::IsBidirectionalStreamId(id)) {
     return bidirectional_stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
-        id);
+        id, error_details);
   }
-  return unidirectional_stream_id_manager_.MaybeIncreaseLargestPeerStreamId(id);
+  return unidirectional_stream_id_manager_.MaybeIncreaseLargestPeerStreamId(
+      id, error_details);
 }
 
 void UberQuicStreamIdManager::OnStreamClosed(QuicStreamId id) {
@@ -84,11 +86,14 @@
 }
 
 bool UberQuicStreamIdManager::OnStreamsBlockedFrame(
-    const QuicStreamsBlockedFrame& frame) {
+    const QuicStreamsBlockedFrame& frame,
+    std::string* error_details) {
   if (frame.unidirectional) {
-    return unidirectional_stream_id_manager_.OnStreamsBlockedFrame(frame);
+    return unidirectional_stream_id_manager_.OnStreamsBlockedFrame(
+        frame, error_details);
   }
-  return bidirectional_stream_id_manager_.OnStreamsBlockedFrame(frame);
+  return bidirectional_stream_id_manager_.OnStreamsBlockedFrame(frame,
+                                                                error_details);
 }
 
 bool UberQuicStreamIdManager::IsIncomingStream(QuicStreamId id) const {
diff --git a/quic/core/uber_quic_stream_id_manager.h b/quic/core/uber_quic_stream_id_manager.h
index b505487..d3f374a 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -56,13 +56,15 @@
   QuicStreamId GetNextOutgoingUnidirectionalStreamId();
 
   // Returns true if the incoming |id| is within the limit.
-  bool MaybeIncreaseLargestPeerStreamId(QuicStreamId id);
+  bool MaybeIncreaseLargestPeerStreamId(QuicStreamId id,
+                                        std::string* error_details);
 
   // Called when |id| is released.
   void OnStreamClosed(QuicStreamId id);
 
   // Called when a STREAMS_BLOCKED frame is received.
-  bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame);
+  bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame,
+                             std::string* error_details);
 
   // Return true if |id| is peer initiated.
   bool IsIncomingStream(QuicStreamId id) const;
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 3522008..4fc1cca 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -46,9 +46,6 @@
 
 class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
-  MOCK_METHOD1(OnCanCreateNewOutgoingStream, void(bool unidirectional));
-  MOCK_METHOD2(OnStreamIdManagerError,
-               void(QuicErrorCode error_code, std::string error_details));
   MOCK_METHOD2(SendMaxStreams,
                void(QuicStreamCount stream_count, bool unidirectional));
 };
@@ -191,21 +188,29 @@
   size_t i;
   for (i = 0; i < kNumMaxIncomingStreams; i++) {
     EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
-        GetNthPeerInitiatedUnidirectionalStreamId(i)));
+        GetNthPeerInitiatedUnidirectionalStreamId(i), nullptr));
     EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
-        GetNthPeerInitiatedBidirectionalStreamId(i)));
+        GetNthPeerInitiatedBidirectionalStreamId(i), nullptr));
   }
   // Should be able to open the next bidirectional stream
   EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
-      GetNthPeerInitiatedBidirectionalStreamId(i)));
+      GetNthPeerInitiatedBidirectionalStreamId(i), nullptr));
 
   // We should have exhausted the counts, the next streams should fail
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(QUIC_INVALID_STREAM_ID, _));
+  std::string error_details;
   EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
-      GetNthPeerInitiatedUnidirectionalStreamId(i)));
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(QUIC_INVALID_STREAM_ID, _));
+      GetNthPeerInitiatedUnidirectionalStreamId(i), &error_details));
+  EXPECT_EQ(error_details,
+            quiche::QuicheStrCat(
+                "Stream id ", GetNthPeerInitiatedUnidirectionalStreamId(i),
+                " would exceed stream count limit ", kNumMaxIncomingStreams));
   EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
-      GetNthPeerInitiatedBidirectionalStreamId(i + 1)));
+      GetNthPeerInitiatedBidirectionalStreamId(i + 1), &error_details));
+  EXPECT_EQ(
+      error_details,
+      quiche::QuicheStrCat(
+          "Stream id ", GetNthPeerInitiatedBidirectionalStreamId(i + 1),
+          " would exceed stream count limit ", kNumMaxIncomingStreams + 1));
 }
 
 TEST_P(UberQuicStreamIdManagerTest, GetNextOutgoingStreamId) {
@@ -223,14 +228,14 @@
 
 TEST_P(UberQuicStreamIdManagerTest, AvailableStreams) {
   EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
-      GetNthPeerInitiatedBidirectionalStreamId(3)));
+      GetNthPeerInitiatedBidirectionalStreamId(3), nullptr));
   EXPECT_TRUE(
       manager_.IsAvailableStream(GetNthPeerInitiatedBidirectionalStreamId(1)));
   EXPECT_TRUE(
       manager_.IsAvailableStream(GetNthPeerInitiatedBidirectionalStreamId(2)));
 
   EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
-      GetNthPeerInitiatedUnidirectionalStreamId(3)));
+      GetNthPeerInitiatedUnidirectionalStreamId(3), nullptr));
   EXPECT_TRUE(
       manager_.IsAvailableStream(GetNthPeerInitiatedUnidirectionalStreamId(1)));
   EXPECT_TRUE(
@@ -238,32 +243,40 @@
 }
 
 TEST_P(UberQuicStreamIdManagerTest, MaybeIncreaseLargestPeerStreamId) {
-  EXPECT_CALL(delegate_, OnStreamIdManagerError(_, _)).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)));
+  EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
+      StreamCountToId(manager_.max_incoming_bidirectional_streams(),
+                      QuicUtils::InvertPerspective(perspective()),
+                      /* bidirectional=*/true),
+      nullptr));
+  EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
+      StreamCountToId(manager_.max_incoming_bidirectional_streams(),
+                      QuicUtils::InvertPerspective(perspective()),
+                      /* bidirectional=*/false),
+      nullptr));
 
-  std::string error_details =
+  std::string expected_error_details =
       perspective() == Perspective::IS_SERVER
           ? "Stream id 400 would exceed stream count limit 100"
           : "Stream id 401 would exceed stream count limit 100";
+  std::string error_details;
 
-  EXPECT_CALL(delegate_,
-              OnStreamIdManagerError(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(delegate_,
-              OnStreamIdManagerError(QUIC_INVALID_STREAM_ID, error_details));
-  EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
-      manager_.max_incoming_bidirectional_streams() + 1,
-      QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/false)));
+  EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
+      StreamCountToId(manager_.max_incoming_bidirectional_streams() + 1,
+                      QuicUtils::InvertPerspective(perspective()),
+                      /* bidirectional=*/true),
+      &error_details));
+  EXPECT_EQ(expected_error_details, error_details);
+  expected_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_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
+      StreamCountToId(manager_.max_incoming_bidirectional_streams() + 1,
+                      QuicUtils::InvertPerspective(perspective()),
+                      /* bidirectional=*/false),
+      &error_details));
+  EXPECT_EQ(expected_error_details, error_details);
 }
 
 TEST_P(UberQuicStreamIdManagerTest, OnStreamsBlockedFrame) {
@@ -275,7 +288,7 @@
   EXPECT_CALL(delegate_,
               SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
                              frame.unidirectional));
-  manager_.OnStreamsBlockedFrame(frame);
+  EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
 
   stream_count = manager_.advertised_max_incoming_unidirectional_streams() - 1;
   frame.stream_count = stream_count;
@@ -284,7 +297,7 @@
   EXPECT_CALL(delegate_,
               SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
                              frame.unidirectional));
-  manager_.OnStreamsBlockedFrame(frame);
+  EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
 }
 
 TEST_P(UberQuicStreamIdManagerTest, IsIncomingStream) {