Land Recent QUIC Changes until 03/27/2015

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 189 matching lines @@
     AckNPackets(2);
   }
   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();
-    AckNPackets(2);
-  }
-  QuicByteCount expected_send_window =
-      kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAcks);
-  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
-
-  // We should now have fallen out of slow start.
-  // Testing Reno phase.
-  // We should need 140(65*2+10) ACK:ed packets before increasing window by
-  // one.
-  for (int i = 0; i < 69; ++i) {
-    SendAvailableSendWindow();
-    AckNPackets(2);
-    EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
-  }
-  SendAvailableSendWindow();
-  AckNPackets(2);
-  QuicByteCount expected_ss_tresh = expected_send_window;
-  expected_send_window += kDefaultTCPMSS;
-  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
-  EXPECT_EQ(expected_ss_tresh, sender_->GetSlowStartThreshold());
-  EXPECT_EQ(140u, sender_->slowstart_threshold());
-
-  // Now RTO and ensure slow start gets reset.
-  EXPECT_TRUE(sender_->hybrid_slow_start().started());
-  sender_->OnRetransmissionTimeout(true);
-  EXPECT_FALSE(sender_->hybrid_slow_start().started());
-  EXPECT_EQ(2 * kDefaultTCPMSS, sender_->GetCongestionWindow());
-  EXPECT_EQ(expected_send_window / 2 / kDefaultTCPMSS,
-            sender_->slowstart_threshold());
-}
-
 TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   sender_->SetNumEmulatedConnections(1);
   const int kNumberOfAcks = 10;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   SendAvailableSendWindow();
   QuicByteCount expected_send_window = kDefaultWindowTCP +
@@ skipping 293 matching lines @@
                                     HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(TcpCubicSenderTest, ConfigureInitialWindow) {
   QuicConfig config;
 
   // Verify that kCOPT: kIW10 forces the congestion window to the default of 10.
   QuicTagVector options;
   options.push_back(kIW10);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
-  sender_->SetFromConfig(config, Perspective::IS_SERVER,
-                         /* using_pacing= */ false);
+  sender_->SetFromConfig(config, Perspective::IS_SERVER);
   EXPECT_EQ(10u, sender_->congestion_window());
 }
 
 TEST_F(TcpCubicSenderTest, ConfigureMinimumWindow) {
   QuicConfig config;
 
   // Verify that kCOPT: kMIN1 forces the min CWND to 1 packet.
   QuicTagVector options;
   options.push_back(kMIN1);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
-  sender_->SetFromConfig(config, Perspective::IS_SERVER,
-                         /* using_pacing= */ false);
+  sender_->SetFromConfig(config, Perspective::IS_SERVER);
   sender_->OnRetransmissionTimeout(true);
   EXPECT_EQ(1u, sender_->congestion_window());
 }
 
-TEST_F(TcpCubicSenderTest, DisableAckTrainDetectionWithPacing) {
-  EXPECT_TRUE(sender_->hybrid_slow_start().ack_train_detection());
-
-  QuicConfig config;
-  sender_->SetFromConfig(config, Perspective::IS_SERVER,
-                         /* using_pacing= */ true);
-  EXPECT_FALSE(sender_->hybrid_slow_start().ack_train_detection());
-}
-
 TEST_F(TcpCubicSenderTest, 2ConnectionCongestionAvoidanceAtEndOfRecovery) {
   sender_->SetNumEmulatedConnections(2);
   // Ack 10 packets in 5 acks to raise the CWND to 20.
   const int kNumberOfAcks = 5;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   SendAvailableSendWindow();
@@ skipping 130 matching lines @@
   // Resume to the max value.
   cached_network_params.set_max_bandwidth_estimate_bytes_per_second(
       (kMinCongestionWindowForBandwidthResumption + 10) * kDefaultTCPMSS);
   EXPECT_TRUE(sender_->ResumeConnectionState(cached_network_params, true));
   EXPECT_EQ((kMinCongestionWindowForBandwidthResumption + 10) * kDefaultTCPMSS,
             sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net