Add support for the MIN1 connection option to TcpCubicBytesSender.

net/quic/congestion_control/tcp_cubic_bytes_sender.cc

 // Copyright (c) 2015 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_bytes_sender.h"
 
 #include <algorithm>
 
 #include "net/quic/congestion_control/prr_sender.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/crypto/crypto_protocol.h"
 
 using std::max;
 using std::min;
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
 // The minimum cwnd based on RFC 3782 (TCP NewReno) for cwnd reductions on a
 // fast retransmission.
-const QuicByteCount kMinimumCongestionWindow = 2 * kDefaultTCPMSS;
+const QuicByteCount kDefaultMinimumCongestionWindow = 2 * kDefaultTCPMSS;
 const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
 const int kMaxBurstLength = 3;
 const float kRenoBeta = 0.7f;             // Reno backoff factor.
 const uint32 kDefaultNumConnections = 2;  // N-connection emulation.
 }  // namespace
 
 TcpCubicBytesSender::TcpCubicBytesSender(
     const QuicClock* clock,
     const RttStats* rtt_stats,
     bool reno,
     QuicPacketCount initial_tcp_congestion_window,
     QuicConnectionStats* stats)
     : hybrid_slow_start_(clock),
       cubic_(clock),
       rtt_stats_(rtt_stats),
       stats_(stats),
       reno_(reno),
       num_connections_(kDefaultNumConnections),
       num_acked_packets_(0),
       largest_sent_sequence_number_(0),
       largest_acked_sequence_number_(0),
       largest_sent_at_last_cutback_(0),
       congestion_window_(initial_tcp_congestion_window * kMaxSegmentSize),
+      min_congestion_window_(kDefaultMinimumCongestionWindow),
       slowstart_threshold_(std::numeric_limits<uint64>::max()),
       last_cutback_exited_slowstart_(false),
       clock_(clock) {
 }
 
 TcpCubicBytesSender::~TcpCubicBytesSender() {
 }
 
 void TcpCubicBytesSender::SetFromConfig(const QuicConfig& config,
                                         Perspective perspective,
                                         bool using_pacing) {
   if (perspective == Perspective::IS_SERVER) {
     if (config.HasReceivedConnectionOptions() &&
         ContainsQuicTag(config.ReceivedConnectionOptions(), kIW10)) {
       // Initial window experiment.
       congestion_window_ = 10 * kMaxSegmentSize;
     }
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kMIN1)) {
+      // Min CWND experiment.
+      min_congestion_window_ = kMaxSegmentSize;
+    }
     if (using_pacing) {
       // Disable the ack train mode in hystart when pacing is enabled, since it
       // may be falsely triggered.
       hybrid_slow_start_.set_ack_train_detection(false);
     }
   }
 }
 
 bool TcpCubicBytesSender::ResumeConnectionState(
     const CachedNetworkParameters& cached_network_params) {
@@ skipping 93 matching lines @@
   prr_.OnPacketLost(bytes_in_flight);
 
   if (reno_) {
     congestion_window_ = congestion_window_ * RenoBeta();
   } else {
     congestion_window_ =
         cubic_.CongestionWindowAfterPacketLoss(congestion_window_);
   }
   slowstart_threshold_ = congestion_window_;
   // Enforce TCP's minimum congestion window of 2*MSS.
-  if (congestion_window_ < kMinimumCongestionWindow) {
-    congestion_window_ = kMinimumCongestionWindow;
+  if (congestion_window_ < min_congestion_window_) {
+    congestion_window_ = min_congestion_window_;
   }
   largest_sent_at_last_cutback_ = largest_sent_sequence_number_;
   // Reset packet count from congestion avoidance mode. We start counting again
   // when we're out of recovery.
   num_acked_packets_ = 0;
   DVLOG(1) << "Incoming loss; congestion window: " << congestion_window_
            << " slowstart threshold: " << slowstart_threshold_;
 }
 
 bool TcpCubicBytesSender::OnPacketSent(
@@ skipping 141 matching lines @@
 }
 
 void TcpCubicBytesSender::OnRetransmissionTimeout(bool packets_retransmitted) {
   largest_sent_at_last_cutback_ = 0;
   if (!packets_retransmitted) {
     return;
   }
   cubic_.Reset();
   hybrid_slow_start_.Restart();
   slowstart_threshold_ = congestion_window_ / 2;
-  congestion_window_ = kMinimumCongestionWindow;
+  congestion_window_ = min_congestion_window_;
 }
 
 CongestionControlType TcpCubicBytesSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net