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