Repair the CWND reduction caused by spurious RTO's in QUIC's congestion

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 19 matching lines @@
                      bool reno,
                      QuicTcpCongestionWindow max_tcp_congestion_window)
       : TcpCubicSender(
             clock, &rtt_stats_, reno, max_tcp_congestion_window, &stats_) {
   }
 
   QuicTcpCongestionWindow congestion_window() {
     return congestion_window_;
   }
 
+  QuicTcpCongestionWindow slowstart_threshold() {
+    return slowstart_threshold_;
+  }
+
   const HybridSlowStart& hybrid_slow_start() const {
     return hybrid_slow_start_;
   }
 
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
 
   using TcpCubicSender::SendWindow;
 };
 
@@ skipping 179 matching lines @@
   // one.
   for (int i = 0; i < 69; ++i) {
     SendAvailableSendWindow();
     AckNPackets(2);
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   }
   SendAvailableSendWindow();
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+  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());
+
+  // Now revert the RTO and ensure the CWND and slowstart threshold revert.
+  sender_->RevertRetransmissionTimeout();
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+  EXPECT_EQ(140u, sender_->slowstart_threshold());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   // Make sure that we fall out of slow start when we encounter a packet loss.
   QuicCongestionFeedbackFrame feedback;
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
 
   const int kNumberOfAcks = 10;
@@ skipping 160 matching lines @@
   // The window should not have changed.
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
   // 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) {
+TEST_F(TcpCubicSenderTest, RTOCongestionWindowAndRevert) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
+  EXPECT_EQ(10000u, sender_->slowstart_threshold());
 
-  // Expect the window to decrease to the minimum once the RTO fires.
+  // 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_->SendWindow());
+  EXPECT_EQ(5u, sender_->slowstart_threshold());
+
+  // Now repair the RTO and ensure the slowstart threshold reverts.
+  sender_->RevertRetransmissionTimeout();
+  EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
+  EXPECT_EQ(10000u, sender_->slowstart_threshold());
 }
 
 TEST_F(TcpCubicSenderTest, RTOCongestionWindowNoRetransmission) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
 
   // Expect the window to remain unchanged if the RTO fires but no
   // packets are retransmitted.
   sender_->OnRetransmissionTimeout(false);
   EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
 }
@@ skipping 191 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