Land Recent QUIC Changes.

net/quic/congestion_control/inter_arrival_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/inter_arrival_sender.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::pair;
 
 namespace net {
 namespace test {
 
 class InterArrivalSenderTest : public ::testing::Test {
  protected:
   InterArrivalSenderTest()
-     : rtt_(QuicTime::Delta::FromMilliseconds(60)),
-       one_ms_(QuicTime::Delta::FromMilliseconds(1)),
+     : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
        one_s_(QuicTime::Delta::FromMilliseconds(1000)),
        nine_ms_(QuicTime::Delta::FromMilliseconds(9)),
        send_start_time_(send_clock_.Now()),
        sender_(&send_clock_),
        sequence_number_(1),
        acked_sequence_number_(1),
        feedback_sequence_number_(1) {
     send_clock_.AdvanceTime(one_ms_);
     receive_clock_.AdvanceTime(one_ms_);
   }
@@ skipping 14 matching lines @@
                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
       sequence_number_++;
     }
     EXPECT_FALSE(sender_.TimeUntilSend(send_clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
 
   void AckNPackets(int n) {
     for (int i = 0; i < n; ++i) {
       sender_.OnPacketAcked(
-          acked_sequence_number_++, kDefaultMaxPacketSize, rtt_);
+          acked_sequence_number_++, kDefaultMaxPacketSize);
     }
   }
 
   void SendDelaySpikeFeedbackMessage(QuicTime::Delta spike_time) {
     QuicCongestionFeedbackFrame feedback;
     feedback.type = kInterArrival;
     feedback.inter_arrival.accumulated_number_of_lost_packets = 0;
     receive_clock_.AdvanceTime(spike_time);
     QuicTime receive_time = receive_clock_.ApproximateNow();
     feedback.inter_arrival.received_packet_times.insert(
@@ skipping 31 matching lines @@
       feedback_sequence_number_++;
     }
     sender_.OnIncomingQuicCongestionFeedbackFrame(feedback, send_clock_.Now(),
                                                   sent_packets_);
   }
 
   QuicTime::Delta SenderDeltaSinceStart() {
     return send_clock_.ApproximateNow().Subtract(send_start_time_);
   }
 
-  const QuicTime::Delta rtt_;
   const QuicTime::Delta one_ms_;
   const QuicTime::Delta one_s_;
   const QuicTime::Delta nine_ms_;
   MockClock send_clock_;
   MockClock receive_clock_;
   const QuicTime send_start_time_;
   InterArrivalSender sender_;
   QuicPacketSequenceNumber sequence_number_;
   QuicPacketSequenceNumber acked_sequence_number_;
   QuicPacketSequenceNumber feedback_sequence_number_;
@@ skipping 377 matching lines @@
   // our minimum bitrate.
   SendFeedbackMessageNPackets(10, one_s_, one_s_);
   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 }
 
 TEST_F(InterArrivalSenderTest, MinBitrateDueToLoss) {
+  sender_.UpdateRtt(QuicTime::Delta::FromMilliseconds(60));
   QuicBandwidth expected_min_bitrate = QuicBandwidth::FromKBitsPerSecond(10);
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // Send 5 bursts.
   for (int i = 0; i < 4; ++i) {
     SendAvailableCongestionWindow();
     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
@@ skipping 17 matching lines @@
               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 
   for (int i = 0; i < 15; ++i) {
     SendAvailableCongestionWindow();
     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     sender_.OnPacketLost(acked_sequence_number_ - 1, send_clock_.Now());
-    sender_.OnPacketAcked(acked_sequence_number_, kDefaultMaxPacketSize, rtt_);
+    sender_.OnPacketAcked(acked_sequence_number_, kDefaultMaxPacketSize);
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
     SendFeedbackMessageNPackets(2, nine_ms_, nine_ms_);
   }
   // Test that our exponentail back off stop at expected_min_bitrate.
   EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     sender_.OnPacketLost(acked_sequence_number_ - 1, send_clock_.Now());
-    sender_.OnPacketAcked(acked_sequence_number_, kDefaultMaxPacketSize, rtt_);
+    sender_.OnPacketAcked(acked_sequence_number_, kDefaultMaxPacketSize);
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
     SendFeedbackMessageNPackets(2, nine_ms_, nine_ms_);
 
     // Make sure our bitrate is fixed at the expected_min_bitrate.
     EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
   }
 }
 
 }  // namespace test
 }  // namespace net