Land recent QUIC changes.

net/quic/congestion_control/tcp_cubic_sender_test.cc

Index: net/quic/congestion_control/tcp_cubic_sender_test.cc
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 5e3edc42096bc1c40a27bc71db23ffe1c9d8078c..fc9a2d7fe75ff6ef2d7a56859f6e26a20d531d96 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -29,6 +29,7 @@ class TcpCubicSenderTest : public ::testing::Test {
   TcpCubicSenderTest()
      : rtt_(QuicTime::Delta::FromMilliseconds(60)),
        one_ms_(QuicTime::Delta::FromMilliseconds(1)),
+       fake_bandwidth_(QuicBandwidth::Zero()),
        sender_(new TcpCubicSenderPeer(&clock_, true)),
        receiver_(new TcpReceiver()),
        sequence_number_(1),
@@ -38,10 +39,11 @@ class TcpCubicSenderTest : public ::testing::Test {
     QuicByteCount bytes_to_send = sender_->AvailableCongestionWindow();
     while (bytes_to_send > 0) {
       QuicByteCount bytes_in_packet = std::min(kMaxPacketSize, bytes_to_send);
-      sender_->SentPacket(sequence_number_++, bytes_in_packet, false);
+      sender_->SentPacket(clock_.Now(), sequence_number_++, bytes_in_packet,
+                          false);
       bytes_to_send -= bytes_in_packet;
       if (bytes_to_send > 0) {
-        EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+        EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
       }
     }
   }
@@ -56,6 +58,7 @@ class TcpCubicSenderTest : public ::testing::Test {
 
   const QuicTime::Delta rtt_;
   const QuicTime::Delta one_ms_;
+  const QuicBandwidth fake_bandwidth_;
   MockClock clock_;
   SendAlgorithmInterface::SentPacketsMap not_used_;
   scoped_ptr<TcpCubicSenderPeer> sender_;
@@ -70,29 +73,31 @@ TEST_F(TcpCubicSenderTest, SimpleSender) {
   EXPECT_EQ(kDefaultWindowTCP,
             sender_->AvailableCongestionWindow());
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
-  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, not_used_);
+  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
+                                                 fake_bandwidth_, not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
   // And that window is un-affected.
   EXPECT_EQ(kDefaultWindowTCP, sender_->AvailableCongestionWindow());
 
   // A retransmitt should always retun 0.
-  EXPECT_TRUE(sender_->TimeUntilSend(true).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), true).IsZero());
 }
 
 TEST_F(TcpCubicSenderTest, ExponentialSlowStart) {
   const int kNumberOfAck = 20;
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
-  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, not_used_);
+  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
+                                                 fake_bandwidth_, not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
 
   for (int n = 0; n < kNumberOfAck; ++n) {
     // Send our full congestion window.
@@ -113,12 +118,13 @@ TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
   const int kNumberOfAck = 65;
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
-  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, not_used_);
+  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
+                                                 fake_bandwidth_, not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
 
   for (int n = 0; n < kNumberOfAck; ++n) {
     // Send our full congestion window.
@@ -153,12 +159,13 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   const int kNumberOfAck = 10;
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
-  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, not_used_);
+  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
+                                                 fake_bandwidth_, not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsZero());
 
   for (int i = 0; i < kNumberOfAck; ++i) {
     // Send our full congestion window.
@@ -170,10 +177,10 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
       (kMaxPacketSize * 2 * kNumberOfAck);
   EXPECT_EQ(expected_congestion_window, sender_->CongestionWindow());
 
-  sender_->OnIncomingLoss(1);
+  sender_->OnIncomingLoss(clock_.Now());
 
   // Make sure that we should not send right now.
-  EXPECT_TRUE(sender_->TimeUntilSend(false).IsInfinite());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), false).IsInfinite());
 
   // We should now have fallen out of slow start.
   // We expect window to be cut in half.