Rollback of merge internal change: 87346681.

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"
@@ skipping 12 matching lines @@
 // TODO(ianswett): A number of theses tests were written with the assumption of
 // an initial CWND of 10. They have carefully calculated values which should be
 // updated to be based on kInitialCongestionWindowInsecure.
 const uint32 kInitialCongestionWindowPackets = 10;
 const uint32 kDefaultWindowTCP =
     kInitialCongestionWindowPackets * kDefaultTCPMSS;
 const float kRenoBeta = 0.7f;  // Reno backoff factor.
 
 class TcpCubicSenderPeer : public TcpCubicSender {
  public:
-  TcpCubicSenderPeer(const QuicClock* clock, bool reno)
+  TcpCubicSenderPeer(const QuicClock* clock,
+                     bool reno,
+                     QuicPacketCount max_tcp_congestion_window)
       : TcpCubicSender(clock,
                        &rtt_stats_,
                        reno,
                        kInitialCongestionWindowPackets,
+                       max_tcp_congestion_window,
                        &stats_) {}
 
   QuicPacketCount congestion_window() {
     return congestion_window_;
   }
 
   QuicPacketCount slowstart_threshold() {
     return slowstart_threshold_;
   }
 
   const HybridSlowStart& hybrid_slow_start() const {
     return hybrid_slow_start_;
   }
 
   float GetRenoBeta() const {
     return RenoBeta();
   }
 
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
 };
 
 class TcpCubicSenderTest : public ::testing::Test {
  protected:
   TcpCubicSenderTest()
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
-        sender_(new TcpCubicSenderPeer(&clock_, true)),
+        sender_(new TcpCubicSenderPeer(&clock_, true, kMaxTcpCongestionWindow)),
         sequence_number_(1),
         acked_sequence_number_(0),
         bytes_in_flight_(0) {
     standard_packet_.bytes_sent = kDefaultTCPMSS;
   }
 
   int SendAvailableSendWindow() {
     // Send as long as TimeUntilSend returns Zero.
     int packets_sent = 0;
     bool can_send = sender_->TimeUntilSend(
@@ skipping 124 matching lines @@
   const QuicByteCount cwnd = sender_->GetCongestionWindow();
   EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks, cwnd);
   EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
   EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(
                 cwnd, sender_->rtt_stats_.smoothed_rtt()),
             sender_->BandwidthEstimate());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
   sender_->SetNumEmulatedConnections(1);
+  EXPECT_EQ(kMaxTcpCongestionWindow * kDefaultTCPMSS,
+            sender_->GetSlowStartThreshold());
 
   // Make sure that we fall out of slow start when we send ACK train longer
   // than half the RTT, in this test case 30ms, which is more than 30 calls to
   // Ack2Packets in one round.
   // Since we start at 10 packet first round will be 5 second round 10 etc
   // Hence we should pass 30 at 65 = 5 + 10 + 20 + 30
   const int kNumberOfAcks = 65;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
@@ skipping 188 matching lines @@
 
   // Exit recovery and return to sending at the new rate.
   for (int i = 0; i < kNumberOfAcks; ++i) {
     AckNPackets(1);
     EXPECT_EQ(1, SendAvailableSendWindow());
   }
 }
 
 TEST_F(TcpCubicSenderTest, RTOCongestionWindow) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
+  EXPECT_EQ(kMaxTcpCongestionWindow, sender_->slowstart_threshold());
+
   // Expect the window to decrease to the minimum once the RTO fires
   // and slow start threshold to be set to 1/2 of the CWND.
   sender_->OnRetransmissionTimeout(true);
   EXPECT_EQ(2 * kDefaultTCPMSS, sender_->GetCongestionWindow());
   EXPECT_EQ(5u, sender_->slowstart_threshold());
 }
 
 TEST_F(TcpCubicSenderTest, RTOCongestionWindowNoRetransmission) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
 
@@ skipping 32 matching lines @@
   EXPECT_NEAR(kRttMs, sender_->rtt_stats_.smoothed_rtt().ToMilliseconds(), 1);
   EXPECT_NEAR(expected_delay.ToMilliseconds(),
               sender_->RetransmissionDelay().ToMilliseconds(),
               1);
   EXPECT_EQ(static_cast<int64>(
                 sender_->GetCongestionWindow() * kNumMicrosPerSecond /
                 sender_->rtt_stats_.smoothed_rtt().ToMicroseconds()),
             sender_->BandwidthEstimate().ToBytesPerSecond());
 }
 
+TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
+  const QuicPacketCount kMaxCongestionWindowTCP = 50;
+  const int kNumberOfAcks = 100;
+  sender_.reset(
+      new TcpCubicSenderPeer(&clock_, false, kMaxCongestionWindowTCP));
+
+  for (int i = 0; i < kNumberOfAcks; ++i) {
+    // Send our full send window.
+    SendAvailableSendWindow();
+    AckNPackets(2);
+  }
+  QuicByteCount expected_send_window = kMaxCongestionWindowTCP * kDefaultTCPMSS;
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+}
+
+TEST_F(TcpCubicSenderTest, TcpRenoMaxCongestionWindow) {
+  const QuicPacketCount kMaxCongestionWindowTCP = 50;
+  const int kNumberOfAcks = 1000;
+  sender_.reset(new TcpCubicSenderPeer(&clock_, true, kMaxCongestionWindowTCP));
+
+  SendAvailableSendWindow();
+  AckNPackets(2);
+  // Make sure we fall out of slow start.
+  LoseNPackets(1);
+
+  for (int i = 0; i < kNumberOfAcks; ++i) {
+    // Send our full send window.
+    SendAvailableSendWindow();
+    AckNPackets(2);
+  }
+
+  QuicByteCount expected_send_window = kMaxCongestionWindowTCP * kDefaultTCPMSS;
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+}
+
+TEST_F(TcpCubicSenderTest, TcpCubicMaxCongestionWindow) {
+  const QuicPacketCount kMaxCongestionWindowTCP = 50;
+  // Set to 10000 to compensate for small cubic alpha.
+  const int kNumberOfAcks = 10000;
+
+  sender_.reset(
+      new TcpCubicSenderPeer(&clock_, false, kMaxCongestionWindowTCP));
+
+  SendAvailableSendWindow();
+  AckNPackets(2);
+  // Make sure we fall out of slow start.
+  LoseNPackets(1);
+
+  for (int i = 0; i < kNumberOfAcks; ++i) {
+    // Send our full send window.
+    SendAvailableSendWindow();
+    AckNPackets(2);
+  }
+
+  QuicByteCount expected_send_window = kMaxCongestionWindowTCP * kDefaultTCPMSS;
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+}
+
 TEST_F(TcpCubicSenderTest, MultipleLossesInOneWindow) {
   SendAvailableSendWindow();
   const QuicByteCount initial_window = sender_->GetCongestionWindow();
   LosePacket(acked_sequence_number_ + 1);
   const QuicByteCount post_loss_window = sender_->GetCongestionWindow();
   EXPECT_GT(initial_window, post_loss_window);
   LosePacket(acked_sequence_number_ + 3);
   EXPECT_EQ(post_loss_window, sender_->GetCongestionWindow());
   LosePacket(sequence_number_ - 1);
   EXPECT_EQ(post_loss_window, sender_->GetCongestionWindow());
@@ skipping 172 matching lines @@
   EXPECT_EQ(10u, sender_->congestion_window());
 
   // If the estimate is new enough, make sure it is used.
   cached_network_params.set_timestamp(clock_.WallNow().ToUNIXSeconds() -
                                       (kNumSecondsPerHour - 1));
   EXPECT_TRUE(sender_->ResumeConnectionState(cached_network_params));
   EXPECT_EQ(kNumberOfPackets, sender_->congestion_window());
 
   // Resumed CWND is limited to be in a sensible range.
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
-      (kMaxCongestionWindowForBandwidthResumption + 1) * kMaxPacketSize);
+      (kMaxTcpCongestionWindow + 1) * kMaxPacketSize);
   EXPECT_TRUE(sender_->ResumeConnectionState(cached_network_params));
-  EXPECT_EQ(kMaxCongestionWindowForBandwidthResumption,
-            sender_->congestion_window());
+  EXPECT_EQ(kMaxTcpCongestionWindow, sender_->congestion_window());
 
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
       (kMinCongestionWindowForBandwidthResumption - 1) * kMaxPacketSize);
   EXPECT_TRUE(sender_->ResumeConnectionState(cached_network_params));
   EXPECT_EQ(kMinCongestionWindowForBandwidthResumption,
             sender_->congestion_window());
 }
 
 }  // namespace test
 }  // namespace net