Remove "incoming" from QUIC stream limit config code.
The word "incoming" adds confusion because we need to think in the peer's perspective on names like "ReceivedMaxIncomingStreamLimit". And since there's no accorded "MaxOutgoingStreamLimit", we don't need "incoming" here.
After this change, "MaxBidirectionalStreamsToSend" means the stream limit we want the peer to have, and "ReceivedMaxBidirectionalStreams" means the stream limit the peer wants.
gfe-relnote: no behavior change. Not protected.
PiperOrigin-RevId: 288524398
Change-Id: I968eae53df8d2c406b6b486356549c8a858e11d5
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 465d4ff..c5d14ec 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -1732,12 +1732,11 @@
}
}
-TEST_P(EndToEndTestWithTls, MaxIncomingDynamicStreamsLimitRespected) {
+TEST_P(EndToEndTestWithTls, MaxDynamicStreamsLimitRespected) {
// Set a limit on maximum number of incoming dynamic streams.
- // Make sure the limit is respected.
- const uint32_t kServerMaxIncomingDynamicStreams = 1;
- server_config_.SetMaxIncomingBidirectionalStreamsToSend(
- kServerMaxIncomingDynamicStreams);
+ // Make sure the limit is respected by the peer.
+ const uint32_t kServerMaxDynamicStreams = 1;
+ server_config_.SetMaxBidirectionalStreamsToSend(kServerMaxDynamicStreams);
ASSERT_TRUE(Initialize());
if (VersionHasIetfQuicFrames(
GetParam().negotiated_version.transport_version)) {
@@ -1776,18 +1775,14 @@
EXPECT_THAT(client_->connection_error(), IsQuicNoError());
}
-TEST_P(EndToEndTest, SetIndependentMaxIncomingDynamicStreamsLimits) {
- // Each endpoint can set max incoming dynamic streams independently.
- const uint32_t kClientMaxIncomingDynamicStreams = 4;
- const uint32_t kServerMaxIncomingDynamicStreams = 3;
- client_config_.SetMaxIncomingBidirectionalStreamsToSend(
- kClientMaxIncomingDynamicStreams);
- server_config_.SetMaxIncomingBidirectionalStreamsToSend(
- kServerMaxIncomingDynamicStreams);
- client_config_.SetMaxIncomingUnidirectionalStreamsToSend(
- kClientMaxIncomingDynamicStreams);
- server_config_.SetMaxIncomingUnidirectionalStreamsToSend(
- kServerMaxIncomingDynamicStreams);
+TEST_P(EndToEndTest, SetIndependentMaxDynamicStreamsLimits) {
+ // Each endpoint can set max dynamic streams independently.
+ const uint32_t kClientMaxDynamicStreams = 4;
+ const uint32_t kServerMaxDynamicStreams = 3;
+ client_config_.SetMaxBidirectionalStreamsToSend(kClientMaxDynamicStreams);
+ server_config_.SetMaxBidirectionalStreamsToSend(kServerMaxDynamicStreams);
+ client_config_.SetMaxUnidirectionalStreamsToSend(kClientMaxDynamicStreams);
+ server_config_.SetMaxUnidirectionalStreamsToSend(kServerMaxDynamicStreams);
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
@@ -1815,9 +1810,9 @@
client_session->num_expected_unidirectional_static_streams()
: QuicSessionPeer::GetStreamIdManager(client_session)
->max_open_outgoing_streams();
- EXPECT_EQ(kServerMaxIncomingDynamicStreams,
+ EXPECT_EQ(kServerMaxDynamicStreams,
client_max_open_outgoing_bidirectional_streams);
- EXPECT_EQ(kServerMaxIncomingDynamicStreams,
+ EXPECT_EQ(kServerMaxDynamicStreams,
client_max_open_outgoing_unidirectional_streams);
server_thread_->Pause();
QuicSession* server_session = GetServerSession();
@@ -1836,9 +1831,9 @@
server_session->num_expected_unidirectional_static_streams()
: QuicSessionPeer::GetStreamIdManager(server_session)
->max_open_outgoing_streams();
- EXPECT_EQ(kClientMaxIncomingDynamicStreams,
+ EXPECT_EQ(kClientMaxDynamicStreams,
server_max_open_outgoing_bidirectional_streams);
- EXPECT_EQ(kClientMaxIncomingDynamicStreams,
+ EXPECT_EQ(kClientMaxDynamicStreams,
server_max_open_outgoing_unidirectional_streams);
server_thread_->Resume();
@@ -3142,10 +3137,10 @@
const size_t kNumMaxStreams = 10;
EndToEndTestServerPush() : EndToEndTest() {
- client_config_.SetMaxIncomingBidirectionalStreamsToSend(kNumMaxStreams);
- server_config_.SetMaxIncomingBidirectionalStreamsToSend(kNumMaxStreams);
- client_config_.SetMaxIncomingUnidirectionalStreamsToSend(kNumMaxStreams);
- server_config_.SetMaxIncomingUnidirectionalStreamsToSend(kNumMaxStreams);
+ client_config_.SetMaxBidirectionalStreamsToSend(kNumMaxStreams);
+ server_config_.SetMaxBidirectionalStreamsToSend(kNumMaxStreams);
+ client_config_.SetMaxUnidirectionalStreamsToSend(kNumMaxStreams);
+ server_config_.SetMaxUnidirectionalStreamsToSend(kNumMaxStreams);
support_server_push_ = true;
}
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index 9d3504e..ab5b89a 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -83,8 +83,7 @@
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
session_.config(), kMinimumFlowControlSendWindow);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- session_.config(), 3);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 3);
session_.OnConfigNegotiated();
}
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 0018bbe..d8063d1 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -129,12 +129,12 @@
KeyExchangeSource::Default()),
compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
- config_.SetMaxIncomingBidirectionalStreamsToSend(kMaxStreamsForTest);
- config_.SetMaxIncomingUnidirectionalStreamsToSend(kMaxStreamsForTest);
- QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
- &config_, kMaxStreamsForTest);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- &config_, kMaxStreamsForTest);
+ config_.SetMaxBidirectionalStreamsToSend(kMaxStreamsForTest);
+ config_.SetMaxUnidirectionalStreamsToSend(kMaxStreamsForTest);
+ QuicConfigPeer::SetReceivedMaxBidirectionalStreams(&config_,
+ kMaxStreamsForTest);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(&config_,
+ kMaxStreamsForTest);
config_.SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
config_.SetInitialSessionFlowControlWindowToSend(
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 89f719d..2ebcbed 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -156,14 +156,12 @@
session_->GetMutableCryptoStream());
QuicConfig config = DefaultQuicConfig();
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
- config.SetMaxIncomingUnidirectionalStreamsToSend(
+ config.SetMaxUnidirectionalStreamsToSend(
server_max_incoming_streams +
session_->num_expected_unidirectional_static_streams());
- config.SetMaxIncomingBidirectionalStreamsToSend(
- server_max_incoming_streams);
+ config.SetMaxBidirectionalStreamsToSend(server_max_incoming_streams);
} else {
- config.SetMaxIncomingBidirectionalStreamsToSend(
- server_max_incoming_streams);
+ config.SetMaxBidirectionalStreamsToSend(server_max_incoming_streams);
}
std::unique_ptr<QuicCryptoServerConfig> crypto_config =
crypto_test_utils::CryptoServerConfigForTesting();
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 82b5728..1aef2e3 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -399,8 +399,8 @@
headers_stream_ = headers_stream.get();
ActivateStream(std::move(headers_stream));
} else {
- ConfigureMaxIncomingDynamicStreamsToSend(
- config()->GetMaxIncomingUnidirectionalStreamsToSend());
+ ConfigureMaxDynamicStreamsToSend(
+ config()->GetMaxUnidirectionalStreamsToSend());
qpack_encoder_ = std::make_unique<QpackEncoder>(this);
qpack_decoder_ =
std::make_unique<QpackDecoder>(qpack_maximum_dynamic_table_capacity_,
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index ac5f707..e0c7823 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -342,7 +342,7 @@
session_.config()->SetInitialSessionFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
if (VersionUsesHttp3(transport_version())) {
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(
session_.config(),
session_.num_expected_unidirectional_static_streams());
}
@@ -1535,8 +1535,7 @@
if (!VersionUsesHttp3(transport_version())) {
return;
}
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(session_.config(),
- 2u);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 2u);
EXPECT_CALL(
*connection_,
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 8480ec7..9b17b65 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -221,8 +221,7 @@
session_->config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
session_->config(), kMinimumFlowControlSendWindow);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- session_->config(), 10);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_->config(), 10);
session_->OnConfigNegotiated();
if (!session_->use_handshake_delegate() ||
session_->perspective() == Perspective::IS_CLIENT) {
diff --git a/quic/core/qpack/qpack_send_stream_test.cc b/quic/core/qpack/qpack_send_stream_test.cc
index e1f32bb..ab0f3d7 100644
--- a/quic/core/qpack/qpack_send_stream_test.cc
+++ b/quic/core/qpack/qpack_send_stream_test.cc
@@ -70,8 +70,7 @@
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
session_.config(), kMinimumFlowControlSendWindow);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- session_.config(), 3);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 3);
session_.OnConfigNegotiated();
qpack_send_stream_ =
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index d5c4d33..86b4a97 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -404,7 +404,8 @@
client_connection_options_(kCLOP, PRESENCE_OPTIONAL),
idle_network_timeout_seconds_(kICSL, PRESENCE_REQUIRED),
silent_close_(kSCLS, PRESENCE_OPTIONAL),
- max_incoming_bidirectional_streams_(kMIBS, PRESENCE_REQUIRED),
+ max_bidirectional_streams_(kMIBS, PRESENCE_REQUIRED),
+ max_unidirectional_streams_(kMIUS, PRESENCE_OPTIONAL),
bytes_for_connection_id_(kTCID, PRESENCE_OPTIONAL),
initial_round_trip_time_us_(kIRTT, PRESENCE_OPTIONAL),
initial_max_stream_data_bytes_incoming_bidirectional_(0,
@@ -418,7 +419,6 @@
alternate_server_address_(kASAD, PRESENCE_OPTIONAL),
support_max_header_list_size_(kSMHL, PRESENCE_OPTIONAL),
stateless_reset_token_(kSRST, PRESENCE_OPTIONAL),
- max_incoming_unidirectional_streams_(kMIUS, PRESENCE_OPTIONAL),
max_ack_delay_ms_(kMAD, PRESENCE_OPTIONAL),
ack_delay_exponent_(kADE, PRESENCE_OPTIONAL),
max_packet_size_(0, PRESENCE_OPTIONAL),
@@ -515,38 +515,36 @@
return silent_close_.GetUint32() > 0;
}
-void QuicConfig::SetMaxIncomingBidirectionalStreamsToSend(
- uint32_t max_streams) {
- max_incoming_bidirectional_streams_.SetSendValue(max_streams);
+void QuicConfig::SetMaxBidirectionalStreamsToSend(uint32_t max_streams) {
+ max_bidirectional_streams_.SetSendValue(max_streams);
}
-uint32_t QuicConfig::GetMaxIncomingBidirectionalStreamsToSend() const {
- return max_incoming_bidirectional_streams_.GetSendValue();
+uint32_t QuicConfig::GetMaxBidirectionalStreamsToSend() const {
+ return max_bidirectional_streams_.GetSendValue();
}
-bool QuicConfig::HasReceivedMaxIncomingBidirectionalStreams() const {
- return max_incoming_bidirectional_streams_.HasReceivedValue();
+bool QuicConfig::HasReceivedMaxBidirectionalStreams() const {
+ return max_bidirectional_streams_.HasReceivedValue();
}
-uint32_t QuicConfig::ReceivedMaxIncomingBidirectionalStreams() const {
- return max_incoming_bidirectional_streams_.GetReceivedValue();
+uint32_t QuicConfig::ReceivedMaxBidirectionalStreams() const {
+ return max_bidirectional_streams_.GetReceivedValue();
}
-void QuicConfig::SetMaxIncomingUnidirectionalStreamsToSend(
- uint32_t max_streams) {
- max_incoming_unidirectional_streams_.SetSendValue(max_streams);
+void QuicConfig::SetMaxUnidirectionalStreamsToSend(uint32_t max_streams) {
+ max_unidirectional_streams_.SetSendValue(max_streams);
}
-uint32_t QuicConfig::GetMaxIncomingUnidirectionalStreamsToSend() const {
- return max_incoming_unidirectional_streams_.GetSendValue();
+uint32_t QuicConfig::GetMaxUnidirectionalStreamsToSend() const {
+ return max_unidirectional_streams_.GetSendValue();
}
-bool QuicConfig::HasReceivedMaxIncomingUnidirectionalStreams() const {
- return max_incoming_unidirectional_streams_.HasReceivedValue();
+bool QuicConfig::HasReceivedMaxUnidirectionalStreams() const {
+ return max_unidirectional_streams_.HasReceivedValue();
}
-uint32_t QuicConfig::ReceivedMaxIncomingUnidirectionalStreams() const {
- return max_incoming_unidirectional_streams_.GetReceivedValue();
+uint32_t QuicConfig::ReceivedMaxUnidirectionalStreams() const {
+ return max_unidirectional_streams_.GetReceivedValue();
}
void QuicConfig::SetMaxAckDelayToSendMs(uint32_t max_ack_delay_ms) {
@@ -828,8 +826,8 @@
idle_network_timeout_seconds_.set(kMaximumIdleTimeoutSecs,
kDefaultIdleTimeoutSecs);
silent_close_.set(1, 0);
- SetMaxIncomingBidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection);
- SetMaxIncomingUnidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection);
+ SetMaxBidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection);
+ SetMaxUnidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection);
max_time_before_crypto_handshake_ =
QuicTime::Delta::FromSeconds(kMaxTimeForCryptoHandshakeSecs);
max_idle_time_before_crypto_handshake_ =
@@ -853,9 +851,9 @@
// Do not need a version check here, max...bi... will encode
// as "MIDS" -- the max initial dynamic streams tag -- if
// doing some version other than IETF QUIC.
- max_incoming_bidirectional_streams_.ToHandshakeMessage(out);
+ max_bidirectional_streams_.ToHandshakeMessage(out);
if (VersionHasIetfQuicFrames(transport_version)) {
- max_incoming_unidirectional_streams_.ToHandshakeMessage(out);
+ max_unidirectional_streams_.ToHandshakeMessage(out);
ack_delay_exponent_.ToHandshakeMessage(out);
}
if (GetQuicReloadableFlag(quic_negotiate_ack_delay_time)) {
@@ -889,12 +887,12 @@
silent_close_.ProcessPeerHello(peer_hello, hello_type, error_details);
}
if (error == QUIC_NO_ERROR) {
- error = max_incoming_bidirectional_streams_.ProcessPeerHello(
- peer_hello, hello_type, error_details);
+ error = max_bidirectional_streams_.ProcessPeerHello(peer_hello, hello_type,
+ error_details);
}
if (error == QUIC_NO_ERROR) {
- error = max_incoming_unidirectional_streams_.ProcessPeerHello(
- peer_hello, hello_type, error_details);
+ error = max_unidirectional_streams_.ProcessPeerHello(peer_hello, hello_type,
+ error_details);
}
if (error == QUIC_NO_ERROR) {
error = bytes_for_connection_id_.ProcessPeerHello(peer_hello, hello_type,
@@ -975,9 +973,9 @@
params->initial_max_stream_data_uni.set_value(
GetInitialMaxStreamDataBytesUnidirectionalToSend());
params->initial_max_streams_bidi.set_value(
- GetMaxIncomingBidirectionalStreamsToSend());
+ GetMaxBidirectionalStreamsToSend());
params->initial_max_streams_uni.set_value(
- GetMaxIncomingUnidirectionalStreamsToSend());
+ GetMaxUnidirectionalStreamsToSend());
if (GetQuicReloadableFlag(quic_negotiate_ack_delay_time)) {
QUIC_RELOADABLE_FLAG_COUNT_N(quic_negotiate_ack_delay_time, 3, 4);
params->max_ack_delay.set_value(kDefaultDelayedAckTimeMs);
@@ -1064,10 +1062,10 @@
initial_session_flow_control_window_bytes_.SetReceivedValue(
std::min<uint64_t>(params.initial_max_data.value(),
std::numeric_limits<uint32_t>::max()));
- max_incoming_bidirectional_streams_.SetReceivedValue(
+ max_bidirectional_streams_.SetReceivedValue(
std::min<uint64_t>(params.initial_max_streams_bidi.value(),
std::numeric_limits<uint32_t>::max()));
- max_incoming_unidirectional_streams_.SetReceivedValue(
+ max_unidirectional_streams_.SetReceivedValue(
std::min<uint64_t>(params.initial_max_streams_uni.value(),
std::numeric_limits<uint32_t>::max()));
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index de78d40..95a26cb 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -305,25 +305,21 @@
bool SilentClose() const;
- // Configuration for the Google QUIC and IETF QUIC stream ID managers. Note
- // that the naming is a bit weird; it is from the perspective of the node
- // generating (sending) the configuration and, thus, The "incoming" counts are
- // the number of streams that the node sending the configuration is willing to
- // accept and therefore the number that the node receiving the confguration
- // can create .. the number of outbound streams that may be intiated..
- // There are two sets, one for unidirectional streams and one for
- // bidirectional. The bidirectional set also covers Google-QUICs
- // dynamic stream count (which are bidirectional streams).
- // TODO(b/142351095) rename these to improve clarity.
- void SetMaxIncomingBidirectionalStreamsToSend(uint32_t max_streams);
- uint32_t GetMaxIncomingBidirectionalStreamsToSend() const;
- bool HasReceivedMaxIncomingBidirectionalStreams() const;
- uint32_t ReceivedMaxIncomingBidirectionalStreams() const;
+ // Sets the max bidirectional stream count that this endpoint supports.
+ void SetMaxBidirectionalStreamsToSend(uint32_t max_streams);
+ uint32_t GetMaxBidirectionalStreamsToSend() const;
- void SetMaxIncomingUnidirectionalStreamsToSend(uint32_t max_streams);
- uint32_t GetMaxIncomingUnidirectionalStreamsToSend() const;
- bool HasReceivedMaxIncomingUnidirectionalStreams() const;
- uint32_t ReceivedMaxIncomingUnidirectionalStreams() const;
+ bool HasReceivedMaxBidirectionalStreams() const;
+ // Gets the max bidirectional stream limit imposed by the peer.
+ uint32_t ReceivedMaxBidirectionalStreams() const;
+
+ // Sets the max unidirectional stream count that this endpoint supports.
+ void SetMaxUnidirectionalStreamsToSend(uint32_t max_streams);
+ uint32_t GetMaxUnidirectionalStreamsToSend() const;
+
+ bool HasReceivedMaxUnidirectionalStreams() const;
+ // Gets the max unidirectional stream limit imposed by the peer.
+ uint32_t ReceivedMaxUnidirectionalStreams() const;
void set_max_time_before_crypto_handshake(
QuicTime::Delta max_time_before_crypto_handshake) {
@@ -529,10 +525,21 @@
QuicNegotiableUint32 idle_network_timeout_seconds_;
// Whether to use silent close. Defaults to 0 (false) and is otherwise true.
QuicNegotiableUint32 silent_close_;
- // Maximum number of incoming dynamic streams that a Google QUIC connection
- // can support or the maximum number of incoming bidirectional streams that
+ // Maximum number of dynamic streams that a Google QUIC connection
+ // can support or the maximum number of bidirectional streams that
// an IETF QUIC connection can support.
- QuicFixedUint32 max_incoming_bidirectional_streams_;
+ // The SendValue is the limit on peer-created streams that this endpoint is
+ // advertising.
+ // The ReceivedValue is the limit on locally-created streams that
+ // the peer advertised.
+ QuicFixedUint32 max_bidirectional_streams_;
+ // Maximum number of unidirectional streams that the connection can
+ // support.
+ // The SendValue is the limit on peer-created streams that this endpoint is
+ // advertising.
+ // The ReceivedValue is the limit on locally-created streams that the peer
+ // advertised.
+ QuicFixedUint32 max_unidirectional_streams_;
// The number of bytes required for the connection ID.
QuicFixedUint32 bytes_for_connection_id_;
// Initial round trip time estimate in microseconds.
@@ -569,10 +576,6 @@
// packet to be processed.
QuicTagVector create_session_tag_indicators_;
- // Maximum number of incoming unidirectional streams that the connection can
- // support.
- QuicFixedUint32 max_incoming_unidirectional_streams_;
-
// Maximum ack delay. The sent value is the value used on this node.
// The received value is the value received from the peer and used by
// the peer.
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 55ce02d..6af4211 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -64,15 +64,14 @@
stream_id_manager_(perspective(),
connection->transport_version(),
kDefaultMaxStreamsPerConnection,
- config_.GetMaxIncomingBidirectionalStreamsToSend()),
- v99_streamid_manager_(
- perspective(),
- connection->version(),
- this,
- kDefaultMaxStreamsPerConnection,
- kDefaultMaxStreamsPerConnection,
- config_.GetMaxIncomingBidirectionalStreamsToSend(),
- config_.GetMaxIncomingUnidirectionalStreamsToSend()),
+ config_.GetMaxBidirectionalStreamsToSend()),
+ v99_streamid_manager_(perspective(),
+ connection->version(),
+ this,
+ kDefaultMaxStreamsPerConnection,
+ kDefaultMaxStreamsPerConnection,
+ config_.GetMaxBidirectionalStreamsToSend(),
+ config_.GetMaxUnidirectionalStreamsToSend()),
num_dynamic_incoming_streams_(0),
num_draining_incoming_streams_(0),
num_outgoing_static_streams_(0),
@@ -999,8 +998,8 @@
if (VersionHasIetfQuicFrames(transport_version())) {
uint32_t max_streams = 0;
- if (config_.HasReceivedMaxIncomingBidirectionalStreams()) {
- max_streams = config_.ReceivedMaxIncomingBidirectionalStreams();
+ if (config_.HasReceivedMaxBidirectionalStreams()) {
+ max_streams = config_.ReceivedMaxBidirectionalStreams();
}
QUIC_DVLOG(1) << ENDPOINT
<< "Setting Bidirectional outgoing_max_streams_ to "
@@ -1008,8 +1007,8 @@
v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(max_streams);
max_streams = 0;
- if (config_.HasReceivedMaxIncomingUnidirectionalStreams()) {
- max_streams = config_.ReceivedMaxIncomingUnidirectionalStreams();
+ if (config_.HasReceivedMaxUnidirectionalStreams()) {
+ max_streams = config_.ReceivedMaxUnidirectionalStreams();
}
if (max_streams < num_expected_unidirectional_static_streams_) {
// TODO(ianswett): Change this to an application error for HTTP/3.
@@ -1026,8 +1025,8 @@
v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(max_streams);
} else {
uint32_t max_streams = 0;
- if (config_.HasReceivedMaxIncomingBidirectionalStreams()) {
- max_streams = config_.ReceivedMaxIncomingBidirectionalStreams();
+ if (config_.HasReceivedMaxBidirectionalStreams()) {
+ max_streams = config_.ReceivedMaxBidirectionalStreams();
}
QUIC_DVLOG(1) << ENDPOINT << "Setting max_open_outgoing_streams_ to "
<< max_streams;
@@ -1088,9 +1087,9 @@
if (VersionHasIetfQuicFrames(transport_version())) {
v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
- config_.GetMaxIncomingBidirectionalStreamsToSend());
+ config_.GetMaxBidirectionalStreamsToSend());
v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
- config_.GetMaxIncomingUnidirectionalStreamsToSend());
+ config_.GetMaxUnidirectionalStreamsToSend());
} else {
// A small number of additional incoming streams beyond the limit should be
// allowed. This helps avoid early connection termination when FIN/RSTs for
@@ -1098,7 +1097,7 @@
// Use a minimum number of additional streams, or a percentage increase,
// whichever is larger.
uint32_t max_incoming_streams_to_send =
- config_.GetMaxIncomingBidirectionalStreamsToSend();
+ config_.GetMaxBidirectionalStreamsToSend();
uint32_t max_incoming_streams =
std::max(max_incoming_streams_to_send + kMaxStreamsMinimumIncrement,
static_cast<uint32_t>(max_incoming_streams_to_send *
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index f10b548..9a252c9 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -479,8 +479,8 @@
// Set the number of unidirectional stream that the peer is allowed to open to
// be |max_stream| + |num_expected_static_streams_|.
- void ConfigureMaxIncomingDynamicStreamsToSend(QuicStreamCount max_stream) {
- config_.SetMaxIncomingUnidirectionalStreamsToSend(
+ void ConfigureMaxDynamicStreamsToSend(QuicStreamCount max_stream) {
+ config_.SetMaxUnidirectionalStreamsToSend(
max_stream + num_expected_unidirectional_static_streams_);
}
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 935ef0b..f4323f9 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -353,9 +353,9 @@
kInitialSessionFlowControlWindowForTest);
if (configure_session) {
- QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
+ QuicConfigPeer::SetReceivedMaxBidirectionalStreams(
session_.config(), kDefaultMaxStreamsPerConnection);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(
session_.config(), kDefaultMaxStreamsPerConnection);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
session_.config(), kMinimumFlowControlSendWindow);
@@ -2858,8 +2858,7 @@
.WillRepeatedly(Invoke(&session_, &TestSession::SaveFrame));
// Set configuration data so that when the config happens, the stream limit is
// not increased and another STREAMS-BLOCKED will be needed..
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(session_.config(),
- 0);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 0);
session_.OnConfigNegotiated();
@@ -2893,8 +2892,7 @@
// Set configuration data so that when the config happens, the stream limit is
// increased.
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(session_.config(),
- 10);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 10);
// STREAMS_BLOCKED frame should not be sent because streams can now be
// created.
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index ebb0f2c..31fd411 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -99,8 +99,7 @@
session_->config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
session_->config(), kMinimumFlowControlSendWindow);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- session_->config(), 10);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_->config(), 10);
session_->OnConfigNegotiated();
stream_ = new StrictMock<TestStream>(kTestStreamId, session_.get(),
