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));
   }