Landing Recent QUIC changes until 01/26/2016 18:14 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/containers/hash_tables.h"
 #include "base/rand_util.h"
@@ skipping 117 matching lines @@
 
   TestStream* CreateOutgoingDynamicStream(SpdyPriority priority) override {
     TestStream* stream = new TestStream(GetNextOutgoingStreamId(), this);
     stream->SetPriority(priority);
     ActivateStream(stream);
     return stream;
   }
 
   TestStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     // Enforce the limit on the number of open streams.
-    if (GetNumOpenIncomingStreams() + 1 > get_max_open_streams()) {
+    if (GetNumOpenIncomingStreams() + 1 > max_open_incoming_streams()) {
       connection()->SendConnectionCloseWithDetails(QUIC_TOO_MANY_OPEN_STREAMS,
                                                    "Too many streams!");
       return nullptr;
     } else {
       return new TestStream(id, this);
     }
   }
 
   bool IsClosedStream(QuicStreamId id) {
     return QuicSession::IsClosedStream(id);
   }
 
   ReliableQuicStream* GetOrCreateDynamicStream(QuicStreamId stream_id) {
     return QuicSpdySession::GetOrCreateDynamicStream(stream_id);
   }
 
   QuicConsumedData WritevData(
       QuicStreamId id,
       QuicIOVector data,
       QuicStreamOffset offset,
       bool fin,
       FecProtection fec_protection,
       QuicAckListenerInterface* ack_notifier_delegate) override {
     QuicConsumedData consumed(data.total_length, fin);
     if (!writev_consumes_all_data_) {
       consumed = QuicSession::WritevData(id, data, offset, fin, fec_protection,
                                          ack_notifier_delegate);
     }
-    QuicSessionPeer::GetWriteBlockedStreams(this)
-        ->UpdateBytesForStream(id, consumed.bytes_consumed);
+    QuicSessionPeer::GetWriteBlockedStreams(this)->UpdateBytesForStream(
+        id, consumed.bytes_consumed);
     return consumed;
   }
 
   void set_writev_consumes_all_data(bool val) {
     writev_consumes_all_data_ = val;
   }
 
   QuicConsumedData SendStreamData(QuicStreamId id) {
     struct iovec iov;
     return WritevData(id, MakeIOVector("not empty", &iov), 0, true,
@@ skipping 155 matching lines @@
   CloseStream(stream3->id());
   CheckClosedStreams();
 }
 
 TEST_P(QuicSessionTestServer, MaximumAvailableOpenedStreams) {
   QuicStreamId stream_id = kClientDataStreamId1;
   session_.GetOrCreateDynamicStream(stream_id);
   EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(_, _)).Times(0);
   EXPECT_NE(nullptr,
             session_.GetOrCreateDynamicStream(
-                stream_id + 2 * (session_.get_max_open_streams() - 1)));
+                stream_id + 2 * (session_.max_open_incoming_streams() - 1)));
 }
 
 TEST_P(QuicSessionTestServer, TooManyAvailableStreams) {
   QuicStreamId stream_id1 = kClientDataStreamId1;
   QuicStreamId stream_id2;
   EXPECT_NE(nullptr, session_.GetOrCreateDynamicStream(stream_id1));
   // A stream ID which is too large to create.
-  stream_id2 = stream_id1 + 2 * session_.get_max_available_streams() + 4;
+  stream_id2 = stream_id1 + 2 * session_.MaxAvailableStreams() + 4;
   EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
                                 QUIC_TOO_MANY_AVAILABLE_STREAMS, _));
   EXPECT_EQ(nullptr, session_.GetOrCreateDynamicStream(stream_id2));
 }
 
 TEST_P(QuicSessionTestServer, ManyAvailableStreams) {
   // 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);
+  QuicSessionPeer::SetMaxOpenIncomingStreams(&session_, 200);
   QuicStreamId stream_id = kClientDataStreamId1;
   // Create one stream.
   session_.GetOrCreateDynamicStream(stream_id);
   EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(_, _)).Times(0);
   // Create the largest stream ID of a threatened total of 200 streams.
   session_.GetOrCreateDynamicStream(stream_id + 2 * (200 - 1));
 }
 
 TEST_P(QuicSessionTestServer, DebugDFatalIfMarkingClosedStreamWriteBlocked) {
   TestStream* stream2 = session_.CreateOutgoingDynamicStream(kDefaultPriority);
@@ skipping 159 matching lines @@
       .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor(
           &session_, &TestSession::SendStreamData, stream4->id()))));
   EXPECT_CALL(*stream6, OnCanWrite())
       .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor(
           &session_, &TestSession::SendStreamData, stream6->id()))));
 
   // Expect that we only send one packet, the writes from different streams
   // should be bundled together.
   MockPacketWriter* writer = static_cast<MockPacketWriter*>(
       QuicConnectionPeer::GetWriter(session_.connection()));
-  EXPECT_CALL(*writer, WritePacket(_, _, _, _))
+  EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _));
   session_.OnCanWrite();
   EXPECT_FALSE(session_.WillingAndAbleToWrite());
 }
 
 TEST_P(QuicSessionTestServer, OnCanWriteCongestionControlBlocks) {
   InSequence s;
 
   // Drive congestion control manually.
@@ skipping 124 matching lines @@
   QuicSpdySessionPeer::SetHeadersStream(&session_, headers_stream);
   EXPECT_CALL(*headers_stream, OnCanWrite());
 
   session_.OnCanWrite();
   EXPECT_FALSE(session_.WillingAndAbleToWrite());
 }
 
 TEST_P(QuicSessionTestServer, SendGoAway) {
   MockPacketWriter* writer = static_cast<MockPacketWriter*>(
       QuicConnectionPeer::GetWriter(session_.connection()));
-  EXPECT_CALL(*writer, WritePacket(_, _, _, _))
+  EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   EXPECT_CALL(*connection_, SendGoAway(_, _, _))
       .WillOnce(Invoke(connection_, &MockConnection::ReallySendGoAway));
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.goaway_sent());
 
   const QuicStreamId kTestStreamId = 5u;
   EXPECT_CALL(*connection_,
               SendRstStream(kTestStreamId, QUIC_STREAM_PEER_GOING_AWAY, 0))
       .Times(0);
@@ skipping 374 matching lines @@
   EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
 }
 
 TEST_P(QuicSessionTestServer, TooManyUnfinishedStreamsCauseServerRejectStream) {
   // If a buggy/malicious peer creates too many streams that are not ended
   // with a FIN or RST then we send a connection close or an RST to
   // refuse streams.
   const QuicStreamId kMaxStreams = 5;
-  QuicSessionPeer::SetMaxOpenStreams(&session_, kMaxStreams);
+  QuicSessionPeer::SetMaxOpenIncomingStreams(&session_, kMaxStreams);
   const QuicStreamId kFirstStreamId = kClientDataStreamId1;
   const QuicStreamId kFinalStreamId = kClientDataStreamId1 + 2 * kMaxStreams;
 
   // Create kMaxStreams data streams, and close them all without receiving a
   // FIN or a RST_STREAM from the client.
   for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId; i += 2) {
     QuicStreamFrame data1(i, false, 0, StringPiece("HT"));
     session_.OnStreamFrame(data1);
     // EXPECT_EQ(1u, session_.GetNumOpenStreams());
     EXPECT_CALL(*connection_, SendRstStream(i, _, _));
@@ skipping 24 matching lines @@
   // protocol point of view).
   if (GetParam() <= QUIC_VERSION_27) {
     EXPECT_CALL(*connection_,
                 SendConnectionCloseWithDetails(QUIC_TOO_MANY_OPEN_STREAMS, _))
         .Times(0);
   } else {
     EXPECT_CALL(*connection_, SendRstStream(_, QUIC_REFUSED_STREAM, _))
         .Times(0);
   }
   const QuicStreamId kMaxStreams = 5;
-  QuicSessionPeer::SetMaxOpenStreams(&session_, kMaxStreams);
+  QuicSessionPeer::SetMaxOpenIncomingStreams(&session_, kMaxStreams);
 
   // Create kMaxStreams + 1 data streams, and mark them draining.
   const QuicStreamId kFirstStreamId = kClientDataStreamId1;
   const QuicStreamId kFinalStreamId =
       kClientDataStreamId1 + 2 * kMaxStreams + 1;
   for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId; i += 2) {
     QuicStreamFrame data1(i, true, 0, StringPiece("HT"));
     session_.OnStreamFrame(data1);
     EXPECT_EQ(1u, session_.GetNumOpenIncomingStreams());
     session_.StreamDraining(i);
     EXPECT_EQ(0u, session_.GetNumOpenIncomingStreams());
   }
 
   // Called after any new data is received by the session, and triggers the call
   // to close the connection.
   session_.PostProcessAfterData();
 }
 
+TEST_P(QuicSessionTestServer, TestMaxIncomingAndOutgoingStreamsAllowed) {
+  // Tests that on server side, the value of max_open_incoming/outgoing streams
+  // are setup correctly during negotiation.
+  // When FLAGS_quic_different_max_num_open_streams is off, both of them are a
+  // little larger than negotiated values. When flag is true, the value for
+  // outgoing stream is limited to negotiated value and for incoming stream it
+  // is set to be larger than that.
+  session_.OnConfigNegotiated();
+  if (FLAGS_quic_different_max_num_open_streams) {
+    // The max number of open outgoing streams is less than that of incoming
+    // streams, and it should be same as negotiated value.
+    EXPECT_LT(session_.max_open_outgoing_streams(),
+              session_.max_open_incoming_streams());
+    EXPECT_EQ(session_.max_open_outgoing_streams(),
+              kDefaultMaxStreamsPerConnection);
+  } else {
+    // The max number of outgoing/incoming streams are the same.
+    EXPECT_EQ(session_.max_open_outgoing_streams(),
+              session_.max_open_incoming_streams());
+  }
+
+  EXPECT_GT(session_.max_open_incoming_streams(),
+            kDefaultMaxStreamsPerConnection);
+}
+
 class QuicSessionTestClient : public QuicSessionTestBase {
  protected:
   QuicSessionTestClient() : QuicSessionTestBase(Perspective::IS_CLIENT) {}
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicSessionTestClient,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSessionTestClient, AvailableStreamsClient) {
@@ skipping 28 matching lines @@
   EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream));
 
   // Allow the session to delete the stream object.
   session_.PostProcessAfterData();
   EXPECT_TRUE(connection_->connected());
   EXPECT_TRUE(QuicSessionPeer::IsStreamClosed(&session_, stream_id));
   EXPECT_EQ(nullptr, QuicSessionPeer::dynamic_streams(&session_)[stream_id]);
 
   // The stream is not waiting for the arrival of the peer's final offset as it
   // was received with the FIN earlier.
-  EXPECT_EQ(0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(&session_)
-                    .size());
+  EXPECT_EQ(
+      0u,
+      QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(&session_).size());
+}
+
+TEST_P(QuicSessionTestClient, TestMaxIncomingAndOutgoingStreamsAllowed) {
+  // Tests that on client side, the value of max_open_incoming/outgoing streams
+  // are setup correctly during negotiation.
+  // When FLAGS_quic_different_max_num_open_streams is off, both of them are
+  // same as negotiated value. When flag is true, the value for outgoing stream
+  // is limited to negotiated value and for incoming stream it is set to be
+  // larger than that.
+  session_.OnConfigNegotiated();
+  if (FLAGS_quic_different_max_num_open_streams) {
+    EXPECT_LT(session_.max_open_outgoing_streams(),
+              session_.max_open_incoming_streams());
+  } else {
+    EXPECT_EQ(session_.max_open_outgoing_streams(),
+              session_.max_open_incoming_streams());
+  }
+
+  EXPECT_EQ(session_.max_open_outgoing_streams(),
+            kDefaultMaxStreamsPerConnection);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net