Landing 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 43 matching lines @@
     return s->GetDataStream(id);
   }
   static void SetCryptoStream(QuicServerSession* s,
                               QuicCryptoServerStream* crypto_stream) {
     s->crypto_stream_.reset(crypto_stream);
   }
 };
 
 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(3, 3);
+    config_.set_max_streams_per_connection(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 101 matching lines @@
   frames.push_back(
       QuicStreamFrame(kClientDataStreamId1, false, 2, MakeIOVector("TP")));
   frames.push_back(
       QuicStreamFrame(kClientDataStreamId2, false, 2, MakeIOVector("TP")));
   visitor_->OnStreamFrames(frames);
   // The stream should never be opened, now that the reset is received.
   EXPECT_EQ(1u, session_->GetNumOpenStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
-TEST_P(QuicServerSessionTest, MaxNumConnections) {
+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.
+  EXPECT_EQ(kMaxStreamsForTest, session_->get_max_open_streams());
+  session_->OnConfigNegotiated();
+  EXPECT_EQ(kMaxStreamsMultiplier * kMaxStreamsForTest,
+            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));
+
+  // 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,
+            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 kMaxValidStreamId =
+      kClientDataStreamId1 + (kActualMaxStreams - 1) * 2;
   EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
-      session_.get(), kClientDataStreamId2));
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
-      session_.get(), kClientDataStreamId3));
+      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(), kClientDataStreamId4));
-}
-
-TEST_P(QuicServerSessionTest, MaxNumConnectionsImplicit) {
-  EXPECT_EQ(0u, session_->GetNumOpenStreams());
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(
-      session_.get(), kClientDataStreamId1));
-  // Implicitly opens two more streams.
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
-  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDataStream(
-      session_.get(), kClientDataStreamId4));
+      session_.get(), kMaxValidStreamId + 2));
 }
 
 TEST_P(QuicServerSessionTest, GetEvenIncomingError) {
   // Incoming streams on the server session must be odd.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   EXPECT_EQ(NULL,
             QuicServerSessionPeer::GetIncomingDataStream(session_.get(), 4));
 }
 
 TEST_P(QuicServerSessionTest, SetFecProtectionFromConfig) {
@@ skipping 92 matching lines @@
   EXPECT_CALL(*crypto_stream,
               SendServerConfigUpdate(EqualsProto(expected_network_params)))
       .Times(1);
   session_->OnCongestionWindowChange(now);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net