Update from https://crrev.com/304418

net/quic/congestion_control/hybrid_slow_start.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/hybrid_slow_start.h"
 
 #include <algorithm>
 
 using std::max;
 using std::min;
 
 namespace net {
 
 // Note(pwestin): the magic clamping numbers come from the original code in
 // tcp_cubic.c.
 const int64 kHybridStartLowWindow = 16;
 // Number of delay samples for detecting the increase of delay.
 const uint32 kHybridStartMinSamples = 8;
 const int kHybridStartDelayFactorExp = 4;  // 2^4 = 16
 // The original paper specifies 2 and 8ms, but those have changed over time.
 const int64 kHybridStartDelayMinThresholdUs = 4000;
 const int64 kHybridStartDelayMaxThresholdUs = 16000;
 
 HybridSlowStart::HybridSlowStart(const QuicClock* clock)
     : clock_(clock),
+      ack_train_detection_(true),
       started_(false),
       hystart_found_(NOT_FOUND),
       last_sent_sequence_number_(0),
       round_start_(QuicTime::Zero()),
       end_sequence_number_(0),
       last_close_ack_pair_time_(QuicTime::Zero()),
       rtt_sample_count_(0),
       current_min_rtt_(QuicTime::Delta::Zero()) {
 }
 
@@ skipping 41 matching lines @@
   }
   QuicTime current_time = clock_->ApproximateNow();
 
   // First detection parameter - ack-train detection.
   // Since slow start burst out packets we can indirectly estimate the inter-
   // arrival time by looking at the arrival time of the ACKs if the ACKs are
   // spread out more then half the minimum RTT packets are being spread out
   // more than the capacity.
   // This first trigger will not come into play until we hit roughly 9.6 Mbps
   // with delayed acks (or 4.8Mbps without delayed acks)
-  // TODO(ianswett): QUIC always uses delayed acks, even at the beginning, so
-  // this should likely be at least 4ms.
-  // TODO(pwestin): we need to make sure our pacing don't trigger this detector.
-  // TODO(ianswett): Pacing or other cases could be handled by checking the send
-  // time of the first acked packet in a receive round.
-  if (current_time.Subtract(last_close_ack_pair_time_).ToMicroseconds() <=
+  if (ack_train_detection_ &&
+      current_time.Subtract(last_close_ack_pair_time_).ToMicroseconds() <=
           kHybridStartDelayMinThresholdUs) {
     last_close_ack_pair_time_ = current_time;
     if (current_time.Subtract(round_start_).ToMicroseconds() >=
             min_rtt.ToMicroseconds() >> 1) {
       hystart_found_ = ACK_TRAIN;
     }
   } else if (last_close_ack_pair_time_ == round_start_) {
     // If the previous ack wasn't close, then move forward the round start time
     // to the incoming ack.
     last_close_ack_pair_time_ = round_start_ = current_time;
@@ skipping 26 matching lines @@
       hystart_found_= DELAY;
     }
   }
   // Exit from slow start if the cwnd is greater than 16 and an ack train or
   // increasing delay are found.
   return congestion_window >= kHybridStartLowWindow &&
       hystart_found_ != NOT_FOUND;
 }
 
 }  // namespace net