Remove the kMaxSegmentSize constant from QUIC's TcpCubicSender and TcpCubicBytesSender and replace …

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_macros.h"
 #include "net/quic/congestion_control/prr_sender.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_flags.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.  The cwnd after a timeout is still 1.
 const QuicPacketCount kDefaultMinimumCongestionWindow = 2;
-const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
-const QuicByteCount kMaxBurstBytes = 3 * kMaxSegmentSize;
+const QuicByteCount kMaxBurstBytes = 3 * kDefaultTCPMSS;
 const float kRenoBeta = 0.7f;  // Reno backoff factor.
 const uint32 kDefaultNumConnections = 2;  // N-connection emulation.
 }  // namespace
 
 TcpCubicSender::TcpCubicSender(const QuicClock* clock,
                                const RttStats* rtt_stats,
                                bool reno,
                                QuicPacketCount initial_tcp_congestion_window,
                                QuicPacketCount max_tcp_congestion_window,
                                QuicConnectionStats* stats)
@@ skipping 60 matching lines @@
     bool max_bandwidth_resumption) {
   QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(
       max_bandwidth_resumption
           ? cached_network_params.max_bandwidth_estimate_bytes_per_second()
           : cached_network_params.bandwidth_estimate_bytes_per_second());
   QuicTime::Delta rtt_ms =
       QuicTime::Delta::FromMilliseconds(cached_network_params.min_rtt_ms());
 
   // Make sure CWND is in appropriate range (in case of bad data).
   QuicPacketCount new_congestion_window =
-      bandwidth.ToBytesPerPeriod(rtt_ms) / kMaxPacketSize;
+      bandwidth.ToBytesPerPeriod(rtt_ms) / kDefaultTCPMSS;
   congestion_window_ = max(min(new_congestion_window, kMaxCongestionWindow),
                            kMinCongestionWindowForBandwidthResumption);
 }
 
 void TcpCubicSender::SetNumEmulatedConnections(int num_connections) {
   num_connections_ = max(1, num_connections);
   cubic_.SetNumConnections(num_connections_);
 }
 
 void TcpCubicSender::SetMaxCongestionWindow(
     QuicByteCount max_congestion_window) {
-  max_tcp_congestion_window_ = max_congestion_window / kMaxPacketSize;
+  max_tcp_congestion_window_ = max_congestion_window / kDefaultTCPMSS;
 }
 
 float TcpCubicSender::RenoBeta() const {
   // kNConnectionBeta is the backoff factor after loss for our N-connection
   // emulation, which emulates the effective backoff of an ensemble of N
   // TCP-Reno connections on a single loss event. The effective multiplier is
   // computed as:
   return (num_connections_ - 1 + kRenoBeta) / num_connections_;
 }
 
@@ skipping 99 matching lines @@
     QuicTime /* now */,
     QuicByteCount bytes_in_flight,
     HasRetransmittableData has_retransmittable_data) const {
   if (has_retransmittable_data == NO_RETRANSMITTABLE_DATA) {
     // For TCP we can always send an ACK immediately.
     return QuicTime::Delta::Zero();
   }
   if (InRecovery()) {
     // PRR is used when in recovery.
     return prr_.TimeUntilSend(GetCongestionWindow(), bytes_in_flight,
-                              slowstart_threshold_ * kMaxSegmentSize);
+                              slowstart_threshold_ * kDefaultTCPMSS);
   }
   if (GetCongestionWindow() > bytes_in_flight) {
     return QuicTime::Delta::Zero();
   }
-  if (min4_mode_ && bytes_in_flight < 4 * kMaxSegmentSize) {
+  if (min4_mode_ && bytes_in_flight < 4 * kDefaultTCPMSS) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 QuicBandwidth TcpCubicSender::PacingRate() const {
   // We pace at twice the rate of the underlying sender's bandwidth estimate
   // during slow start and 1.25x during congestion avoidance to ensure pacing
   // doesn't prevent us from filling the window.
   QuicTime::Delta srtt = rtt_stats_->smoothed_rtt();
@@ skipping 16 matching lines @@
 
 QuicTime::Delta TcpCubicSender::RetransmissionDelay() const {
   if (rtt_stats_->smoothed_rtt().IsZero()) {
     return QuicTime::Delta::Zero();
   }
   return rtt_stats_->smoothed_rtt().Add(
       rtt_stats_->mean_deviation().Multiply(4));
 }
 
 QuicByteCount TcpCubicSender::GetCongestionWindow() const {
-  return congestion_window_ * kMaxSegmentSize;
+  return congestion_window_ * kDefaultTCPMSS;
 }
 
 bool TcpCubicSender::InSlowStart() const {
   return congestion_window_ < slowstart_threshold_;
 }
 
 QuicByteCount TcpCubicSender::GetSlowStartThreshold() const {
-  return slowstart_threshold_ * kMaxSegmentSize;
+  return slowstart_threshold_ * kDefaultTCPMSS;
 }
 
 bool TcpCubicSender::IsCwndLimited(QuicByteCount bytes_in_flight) const {
   const QuicByteCount congestion_window_bytes = GetCongestionWindow();
   if (bytes_in_flight >= congestion_window_bytes) {
     return true;
   }
   const QuicByteCount available_bytes =
       congestion_window_bytes - bytes_in_flight;
   const bool slow_start_limited = InSlowStart() &&
@@ skipping 62 matching lines @@
   hybrid_slow_start_.Restart();
   slowstart_threshold_ = congestion_window_ / 2;
   congestion_window_ = min_congestion_window_;
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net