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

net/quic/congestion_control/tcp_cubic_sender.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 "net/quic/congestion_control/tcp_cubic_sender.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "net/quic/congestion_control/rtt_stats.h"
@@ skipping 28 matching lines @@
       congestion_window_count_(0),
       receive_window_(kDefaultReceiveWindow),
       prr_out_(0),
       prr_delivered_(0),
       ack_count_since_loss_(0),
       bytes_in_flight_before_loss_(0),
       largest_sent_sequence_number_(0),
       largest_acked_sequence_number_(0),
       largest_sent_at_last_cutback_(0),
       congestion_window_(kInitialCongestionWindow),
+      previous_congestion_window_(0),
       slowstart_threshold_(max_tcp_congestion_window),
+      previous_slowstart_threshold_(0),
       last_cutback_exited_slowstart_(false),
       max_tcp_congestion_window_(max_tcp_congestion_window) {
 }
 
 TcpCubicSender::~TcpCubicSender() {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.FinalTcpCwnd", congestion_window_);
 }
 
 bool TcpCubicSender::InSlowStart() const {
   return congestion_window_ < slowstart_threshold_;
@@ skipping 207 matching lines @@
     congestion_window_ = min(max_tcp_congestion_window_,
                              cubic_.CongestionWindowAfterAck(
                                  congestion_window_, rtt_stats_->min_rtt()));
     DVLOG(1) << "Cubic; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
   }
 }
 
 void TcpCubicSender::OnRetransmissionTimeout(bool packets_retransmitted) {
   largest_sent_at_last_cutback_ = 0;
-  if (packets_retransmitted) {
-    cubic_.Reset();
-    hybrid_slow_start_.Restart();
-    congestion_window_ = kMinimumCongestionWindow;
+  if (!packets_retransmitted) {
+    return;
   }
+  cubic_.Reset();
+  hybrid_slow_start_.Restart();
+  previous_slowstart_threshold_ = slowstart_threshold_;
+  slowstart_threshold_ = congestion_window_ / 2;
+  previous_congestion_window_ = congestion_window_;
+  congestion_window_ = kMinimumCongestionWindow;
+}
+
+void TcpCubicSender::RevertRetransmissionTimeout() {
+  if (previous_congestion_window_ == 0) {
+    LOG(DFATAL) << "No previous congestion window to revert to.";
+    return;
+  }
+  congestion_window_ = previous_congestion_window_;
+  slowstart_threshold_ = previous_slowstart_threshold_;
+  previous_congestion_window_ = 0;
 }
 
 void TcpCubicSender::PrrOnPacketLost(QuicByteCount bytes_in_flight) {
   prr_out_ = 0;
   bytes_in_flight_before_loss_ = bytes_in_flight;
   prr_delivered_ = 0;
   ack_count_since_loss_ = 0;
 }
 
 void TcpCubicSender::PrrOnPacketAcked(QuicByteCount acked_bytes) {
@@ skipping 23 matching lines @@
   // AvailableSendWindow =
   //   CEIL(prr_delivered * ssthresh / BytesInFlightAtLoss) - prr_sent
   if (prr_delivered_ * slowstart_threshold_ * kMaxSegmentSize >
           prr_out_ * bytes_in_flight_before_loss_) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 }  // namespace net