Land Recent QUIC changes.

net/quic/congestion_control/quic_congestion_control_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.
 
 // Test of the full congestion control chain.
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/quic_congestion_manager.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 31 matching lines @@
 
 TEST_F(QuicCongestionControlTest, FixedRateSenderAPI) {
   SetUpCongestionType(kFixRate);
   QuicCongestionFeedbackFrame congestion_feedback;
   congestion_feedback.type = kFixRate;
   congestion_feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(30);
   manager_->OnIncomingQuicCongestionFeedbackFrame(congestion_feedback,
                                                   clock_.Now());
   EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
-  manager_->SentPacket(1, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
+  manager_->SentPacket(1, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION,
+                       HAS_RETRANSMITTABLE_DATA);
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(40),
             manager_->TimeUntilSend(clock_.Now(),
                 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(35));
   EXPECT_EQ(QuicTime::Delta::Infinite(),
             manager_->TimeUntilSend(clock_.Now(),
                 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
   EXPECT_EQ(QuicTime::Delta::Infinite(),
             manager_->TimeUntilSend(clock_.Now(),
                 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 }
 
 TEST_F(QuicCongestionControlTest, FixedRatePacing) {
   SetUpCongestionType(kFixRate);
   QuicAckFrame ack;
   ack.received_info.largest_observed = 0;
   manager_->OnIncomingAckFrame(ack, clock_.Now());
 
   QuicCongestionFeedbackFrame feedback;
   feedback.type = kFixRate;
   feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(100);
   manager_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
 
   QuicTime acc_advance_time(QuicTime::Zero());
   for (QuicPacketSequenceNumber i = 1; i <= 100; ++i) {
     EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
-    manager_->SentPacket(i, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
+    manager_->SentPacket(i, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION,
+                         HAS_RETRANSMITTABLE_DATA);
     QuicTime::Delta advance_time = manager_->TimeUntilSend(clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     clock_.AdvanceTime(advance_time);
     acc_advance_time = acc_advance_time.Add(advance_time);
     // Ack the packet we sent.
     ack.received_info.largest_observed = max(
         i, ack.received_info.largest_observed);
     manager_->OnIncomingAckFrame(ack, clock_.Now());
   }
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1200),
             acc_advance_time.Subtract(start_));
 }
 
 TEST_F(QuicCongestionControlTest, Pacing) {
   SetUpCongestionType(kFixRate);
   QuicAckFrame ack;
   ack.received_info.largest_observed = 0;
   manager_->OnIncomingAckFrame(ack, clock_.Now());
 
   QuicCongestionFeedbackFrame feedback;
   feedback.type = kFixRate;
   // Test a high bitrate (8Mbit/s) to trigger pacing.
   feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(1000);
   manager_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
 
   QuicTime acc_advance_time(QuicTime::Zero());
   for (QuicPacketSequenceNumber i = 1; i <= 100;) {
     EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
-    manager_->SentPacket(i++, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
+    manager_->SentPacket(i++, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION,
+                         HAS_RETRANSMITTABLE_DATA);
     EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
-    manager_->SentPacket(i++, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
+    manager_->SentPacket(i++, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION,
+                         HAS_RETRANSMITTABLE_DATA);
     QuicTime::Delta advance_time = manager_->TimeUntilSend(clock_.Now(),
         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     clock_.AdvanceTime(advance_time);
     acc_advance_time = acc_advance_time.Add(advance_time);
     // Ack the packets we sent.
     ack.received_info.largest_observed = max(
         i - 2, ack.received_info.largest_observed);
     manager_->OnIncomingAckFrame(ack, clock_.Now());
     ack.received_info.largest_observed = max(
         i - 1, ack.received_info.largest_observed);
     manager_->OnIncomingAckFrame(ack, clock_.Now());
   }
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(120),
             acc_advance_time.Subtract(start_));
 }
 
 // TODO(pwestin): add TCP tests.
 
 // TODO(pwestin): add InterArrival tests.
 
 }  // namespace test
 }  // namespace net