Landing Recent QUIC changes until 5/14/2016 02:25:25 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/rand_util.h"
 #include "base/stl_util.h"
@@ skipping 134 matching lines @@
 
   bool IsClosedStream(QuicStreamId id) {
     return QuicSession::IsClosedStream(id);
   }
 
   ReliableQuicStream* GetOrCreateDynamicStream(QuicStreamId stream_id) {
     return QuicSpdySession::GetOrCreateDynamicStream(stream_id);
   }
 
   QuicConsumedData WritevData(
+      ReliableQuicStream* stream,
       QuicStreamId id,
       QuicIOVector data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckListenerInterface* ack_notifier_delegate) override {
     QuicConsumedData consumed(data.total_length, fin);
     if (!writev_consumes_all_data_) {
-      consumed =
-          QuicSession::WritevData(id, data, offset, fin, ack_notifier_delegate);
+      consumed = QuicSession::WritevData(stream, id, data, offset, fin,
+                                         ack_notifier_delegate);
     }
     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) {
+  QuicConsumedData SendStreamData(ReliableQuicStream* stream) {
     struct iovec iov;
-    return WritevData(id, MakeIOVector("not empty", &iov), 0, true, nullptr);
+    return WritevData(stream, stream->id(), MakeIOVector("not empty", &iov), 0,
+                      true, nullptr);
   }
 
-  QuicConsumedData SendLargeFakeData(QuicStreamId id, int bytes) {
+  QuicConsumedData SendLargeFakeData(ReliableQuicStream* stream, int bytes) {
     DCHECK(writev_consumes_all_data_);
     struct iovec iov;
     iov.iov_base = nullptr;  // should not be read.
     iov.iov_len = static_cast<size_t>(bytes);
-    return WritevData(id, QuicIOVector(&iov, 1, bytes), 0, true, nullptr);
+    return WritevData(stream, stream->id(), QuicIOVector(&iov, 1, bytes), 0,
+                      true, nullptr);
   }
 
   using QuicSession::PostProcessAfterData;
 
  private:
   StrictMock<TestCryptoStream> crypto_stream_;
 
   bool writev_consumes_all_data_;
 };
 
@@ skipping 217 matching lines @@
   StreamBlocker stream2_blocker(&session_, stream2->id());
   StreamBlocker stream4_blocker(&session_, stream4->id());
   StreamBlocker stream6_blocker(&session_, stream6->id());
   // With two sessions blocked, we should get two write calls.  They should both
   // go to the first stream as it will only write 6k and mark itself blocked
   // again.
   InSequence s;
   EXPECT_CALL(*stream2, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_),
-                          stream2->id(), 6000))),
+                          base::Unretained(&session_), stream2, 6000))),
                       Invoke(&stream2_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   EXPECT_CALL(*stream2, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_),
-                          stream2->id(), 6000))),
+                          base::Unretained(&session_), stream2, 6000))),
                       Invoke(&stream2_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   session_.OnCanWrite();
 
   // We should get one more call for stream2, at which point it has used its
   // write quota and we move over to stream 4.
   EXPECT_CALL(*stream2, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_),
-                          stream2->id(), 6000))),
+                          base::Unretained(&session_), stream2, 6000))),
                       Invoke(&stream2_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   EXPECT_CALL(*stream4, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_),
-                          stream4->id(), 6000))),
+                          base::Unretained(&session_), stream4, 6000))),
                       Invoke(&stream4_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   session_.OnCanWrite();
 
   // Now let stream 4 do the 2nd of its 3 writes, but add a block for a high
   // priority stream 6.  4 should be preempted.  6 will write but *not* block so
   // will cede back to 4.
   stream6->SetPriority(kHighestPriority);
   EXPECT_CALL(*stream4, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_), stream4->id(), 6000))),
+                          base::Unretained(&session_), stream4, 6000))),
                       Invoke(&stream4_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked),
                       Invoke(&stream6_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   EXPECT_CALL(*stream6, OnCanWrite())
-      .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor(
-          &TestSession::SendLargeFakeData,
-          base::Unretained(&session_), stream4->id(), 6000))));
+      .WillOnce(testing::IgnoreResult(
+          Invoke(CreateFunctor(&TestSession::SendLargeFakeData,
+                               base::Unretained(&session_), stream4, 6000))));
   session_.OnCanWrite();
 
   // Stream4 alread did 6k worth of writes, so after doing another 12k it should
   // cede and 2 should resume.
   EXPECT_CALL(*stream4, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_),
-                          stream4->id(), 12000))),
+                          base::Unretained(&session_), stream4, 12000))),
                       Invoke(&stream4_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   EXPECT_CALL(*stream2, OnCanWrite())
       .WillOnce(DoAll(testing::IgnoreResult(Invoke(CreateFunctor(
                           &TestSession::SendLargeFakeData,
-                          base::Unretained(&session_),
-                          stream2->id(), 6000))),
+                          base::Unretained(&session_), stream2, 6000))),
                       Invoke(&stream2_blocker,
                              &StreamBlocker::MarkConnectionLevelWriteBlocked)));
   session_.OnCanWrite();
 }
 
 TEST_P(QuicSessionTestServer, OnCanWriteBundlesStreams) {
   // Encryption needs to be established before data can be sent.
   CryptoHandshakeMessage msg;
   session_.GetCryptoStream()->OnHandshakeMessage(msg);
 
   // Drive congestion control manually.
   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
   QuicConnectionPeer::SetSendAlgorithm(session_.connection(), send_algorithm);
 
   TestStream* stream2 = session_.CreateOutgoingDynamicStream(kDefaultPriority);
   TestStream* stream4 = session_.CreateOutgoingDynamicStream(kDefaultPriority);
   TestStream* stream6 = session_.CreateOutgoingDynamicStream(kDefaultPriority);
 
   session_.MarkConnectionLevelWriteBlocked(stream2->id());
   session_.MarkConnectionLevelWriteBlocked(stream6->id());
   session_.MarkConnectionLevelWriteBlocked(stream4->id());
 
   EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _))
       .WillRepeatedly(Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm, GetCongestionWindow())
       .WillRepeatedly(Return(kMaxPacketSize * 10));
   EXPECT_CALL(*stream2, OnCanWrite())
-      .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor(
-          &TestSession::SendStreamData,
-          base::Unretained(&session_), stream2->id()))));
+      .WillOnce(testing::IgnoreResult(
+          Invoke(CreateFunctor(&TestSession::SendStreamData,
+                               base::Unretained(&session_), stream2))));
   EXPECT_CALL(*stream4, OnCanWrite())
-      .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor(
-          &TestSession::SendStreamData,
-          base::Unretained(&session_),
-          stream4->id()))));
+      .WillOnce(testing::IgnoreResult(
+          Invoke(CreateFunctor(&TestSession::SendStreamData,
+                               base::Unretained(&session_), stream4))));
   EXPECT_CALL(*stream6, OnCanWrite())
-      .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor(
-          &TestSession::SendStreamData,
-          base::Unretained(&session_),
-          stream6->id()))));
+      .WillOnce(testing::IgnoreResult(
+          Invoke(CreateFunctor(&TestSession::SendStreamData,
+                               base::Unretained(&session_), stream6))));
 
   // 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(_, _, _, _, _))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _));
   session_.OnCanWrite();
   EXPECT_FALSE(session_.WillingAndAbleToWrite());
@@ skipping 646 matching lines @@
   session_.OnConfigNegotiated();
   EXPECT_LT(session_.max_open_outgoing_streams(),
             session_.max_open_incoming_streams());
   EXPECT_EQ(session_.max_open_outgoing_streams(),
             kDefaultMaxStreamsPerConnection);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net