relnote: Close QUIC connections due to too many open streams earlier in

net/quic/quic_session_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 "net/quic/quic_session.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 116 matching lines @@
 
   TestCryptoStream* GetCryptoStream() override { return &crypto_stream_; }
 
   TestStream* CreateOutgoingDynamicStream() override {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
 
   TestStream* CreateIncomingDynamicStream(QuicStreamId id) override {
-    return new TestStream(id, this);
+    // Enforce the limit on the number of open streams.
+    if (GetNumOpenStreams() + 1 > get_max_open_streams()) {
+      connection()->SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS);
+      return nullptr;
+    } else {
+      return new TestStream(id, this);
+    }
   }
 
   bool IsClosedStream(QuicStreamId id) {
     return QuicSession::IsClosedStream(id);
   }
 
   ReliableQuicStream* GetIncomingDynamicStream(QuicStreamId stream_id) {
     return QuicSpdySession::GetIncomingDynamicStream(stream_id);
   }
 
@@ skipping 157 matching lines @@
   CloseStream(stream_id2);
   // Create a stream explicitly, and another implicitly.
   ReliableQuicStream* stream3 =
       session_.GetIncomingDynamicStream(stream_id2 + 4);
   CheckClosedStreams();
   // Close one, but make sure the other is still not closed
   CloseStream(stream3->id());
   CheckClosedStreams();
 }
 
-TEST_P(QuicSessionTestServer, StreamIdTooLarge) {
+TEST_P(QuicSessionTestServer, MaximumImplicitlyOpenedStreams) {
   QuicStreamId stream_id = kClientDataStreamId1;
   session_.GetIncomingDynamicStream(stream_id);
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
-  session_.GetIncomingDynamicStream(stream_id + kMaxStreamIdDelta + 2);
+  EXPECT_CALL(*connection_, SendConnectionClose(_)).Times(0);
+  EXPECT_NE(nullptr,
+            session_.GetIncomingDynamicStream(
+                stream_id + 2 * (session_.get_max_open_streams() - 1)));
+}
+
+TEST_P(QuicSessionTestServer, TooManyImplicitlyOpenedStreams) {
+  QuicStreamId stream_id1 = kClientDataStreamId1;
+  // A stream ID which is too large to create.
+  const QuicStreamId kMaxStreamIdDelta = 200;
+  QuicStreamId stream_id2 =
+      FLAGS_exact_stream_id_delta
+          ? stream_id1 + 2 * session_.get_max_open_streams()
+          : stream_id1 + kMaxStreamIdDelta + 2;
+  EXPECT_NE(nullptr, session_.GetIncomingDynamicStream(stream_id1));
+  EXPECT_CALL(*connection_, SendConnectionClose(FLAGS_exact_stream_id_delta
+                                                    ? QUIC_TOO_MANY_OPEN_STREAMS
+                                                    : QUIC_INVALID_STREAM_ID));
+  EXPECT_EQ(nullptr, session_.GetIncomingDynamicStream(stream_id2));
+}
+
+TEST_P(QuicSessionTestServer, ManyImplicitlyOpenedStreams) {
+  // When max_open_streams_ is 200, should be able to create 200 streams
+  // out-of-order, that is, creating the one with the largest stream ID first.
+  QuicSessionPeer::SetMaxOpenStreams(&session_, 200);
+  QuicStreamId stream_id = kClientDataStreamId1;
+  // Create one stream.
+  session_.GetIncomingDynamicStream(stream_id);
+  EXPECT_CALL(*connection_, SendConnectionClose(_))
+      .Times(FLAGS_exact_stream_id_delta ? 0 : 1);
+  // Create the largest stream ID of a threatened total of 200 streams.
+  session_.GetIncomingDynamicStream(stream_id + 2 * (200 - 1));
 }
 
 TEST_P(QuicSessionTestServer, DebugDFatalIfMarkingClosedStreamWriteBlocked) {
   TestStream* stream2 = session_.CreateOutgoingDynamicStream();
   QuicStreamId kClosedStreamId = stream2->id();
   // Close the stream.
   EXPECT_CALL(*connection_, SendRstStream(kClosedStreamId, _, _));
   stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
   EXPECT_DEBUG_DFATAL(session_.MarkConnectionLevelWriteBlocked(
                           kClosedStreamId, kSomeMiddlePriority),
@@ skipping 260 matching lines @@
   // should trigger a connection close. However there is no need to send
   // multiple connection close frames.
 
   // Create valid stream.
   QuicStreamFrame data1(kClientDataStreamId1, false, 0, StringPiece("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_EQ(1u, session_.GetNumOpenStreams());
 
   // Process first invalid stream reset, resulting in the connection being
   // closed.
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID))
+  EXPECT_CALL(*connection_, SendConnectionClose(FLAGS_exact_stream_id_delta
+                                                    ? QUIC_TOO_MANY_OPEN_STREAMS
+                                                    : QUIC_INVALID_STREAM_ID))
       .Times(1);
   const QuicStreamId kLargeInvalidStreamId = 99999999;
   QuicRstStreamFrame rst1(kLargeInvalidStreamId, QUIC_STREAM_NO_ERROR, 0);
   session_.OnRstStream(rst1);
   QuicConnectionPeer::CloseConnection(connection_);
 
   // Processing of second invalid stream reset should not result in the
   // connection being closed for a second time.
   QuicRstStreamFrame rst2(kLargeInvalidStreamId, QUIC_STREAM_NO_ERROR, 0);
   session_.OnRstStream(rst2);
@@ skipping 387 matching lines @@
   EXPECT_TRUE(QuicSessionPeer::IsStreamImplicitlyCreated(&session_, 4));
   ASSERT_TRUE(session_.GetIncomingDynamicStream(2) != nullptr);
   ASSERT_TRUE(session_.GetIncomingDynamicStream(4) != nullptr);
   // And 5 should be not implicitly created.
   EXPECT_FALSE(QuicSessionPeer::IsStreamImplicitlyCreated(&session_, 5));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net