Landing Recent QUIC changes until 9/2/2015 17:00 UTC.

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"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_crypto_stream.h"
-#include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/reliable_quic_stream.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_data_stream_peer.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 296 matching lines @@
   session_.GetIncomingDynamicStream(stream_id);
   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;
+  QuicStreamId stream_id2 = stream_id1 + 2 * session_.get_max_open_streams();
   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_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
   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);
+  EXPECT_CALL(*connection_, SendConnectionClose(_)).Times(0);
   // 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 closed_stream_id = stream2->id();
   // Close the stream.
   EXPECT_CALL(*connection_, SendRstStream(closed_stream_id, _, _));
   stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
@@ skipping 258 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(FLAGS_exact_stream_id_delta
-                                                    ? QUIC_TOO_MANY_OPEN_STREAMS
-                                                    : QUIC_INVALID_STREAM_ID))
+  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS))
       .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