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/rtt_stats.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/congestion_control/tcp_receiver.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::min;
 
 namespace net {
 namespace test {
 
 const uint32 kDefaultWindowTCP = 10 * kDefaultTCPMSS;
 
 // TODO(ianswett): Remove 10000 once b/10075719 is fixed.
 const QuicTcpCongestionWindow kDefaultMaxCongestionWindowTCP = 10000;
 
 class TcpCubicSenderPeer : public TcpCubicSender {
  public:
   TcpCubicSenderPeer(const QuicClock* clock,
                      bool reno,
                      QuicTcpCongestionWindow max_tcp_congestion_window)
-      : TcpCubicSender(clock, reno, max_tcp_congestion_window, &stats_) {
+      : TcpCubicSender(
+            clock, &rtt_stats_, reno, max_tcp_congestion_window, &stats_) {
   }
 
   QuicTcpCongestionWindow congestion_window() {
     return congestion_window_;
   }
 
+  RttStats rtt_stats_;
   QuicConnectionStats stats_;
 
   using TcpCubicSender::AvailableSendWindow;
   using TcpCubicSender::SendWindow;
 };
 
 class TcpCubicSenderTest : public ::testing::Test {
  protected:
   TcpCubicSenderTest()
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
@@ skipping 14 matching lines @@
       sender_->OnPacketSent(clock_.Now(), sequence_number_++, kDefaultTCPMSS,
                             NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
       ++packets_sent;
       can_send = sender_->TimeUntilSend(
           clock_.Now(), NOT_RETRANSMISSION,
           HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero();
     }
     return packets_sent;
   }
 
+  void UpdateRtt(QuicTime::Delta rtt) {
+    sender_->rtt_stats_.UpdateRtt(rtt, QuicTime::Delta::Zero());
+    sender_->UpdateRtt(rtt);
+  }
+
   // Normal is that TCP acks every other segment.
   void AckNPackets(int n) {
     for (int i = 0; i < n; ++i) {
       ++acked_sequence_number_;
-      sender_->UpdateRtt(QuicTime::Delta::FromMilliseconds(60));
+      UpdateRtt(QuicTime::Delta::FromMilliseconds(60));
       sender_->OnPacketAcked(acked_sequence_number_, kDefaultTCPMSS);
     }
     clock_.AdvanceTime(one_ms_);  // 1 millisecond.
   }
 
   void LoseNPackets(int n) {
     for (int i = 0; i < n; ++i) {
       ++acked_sequence_number_;
       sender_->OnPacketAbandoned(acked_sequence_number_, kDefaultTCPMSS);
       sender_->OnPacketLost(acked_sequence_number_, clock_.Now());
@@ skipping 309 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_->UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs));
+  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_->UpdateRtt(
-        QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs));
-    sender_->UpdateRtt(
-        QuicTime::Delta::FromMilliseconds(kRttMs - kDeviationMs));
+    UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs));
+    UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs - kDeviationMs));
   }
   expected_delay = QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs * 4);
 
-  EXPECT_NEAR(kRttMs, sender_->SmoothedRtt().ToMilliseconds(), 1);
+  EXPECT_NEAR(kRttMs, sender_->rtt_stats_.SmoothedRtt().ToMilliseconds(), 1);
   EXPECT_NEAR(expected_delay.ToMilliseconds(),
               sender_->RetransmissionDelay().ToMilliseconds(),
               1);
   EXPECT_EQ(static_cast<int64>(
                 sender_->GetCongestionWindow() * kNumMicrosPerSecond /
-                sender_->SmoothedRtt().ToMicroseconds()),
+                sender_->rtt_stats_.SmoothedRtt().ToMicroseconds()),
             sender_->BandwidthEstimate().ToBytesPerSecond());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
   const QuicTcpCongestionWindow kMaxCongestionWindowTCP = 50;
   const int kNumberOfAcks = 100;
   sender_.reset(
       new TcpCubicSenderPeer(&clock_, false, kMaxCongestionWindowTCP));
 
   QuicCongestionFeedbackFrame feedback;
@@ skipping 175 matching lines @@
   }
 
   // Next ack should cause congestion window to grow by 1MSS.
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net