Add a new kMIDS (Max Incoming Dynamic Streams) config option, to eventually replace kMSPC.

net/tools/quic/end_to_end_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <sys/epoll.h>
 
 #include <list>
 #include <memory>
 #include <string>
@@ skipping 1163 matching lines @@
     client_->client()->WaitForEvents();
   }
 }
 
 TEST_P(EndToEndTest, NegotiateMaxOpenStreams) {
   // Negotiate 1 max open stream.
   client_config_.SetMaxStreamsPerConnection(1, 1);
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
+  if (negotiated_version_ > QUIC_VERSION_34) {
+    // Newer versions use max incoming dynamic streams.
+    return;
+  }
+
   // Make the client misbehave after negotiation.
   const int kServerMaxStreams = kMaxStreamsMinimumIncrement + 1;
   QuicSessionPeer::SetMaxOpenOutgoingStreams(client_->client()->session(),
                                              kServerMaxStreams + 1);
 
   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
   request.AddHeader("content-length", "3");
   request.set_has_complete_message(false);
 
   // The server supports a small number of additional streams beyond the
   // negotiated limit. Open enough streams to go beyond that limit.
   for (int i = 0; i < kServerMaxStreams + 1; ++i) {
     client_->SendMessage(request);
   }
   client_->WaitForResponse();
 
   if (negotiated_version_ <= QUIC_VERSION_27) {
     EXPECT_FALSE(client_->connected());
     EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
     EXPECT_EQ(QUIC_TOO_MANY_OPEN_STREAMS, client_->connection_error());
   } else {
     EXPECT_TRUE(client_->connected());
     EXPECT_EQ(QUIC_REFUSED_STREAM, client_->stream_error());
     EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
   }
 }
 
+TEST_P(EndToEndTest, MaxIncomingDynamicStreamsLimitRespected) {
+  // Set a limit on maximum number of incoming dynamic streams.
+  // Make sure the limit is respected.
+  const uint32_t kServerMaxIncomingDynamicStreams = 1;
+  server_config_.SetMaxIncomingDynamicStreamsToSend(
+      kServerMaxIncomingDynamicStreams);
+  ASSERT_TRUE(Initialize());
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+
+  if (negotiated_version_ <= QUIC_VERSION_34) {
+    // Earlier versions negotiated max open streams.
+    return;
+  }
+
+  // Make the client misbehave after negotiation.
+  const int kServerMaxStreams =
+      kMaxStreamsMinimumIncrement + kServerMaxIncomingDynamicStreams;
+  QuicSessionPeer::SetMaxOpenOutgoingStreams(client_->client()->session(),
+                                             kServerMaxStreams + 1);
+
+  HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
+  request.AddHeader("content-length", "3");
+  request.set_has_complete_message(false);
+
+  // The server supports a small number of additional streams beyond the
+  // negotiated limit. Open enough streams to go beyond that limit.
+  for (int i = 0; i < kServerMaxStreams + 1; ++i) {
+    client_->SendMessage(request);
+  }
+  client_->WaitForResponse();
+
+  EXPECT_TRUE(client_->connected());
+  EXPECT_EQ(QUIC_REFUSED_STREAM, client_->stream_error());
+  EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
+}
+
+TEST_P(EndToEndTest, SetIndependentMaxIncomingDynamicStreamsLimits) {
+  // Each endpoint can set max incoming dynamic streams independently.
+  const uint32_t kClientMaxIncomingDynamicStreams = 2;
+  const uint32_t kServerMaxIncomingDynamicStreams = 1;
+  client_config_.SetMaxIncomingDynamicStreamsToSend(
+      kClientMaxIncomingDynamicStreams);
+  server_config_.SetMaxIncomingDynamicStreamsToSend(
+      kServerMaxIncomingDynamicStreams);
+  ASSERT_TRUE(Initialize());
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+
+  if (negotiated_version_ <= QUIC_VERSION_34) {
+    // Earlier versions negotiated max open streams.
+    return;
+  }
+
+  // The client has received the server's limit and vice versa.
+  EXPECT_EQ(kServerMaxIncomingDynamicStreams,
+            client_->client()->session()->max_open_outgoing_streams());
+  server_thread_->Pause();
+  QuicDispatcher* dispatcher =
+      QuicServerPeer::GetDispatcher(server_thread_->server());
+  QuicSession* server_session = dispatcher->session_map().begin()->second;
+  EXPECT_EQ(kClientMaxIncomingDynamicStreams,
+            server_session->max_open_outgoing_streams());
+  server_thread_->Resume();
+}
+
 TEST_P(EndToEndTest, NegotiateCongestionControl) {
   ValueRestore<bool> old_flag(&FLAGS_quic_allow_bbr, true);
   // Disable this flag because if connection uses multipath sent packet manager,
   // static_cast here does not work.
   FLAGS_quic_enable_multipath = false;
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   CongestionControlType expected_congestion_control_type = kReno;
   switch (GetParam().congestion_control_tag) {
@@ skipping 18 matching lines @@
 }
 
 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
   // Server limits the number of max streams to 2.
   server_config_.SetMaxStreamsPerConnection(2, 2);
   // Client tries to negotiate for 10.
   client_config_.SetMaxStreamsPerConnection(10, 5);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
+  if (negotiated_version_ > QUIC_VERSION_34) {
+    // No negotiated max streams beyond version 34.
+    return;
+  }
   QuicConfig* client_negotiated_config = client_->client()->session()->config();
   EXPECT_EQ(2u, client_negotiated_config->MaxStreamsPerConnection());
 }
 
 TEST_P(EndToEndTest, ClientSuggestsRTT) {
   // Client suggests initial RTT, verify it is used.
   const uint32_t kInitialRTT = 20000;
   client_config_.SetInitialRoundTripTimeUsToSend(kInitialRTT);
 
   ASSERT_TRUE(Initialize());
@@ skipping 1123 matching lines @@
   EXPECT_EQ(trailers, client_->response_trailers());
 }
 
 class EndToEndTestServerPush : public EndToEndTest {
  protected:
   const size_t kNumMaxStreams = 10;
 
   EndToEndTestServerPush() : EndToEndTest() {
     FLAGS_quic_supports_push_promise = true;
     client_config_.SetMaxStreamsPerConnection(kNumMaxStreams, kNumMaxStreams);
+    client_config_.SetMaxIncomingDynamicStreamsToSend(kNumMaxStreams);
+    server_config_.SetMaxStreamsPerConnection(kNumMaxStreams, kNumMaxStreams);
+    server_config_.SetMaxIncomingDynamicStreamsToSend(kNumMaxStreams);
     support_server_push_ = true;
   }
 
   // Add a request with its response and |num_resources| push resources into
   // cache.
   // If |resource_size| == 0, response body of push resources use default string
   // concatenating with resource url. Otherwise, generate a string of
   // |resource_size| as body.
   void AddRequestAndResponseWithServerPush(string host,
                                            string path,
@@ skipping 337 matching lines @@
   client_->WaitForResponse();
   // TODO(fayang): Fix this test to work with stateless rejects.
   if (!BothSidesSupportStatelessRejects()) {
     VerifyCleanConnection(true);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net