Rollback of merge internal change: 87346681.

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"
@@ skipping 13 matching lines @@
 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,
+    QuicPacketCount max_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),
+      max_congestion_window_(max_congestion_window * kMaxSegmentSize),
       slowstart_threshold_(std::numeric_limits<uint64>::max()),
       last_cutback_exited_slowstart_(false),
       clock_(clock) {
 }
 
 TcpCubicBytesSender::~TcpCubicBytesSender() {
 }
 
 void TcpCubicBytesSender::SetFromConfig(const QuicConfig& config,
                                         Perspective perspective,
@@ skipping 28 matching lines @@
   }
 
   QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(
       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).
   QuicByteCount new_congestion_window = bandwidth.ToBytesPerPeriod(rtt_ms);
   congestion_window_ =
-      max(min(new_congestion_window,
-              kMaxCongestionWindowForBandwidthResumption * kMaxSegmentSize),
+      max(min(new_congestion_window, kMaxTcpCongestionWindow * kMaxSegmentSize),
           kMinCongestionWindowForBandwidthResumption * kMaxSegmentSize);
 
   // TODO(rjshade): Set appropriate CWND when previous connection was in slow
   // start at time of estimate.
   return true;
 }
 
 void TcpCubicBytesSender::SetNumEmulatedConnections(int num_connections) {
   num_connections_ = max(1, num_connections);
   cubic_.SetNumConnections(num_connections_);
@@ skipping 190 matching lines @@
 void TcpCubicBytesSender::MaybeIncreaseCwnd(
     QuicPacketSequenceNumber acked_sequence_number,
     QuicByteCount acked_bytes,
     QuicByteCount bytes_in_flight) {
   LOG_IF(DFATAL, InRecovery()) << "Never increase the CWND during recovery.";
   if (!IsCwndLimited(bytes_in_flight)) {
     // We don't update the congestion window unless we are close to using the
     // window we have available.
     return;
   }
+  if (congestion_window_ >= max_congestion_window_) {
+    return;
+  }
   if (InSlowStart()) {
     // TCP slow start, exponential growth, increase by one for each ACK.
     congestion_window_ += kMaxSegmentSize;
     DVLOG(1) << "Slow start; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
     return;
   }
   // Congestion avoidance.
   if (reno_) {
     // Classic Reno congestion avoidance.
@@ skipping 26 matching lines @@
   hybrid_slow_start_.Restart();
   slowstart_threshold_ = congestion_window_ / 2;
   congestion_window_ = min_congestion_window_;
 }
 
 CongestionControlType TcpCubicBytesSender::GetCongestionControlType() const {
   return reno_ ? kRenoBytes : kCubicBytes;
 }
 
 }  // namespace net