Land Recent QUIC Changes.

net/quic/congestion_control/tcp_cubic_sender_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 <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/congestion_control/tcp_receiver.h"
@@ skipping 17 matching lines @@
                      QuicTcpCongestionWindow max_tcp_congestion_window)
       : TcpCubicSender(clock, reno, max_tcp_congestion_window) {
   }
 
   QuicTcpCongestionWindow congestion_window() {
     return congestion_window_;
   }
 
   using TcpCubicSender::AvailableSendWindow;
   using TcpCubicSender::SendWindow;
-  using TcpCubicSender::AckAccounting;
 };
 
 class TcpCubicSenderTest : public ::testing::Test {
  protected:
   TcpCubicSenderTest()
-      : rtt_(QuicTime::Delta::FromMilliseconds(60)),
-        one_ms_(QuicTime::Delta::FromMilliseconds(1)),
+      : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
         sender_(new TcpCubicSenderPeer(&clock_, true,
                                        kDefaultMaxCongestionWindowTCP)),
         receiver_(new TcpReceiver()),
         sequence_number_(1),
         acked_sequence_number_(0) {
   }
 
   void SendAvailableSendWindow() {
     QuicByteCount bytes_to_send = sender_->AvailableSendWindow();
     while (bytes_to_send > 0) {
       QuicByteCount bytes_in_packet = min(kDefaultTCPMSS, bytes_to_send);
       sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
                             NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
       bytes_to_send -= bytes_in_packet;
       if (bytes_to_send > 0) {
         EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
                         HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
       }
     }
   }
   // Normal is that TCP acks every other segment.
   void AckNPackets(int n) {
     for (int i = 0; i < n; ++i) {
       acked_sequence_number_++;
-      sender_->OnPacketAcked(acked_sequence_number_, kDefaultTCPMSS, rtt_);
+      sender_->UpdateRtt(QuicTime::Delta::FromMilliseconds(60));
+      sender_->OnPacketAcked(acked_sequence_number_, kDefaultTCPMSS);
     }
     clock_.AdvanceTime(one_ms_);  // 1 millisecond.
   }
 
-  const QuicTime::Delta rtt_;
   const QuicTime::Delta one_ms_;
   MockClock clock_;
   SendAlgorithmInterface::SentPacketsMap not_used_;
   scoped_ptr<TcpCubicSenderPeer> sender_;
   scoped_ptr<TcpReceiver> receiver_;
   QuicPacketSequenceNumber sequence_number_;
   QuicPacketSequenceNumber acked_sequence_number_;
 };
 
 TEST_F(TcpCubicSenderTest, SimpleSender) {
@@ skipping 65 matching lines @@
 
   for (int n = 0; n < kNumberOfAck; ++n) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   QuicByteCount expected_send_window =
       kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAck);
   EXPECT_EQ(expected_send_window, sender_->SendWindow());
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+
   // We should now have fallen out of slow start.
-  SendAvailableSendWindow();
-  AckNPackets(2);
-  expected_send_window += kDefaultTCPMSS;
-  EXPECT_EQ(expected_send_window, sender_->SendWindow());
-
   // Testing Reno phase.
   // We should need 141(65*2+1+10) ACK:ed packets before increasing window by
   // one.
   for (int m = 0; m < 70; ++m) {
     SendAvailableSendWindow();
     AckNPackets(2);
     EXPECT_EQ(expected_send_window, sender_->SendWindow());
   }
   SendAvailableSendWindow();
   AckNPackets(2);
@@ skipping 77 matching lines @@
   // packets are retransmitted.
   sender_->OnRetransmissionTimeout(false);
   EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
 }
 
 TEST_F(TcpCubicSenderTest, RetransmissionDelay) {
   const int64 kRttMs = 10;
   const int64 kDeviationMs = 3;
   EXPECT_EQ(QuicTime::Delta::Zero(), sender_->RetransmissionDelay());
 
-  sender_->AckAccounting(QuicTime::Delta::FromMilliseconds(kRttMs));
+  sender_->UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs));
 
   // Initial value is to set the median deviation to half of the initial
   // rtt, the median in then multiplied by a factor of 4 and finally the
   // smoothed rtt is added which is the initial rtt.
   QuicTime::Delta expected_delay =
       QuicTime::Delta::FromMilliseconds(kRttMs + kRttMs / 2 * 4);
   EXPECT_EQ(expected_delay, sender_->RetransmissionDelay());
 
   for (int i = 0; i < 100; ++i) {
     // Run to make sure that we converge.
-    sender_->AckAccounting(
+    sender_->UpdateRtt(
         QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs));
-    sender_->AckAccounting(
+    sender_->UpdateRtt(
         QuicTime::Delta::FromMilliseconds(kRttMs - kDeviationMs));
   }
   expected_delay = QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs * 4);
 
   EXPECT_NEAR(kRttMs, sender_->SmoothedRtt().ToMilliseconds(), 1);
   EXPECT_NEAR(expected_delay.ToMilliseconds(),
               sender_->RetransmissionDelay().ToMilliseconds(),
               1);
   EXPECT_EQ(static_cast<int64>(
                 sender_->GetCongestionWindow() * kNumMicrosPerSecond /
@@ skipping 136 matching lines @@
   config.set_server_initial_congestion_window(2 * congestion_window,
                                        2 * congestion_window);
   EXPECT_EQ(2 * congestion_window, config.server_initial_congestion_window());
 
   sender_->SetFromConfig(config, true);
   EXPECT_EQ(2 * congestion_window, sender_->congestion_window());
 }
 
 }  // namespace test
 }  // namespace net