Land Recent QUIC changes.

net/quic/quic_connection_helper_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_connection_helper.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/quic_decrypter.h"
@@ skipping 107 matching lines @@
     runner_ = new TestTaskRunner(&clock_);
     helper_ = new QuicConnectionHelper(runner_.get(), &clock_,
                                        &random_generator_, socket_.get());
     send_algorithm_ = new testing::StrictMock<MockSendAlgorithm>();
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
         WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(
         testing::Return(QuicBandwidth::FromKBitsPerSecond(100)));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(
         testing::Return(QuicTime::Delta::FromMilliseconds(100)));
+    ON_CALL(*send_algorithm_, SentPacket(_, _, _, _, _))
+        .WillByDefault(testing::Return(true));
     connection_.reset(new TestConnection(guid_, IPEndPoint(), helper_));
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
   }
 
   // Returns a newly created packet to send kData on stream 1.
   QuicEncryptedPacket* ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number) {
     InitializeHeader(sequence_number);
 
@@ skipping 170 matching lines @@
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2));
   Initialize();
 
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
       testing::Return(QuicTime::Delta::Zero()));
 
   QuicTime::Delta kDefaultRetransmissionTime =
       QuicTime::Delta::FromMilliseconds(500);
   QuicTime start = clock_.ApproximateNow();
 
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION, _));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(1, _));
 
   // Send a packet.
-  connection_->SendStreamData(1, kData, 0, false);
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, IS_RETRANSMISSION));
+  struct iovec iov = {const_cast<char*>(kData),
+                      static_cast<size_t>(strlen(kData))};
+  connection_->SendvStreamData(1, &iov, 1, 0, false);
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, IS_RETRANSMISSION, _));
   // Since no ack was received, the retransmission alarm will fire and
   // retransmit it.
   runner_->RunNextTask();
 
   EXPECT_EQ(kDefaultRetransmissionTime,
             clock_.ApproximateNow().Subtract(start));
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicConnectionHelperTest, TestMultipleRetransmission) {
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(3));
   Initialize();
 
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
       testing::Return(QuicTime::Delta::Zero()));
 
   QuicTime::Delta kDefaultRetransmissionTime =
       QuicTime::Delta::FromMilliseconds(500);
   QuicTime start = clock_.ApproximateNow();
 
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION, _));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(1, _));
+
   // Send a packet.
-  connection_->SendStreamData(1, kData, 0, false);
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, IS_RETRANSMISSION));
+  struct iovec iov = {const_cast<char*>(kData),
+                      static_cast<size_t>(strlen(kData))};
+  connection_->SendvStreamData(1, &iov, 1, 0, false);
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, IS_RETRANSMISSION, _));
   // Since no ack was received, the retransmission alarm will fire and
   // retransmit it.
   runner_->RunNextTask();
 
   EXPECT_EQ(kDefaultRetransmissionTime,
             clock_.ApproximateNow().Subtract(start));
 
   // Since no ack was received, the retransmission alarm will fire and
   // retransmit it.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 3, _, IS_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 3, _, IS_RETRANSMISSION, _));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(2, _));
   runner_->RunNextTask();
 
   EXPECT_EQ(kDefaultRetransmissionTime.Add(kDefaultRetransmissionTime),
             clock_.ApproximateNow().Subtract(start));
 
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicConnectionHelperTest, InitialTimeout) {
   AddWrite(SYNCHRONOUS, ConstructClosePacket(1, 0));
   Initialize();
 
   // Verify that a single task was posted.
   ASSERT_EQ(1u, runner_->GetPostedTasks().size());
   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultInitialTimeoutSecs),
             runner_->GetPostedTasks().front().delay);
 
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION, _));
   // After we run the next task, we should close the connection.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
 
   runner_->RunNextTask();
   EXPECT_EQ(QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(
                 kDefaultInitialTimeoutSecs)),
             clock_.ApproximateNow());
   EXPECT_FALSE(connection_->connected());
   EXPECT_TRUE(AtEof());
 }
@@ skipping 26 matching lines @@
   AddWrite(SYNCHRONOUS, ConstructClosePacket(2, 1));
   Initialize();
 
   EXPECT_TRUE(connection_->connected());
   QuicTime start = clock_.ApproximateNow();
 
   // When we send a packet, the timeout will change to 5000 +
   // kDefaultInitialTimeoutSecs.
   clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(5000));
   EXPECT_EQ(5000u, clock_.ApproximateNow().Subtract(start).ToMicroseconds());
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_,
+              SentPacket(_, 1, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
 
   // Send an ack so we don't set the retransmission alarm.
   connection_->SendAck();
 
   // The original alarm will fire.  We should not time out because we had a
   // network event at t=5000.  The alarm will reregister.
   runner_->RunNextTask();
 
   EXPECT_EQ(QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(
                 kDefaultInitialTimeoutSecs)),
             clock_.ApproximateNow());
   EXPECT_TRUE(connection_->connected());
 
   // This time, we should time out.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_,
+              SentPacket(_, 2, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
   runner_->RunNextTask();
   EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000 + 5000,
             clock_.ApproximateNow().Subtract(
                 QuicTime::Zero()).ToMicroseconds());
   EXPECT_FALSE(connection_->connected());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicConnectionHelperTest, SendSchedulerDelayThenSend) {
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1));
   Initialize();
 
   // Test that if we send a packet with a delay, it ends up queued.
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
       testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(
       *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
           testing::Return(QuicTime::Delta::FromMicroseconds(1)));
 
   QuicPacket* packet = ConstructRawDataPacket(1);
-  connection_->SendOrQueuePacket(
-      ENCRYPTION_NONE, 1, packet, 0, HAS_RETRANSMITTABLE_DATA);
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  connection_->SendOrQueuePacket(ENCRYPTION_NONE, 1, packet, 0,
+                                 HAS_RETRANSMITTABLE_DATA);
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION,
+                                           _));
   EXPECT_EQ(1u, connection_->NumQueuedPackets());
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
   EXPECT_CALL(*send_algorithm_,
               TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
       testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
   runner_->RunNextTask();
   EXPECT_EQ(0u, connection_->NumQueuedPackets());
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 }  // namespace net