Land Recent QUIC Changes.

net/tools/quic/quic_server_session_test.cc

 // Copyright 2013 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 "net/tools/quic/quic_server_session.h"
 
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/source_address_token.h"
 #include "net/quic/quic_connection.h"
@@ skipping 51 matching lines @@
 namespace {
 
 const size_t kMaxStreamsForTest = 10;
 
 class QuicServerSessionTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicServerSessionTest()
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance()) {
     config_.SetDefaults();
-    config_.set_max_streams_per_connection(kMaxStreamsForTest,
-                                           kMaxStreamsForTest);
+    config_.SetMaxStreamsPerConnection(kMaxStreamsForTest,
+                                       kMaxStreamsForTest);
     config_.SetInitialFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
 
     connection_ =
         new StrictMock<MockConnection>(true, SupportedVersions(GetParam()));
     session_.reset(new QuicServerSession(config_, connection_, &owner_));
@@ skipping 107 matching lines @@
   EXPECT_EQ(1u, session_->GetNumOpenStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionTest, MaxOpenStreams) {
   ValueRestore<bool> old_flag(&FLAGS_quic_allow_more_open_streams, true);
   // Test that the server closes the connection if a client attempts to open too
   // many data streams. The server accepts slightly more than the negotiated
   // stream limit to deal with rare cases where a client FIN/RST is lost.
 
-  // The slightly increased stream limit is set during config negotiation.
+  // The slightly increased stream limit is set during config negotiation. It
+  // should be either an increase of 10 over negotiated limit, or a fixed
+  // percentage scaling, whichever is larger. Test both before continuing.
   EXPECT_EQ(kMaxStreamsForTest, session_->get_max_open_streams());
   session_->OnConfigNegotiated();
-  EXPECT_EQ(kMaxStreamsMultiplier * kMaxStreamsForTest,
+  EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest,
+            kMaxStreamsForTest + kMaxStreamsMinimumIncrement);
+  EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement,
             session_->get_max_open_streams());
-
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
   QuicStreamId stream_id = kClientDataStreamId1;
   // Open the max configured number of streams, should be no problem.
   for (size_t i = 0; i < kMaxStreamsForTest; ++i) {
     EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
                                                              stream_id));
     stream_id += 2;
   }
 
-  // Open one more stream: server should accept slightly more than the
-  // configured limit.
-  EXPECT_TRUE(
-      QuicServerSessionPeer::GetIncomingDataStream(session_.get(), stream_id));
+  // Open more streams: server should accept slightly more than the limit.
+  for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) {
+    EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                             stream_id));
+    stream_id += 2;
+  }
 
   // Now violate the server's internal stream limit.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
   stream_id += 2;
   EXPECT_FALSE(
       QuicServerSessionPeer::GetIncomingDataStream(session_.get(), stream_id));
 }
 
 TEST_P(QuicServerSessionTest, MaxOpenStreamsImplicit) {
   ValueRestore<bool> old_flag(&FLAGS_quic_allow_more_open_streams, true);
   // Test that the server closes the connection if a client attempts to open too
   // many data streams implicitly.  The server accepts slightly more than the
   // negotiated stream limit to deal with rare cases where a client FIN/RST is
   // lost.
 
   // The slightly increased stream limit is set during config negotiation.
   EXPECT_EQ(kMaxStreamsForTest, session_->get_max_open_streams());
   session_->OnConfigNegotiated();
-  EXPECT_EQ(kMaxStreamsMultiplier * kMaxStreamsForTest,
+  EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest,
+            kMaxStreamsForTest + kMaxStreamsMinimumIncrement);
+  EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement,
             session_->get_max_open_streams());
 
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
   EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
       session_.get(), kClientDataStreamId1));
   // Implicitly open streams up to the server's limit.
-  const int kActualMaxStreams = kMaxStreamsMultiplier * kMaxStreamsForTest;
+  const int kActualMaxStreams =
+      kMaxStreamsForTest + kMaxStreamsMinimumIncrement;
   const int kMaxValidStreamId =
       kClientDataStreamId1 + (kActualMaxStreams - 1) * 2;
   EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
       session_.get(), kMaxValidStreamId));
 
   // Opening a further stream will result in connection close.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
   EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDataStream(
       session_.get(), kMaxValidStreamId + 2));
 }
@@ skipping 103 matching lines @@
   EXPECT_CALL(*crypto_stream,
               SendServerConfigUpdate(EqualsProto(expected_network_params)))
       .Times(1);
   session_->OnCongestionWindowChange(now);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net