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(),
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index 11a0249..35b41bc 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -38,9 +38,9 @@
const uint32_t max_streams =
(std::numeric_limits<uint32_t>::max() / kMaxAvailableStreamsMultiplier) -
1;
- this->config()->SetMaxIncomingBidirectionalStreamsToSend(max_streams);
+ this->config()->SetMaxBidirectionalStreamsToSend(max_streams);
if (VersionHasIetfQuicFrames(transport_version())) {
- ConfigureMaxIncomingDynamicStreamsToSend(max_streams);
+ ConfigureMaxDynamicStreamsToSend(max_streams);
}
}
diff --git a/quic/quartc/quartc_factory.cc b/quic/quartc/quartc_factory.cc
index 35a069a..f5815ea 100644
--- a/quic/quartc/quartc_factory.cc
+++ b/quic/quartc/quartc_factory.cc
@@ -168,7 +168,7 @@
// incomplete streams, but targets 1 second for recovery. Increasing the
// number of open streams gives sufficient headroom to recover before QUIC
// refuses new streams.
- quic_config.SetMaxIncomingBidirectionalStreamsToSend(1000);
+ quic_config.SetMaxBidirectionalStreamsToSend(1000);
return quic_config;
}
diff --git a/quic/test_tools/quic_config_peer.cc b/quic/test_tools/quic_config_peer.cc
index 6278817..481a148 100644
--- a/quic/test_tools/quic_config_peer.cc
+++ b/quic/test_tools/quic_config_peer.cc
@@ -69,16 +69,14 @@
}
// static
-void QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
- QuicConfig* config,
- uint32_t max_streams) {
- config->max_incoming_bidirectional_streams_.SetReceivedValue(max_streams);
+void QuicConfigPeer::SetReceivedMaxBidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams) {
+ config->max_bidirectional_streams_.SetReceivedValue(max_streams);
}
// static
-void QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- QuicConfig* config,
- uint32_t max_streams) {
- config->max_incoming_unidirectional_streams_.SetReceivedValue(max_streams);
+void QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams) {
+ config->max_unidirectional_streams_.SetReceivedValue(max_streams);
}
// static
diff --git a/quic/test_tools/quic_config_peer.h b/quic/test_tools/quic_config_peer.h
index e68d87d..f9d3b1e 100644
--- a/quic/test_tools/quic_config_peer.h
+++ b/quic/test_tools/quic_config_peer.h
@@ -45,10 +45,10 @@
static void SetReceivedDisableConnectionMigration(QuicConfig* config);
- static void SetReceivedMaxIncomingBidirectionalStreams(QuicConfig* config,
- uint32_t max_streams);
- static void SetReceivedMaxIncomingUnidirectionalStreams(QuicConfig* config,
- uint32_t max_streams);
+ static void SetReceivedMaxBidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams);
+ static void SetReceivedMaxUnidirectionalStreams(QuicConfig* config,
+ uint32_t max_streams);
static void SetConnectionOptionsToSend(QuicConfig* config,
const QuicTagVector& options);
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index edef5dd..f86f2b5 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1110,7 +1110,7 @@
kInitialStreamFlowControlWindowForTest);
config.SetInitialSessionFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
- QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
+ QuicConfigPeer::SetReceivedMaxBidirectionalStreams(
&config, kDefaultMaxStreamsPerConnection);
// Default enable NSTP.
// This is unnecessary for versions > 44
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 96cb3ac..4e3a50c 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -194,10 +194,10 @@
KeyExchangeSource::Default()),
compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
- config_.SetMaxIncomingBidirectionalStreamsToSend(kMaxStreamsForTest);
- QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
- &config_, kMaxStreamsForTest);
- config_.SetMaxIncomingUnidirectionalStreamsToSend(kMaxStreamsForTest);
+ config_.SetMaxBidirectionalStreamsToSend(kMaxStreamsForTest);
+ QuicConfigPeer::SetReceivedMaxBidirectionalStreams(&config_,
+ kMaxStreamsForTest);
+ config_.SetMaxUnidirectionalStreamsToSend(kMaxStreamsForTest);
config_.SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
@@ -210,11 +210,11 @@
config_.SetInitialSessionFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
if (VersionUsesHttp3(GetParam().transport_version)) {
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(
&config_, kMaxStreamsForTest + 3);
} else {
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- &config_, kMaxStreamsForTest);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(&config_,
+ kMaxStreamsForTest);
}
ParsedQuicVersionVector supported_versions = SupportedVersions(GetParam());
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index fccf6f8..6c842fc 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -219,8 +219,7 @@
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
session_.config(), kMinimumFlowControlSendWindow);
- QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
- session_.config(), 10);
+ QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 10);
session_.OnConfigNegotiated();
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
}
