Landing Recent QUIC changes until 2016-03-15 16:26 UTC

net/quic/congestion_control/pacing_sender_test.cc

 // Copyright (c) 2013 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/congestion_control/pacing_sender.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/mock_clock.h"
@@ skipping 33 matching lines @@
         mock_sender_, QuicTime::Delta::FromMilliseconds(1), burst_size));
     EXPECT_CALL(*mock_sender_, PacingRate()).WillRepeatedly(Return(bandwidth));
   }
 
   void CheckPacketIsSentImmediately(HasRetransmittableData retransmittable_data,
                                     QuicByteCount bytes_in_flight,
                                     bool in_recovery) {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     for (int i = 0; i < 2; ++i) {
-      EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), bytes_in_flight,
-                                               retransmittable_data))
+      EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), bytes_in_flight))
           .WillOnce(Return(zero_time_));
       // Verify that the packet can be sent immediately.
       EXPECT_EQ(zero_time_,
-                pacing_sender_->TimeUntilSend(clock_.Now(), bytes_in_flight,
-                                              retransmittable_data));
+                pacing_sender_->TimeUntilSend(clock_.Now(), bytes_in_flight));
     }
 
     // Actually send the packet.
     if (bytes_in_flight == 0) {
       EXPECT_CALL(*mock_sender_, InRecovery()).WillOnce(Return(in_recovery));
     }
     EXPECT_CALL(*mock_sender_,
                 OnPacketSent(clock_.Now(), bytes_in_flight, packet_number_,
                              kMaxPacketSize, retransmittable_data));
     pacing_sender_->OnPacketSent(clock_.Now(), bytes_in_flight,
                                  packet_number_++, kMaxPacketSize,
                                  retransmittable_data);
   }
 
   void CheckPacketIsSentImmediately() {
     CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA, kBytesInFlight,
                                  false);
   }
 
-  void CheckAckIsSentImmediately() {
-    CheckPacketIsSentImmediately(NO_RETRANSMITTABLE_DATA, kBytesInFlight,
-                                 false);
-  }
-
   void CheckPacketIsDelayed(QuicTime::Delta delay) {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     for (int i = 0; i < 2; ++i) {
-      EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kBytesInFlight,
-                                               HAS_RETRANSMITTABLE_DATA))
+      EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kBytesInFlight))
           .WillOnce(Return(zero_time_));
       // Verify that the packet is delayed.
       EXPECT_EQ(delay.ToMicroseconds(),
-                pacing_sender_
-                    ->TimeUntilSend(clock_.Now(), kBytesInFlight,
-                                    HAS_RETRANSMITTABLE_DATA)
+                pacing_sender_->TimeUntilSend(clock_.Now(), kBytesInFlight)
                     .ToMicroseconds());
     }
   }
 
   void UpdateRtt() {
     EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
     SendAlgorithmInterface::CongestionVector empty_map;
     pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map,
                                       empty_map);
   }
 
   const QuicTime::Delta zero_time_;
   const QuicTime::Delta infinite_time_;
   MockClock clock_;
   QuicPacketNumber packet_number_;
   StrictMock<MockSendAlgorithm>* mock_sender_;
   scoped_ptr<PacingSender> pacing_sender_;
 };
 
 TEST_F(PacingSenderTest, NoSend) {
   for (int i = 0; i < 2; ++i) {
-    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kBytesInFlight,
-                                             HAS_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kBytesInFlight))
         .WillOnce(Return(infinite_time_));
     EXPECT_EQ(infinite_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(), kBytesInFlight,
-                                            HAS_RETRANSMITTABLE_DATA));
+              pacing_sender_->TimeUntilSend(clock_.Now(), kBytesInFlight));
   }
 }
 
 TEST_F(PacingSenderTest, SendNow) {
   for (int i = 0; i < 2; ++i) {
-    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kBytesInFlight,
-                                             HAS_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kBytesInFlight))
         .WillOnce(Return(zero_time_));
     EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(), kBytesInFlight,
-                                            HAS_RETRANSMITTABLE_DATA));
+              pacing_sender_->TimeUntilSend(clock_.Now(), kBytesInFlight));
   }
 }
 
 TEST_F(PacingSenderTest, VariousSending) {
   // Configure pacing rate of 1 packet per 1 ms, no initial burst.
   InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
                         kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   // Now update the RTT and verify that packets are actually paced.
   UpdateRtt();
 
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
 
   // The first packet was a "make up", then we sent two packets "into the
   // future", so the delay should be 2.
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 
   // Wake up on time.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
-  CheckAckIsSentImmediately();
 
   // Wake up late.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(4));
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 
   // Wake up really late.
@@ skipping 185 matching lines @@
   EXPECT_CALL(*mock_sender_, PacingRate()).WillOnce(Return(kBandwidth));
   pacing_sender_->OnPacketSent(kTime, kBytes, 123u, kBytes,
                                HAS_RETRANSMITTABLE_DATA);
 
   EXPECT_CALL(*mock_sender_, OnRetransmissionTimeout(true));
   pacing_sender_->OnRetransmissionTimeout(true);
 
   EXPECT_CALL(*mock_sender_, OnConnectionMigration());
   pacing_sender_->OnConnectionMigration();
 
-  EXPECT_CALL(*mock_sender_,
-              TimeUntilSend(kTime, kBytes, HAS_RETRANSMITTABLE_DATA))
+  EXPECT_CALL(*mock_sender_, TimeUntilSend(kTime, kBytes))
       .WillOnce(Return(kTimeDelta));
-  pacing_sender_->TimeUntilSend(kTime, kBytes, HAS_RETRANSMITTABLE_DATA);
+  pacing_sender_->TimeUntilSend(kTime, kBytes);
 
   EXPECT_CALL(*mock_sender_, PacingRate()).WillOnce(Return(kBandwidth));
   EXPECT_EQ(kBandwidth, pacing_sender_->PacingRate());
 
   EXPECT_CALL(*mock_sender_, BandwidthEstimate()).WillOnce(Return(kBandwidth));
   EXPECT_EQ(kBandwidth, pacing_sender_->BandwidthEstimate());
 
   EXPECT_CALL(*mock_sender_, RetransmissionDelay())
       .WillOnce(Return(kTimeDelta));
   EXPECT_EQ(kTimeDelta, pacing_sender_->RetransmissionDelay());
@@ skipping 10 matching lines @@
   EXPECT_CALL(*mock_sender_, GetSlowStartThreshold()).WillOnce(Return(kBytes));
   EXPECT_EQ(kBytes, pacing_sender_->GetSlowStartThreshold());
 
   EXPECT_CALL(*mock_sender_, GetCongestionControlType())
       .WillOnce(Return(kReno));
   EXPECT_EQ(kReno, pacing_sender_->GetCongestionControlType());
 }
 
 }  // namespace test
 }  // namespace net