Remove a QUIC test only flag(limit_rto_increase_for_tests) to limit the

net/quic/quic_sent_packet_manager.cc

 // Copyright 2013 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/quic_sent_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/quic_ack_notifier_manager.h"
 
 using std::make_pair;
 using std::max;
 using std::min;
 
 // TODO(rtenneti): Remove this.
 // Do not flip this flag until the flakiness of the
 // net/tools/quic/end_to_end_test is fixed.
 // If true, then QUIC connections will track the retransmission history of a
 // packet so that an ack of a previous transmission will ack the data of all
 // other transmissions.
 bool FLAGS_track_retransmission_history = false;
 
-// A test-only flag to prevent the RTO from backing off when multiple sequential
-// tail drops occur.
-bool FLAGS_limit_rto_increase_for_tests = false;
-
 // Do not remove this flag until the Finch-trials described in b/11706275
 // are complete.
 // If true, QUIC connections will support the use of a pacing algorithm when
 // sending packets, in an attempt to reduce packet loss.  The client must also
 // request pacing for the server to enable it.
 bool FLAGS_enable_quic_pacing = false;
 
 namespace net {
 namespace {
 static const int kBitrateSmoothingPeriodMs = 1000;
@@ skipping 812 matching lines @@
       QuicTime rto_timeout = sent_time.Add(GetRetransmissionDelay());
 
       return QuicTime::Max(min_timeout, rto_timeout);
     }
     default:
       DCHECK(false);
   }
   return QuicTime::Zero();
 }
 
-const QuicTime::Delta
-QuicSentPacketManager::GetCryptoRetransmissionDelay() const {
+const QuicTime::Delta QuicSentPacketManager::GetCryptoRetransmissionDelay()
+    const {
   // This is equivalent to the TailLossProbeDelay, but slightly more aggressive
   // because crypto handshake messages don't incur a delayed ack time.
   int64 delay_ms = max<int64>(kMinHandshakeTimeoutMs,
                               1.5 * SmoothedRtt().ToMilliseconds());
   return QuicTime::Delta::FromMilliseconds(
       delay_ms << consecutive_crypto_retransmission_count_);
 }
 
 const QuicTime::Delta QuicSentPacketManager::GetTailLossProbeDelay() const {
   QuicTime::Delta srtt = SmoothedRtt();
   if (pending_packets_.size() == 1) {
     return QuicTime::Delta::Max(
         srtt.Multiply(1.5).Add(DelayedAckTime()), srtt.Multiply(2));
   }
   return QuicTime::Delta::FromMilliseconds(
       max(kMinTailLossProbeTimeoutMs,
           static_cast<int64>(2 * srtt.ToMilliseconds())));
 }
 
 const QuicTime::Delta QuicSentPacketManager::GetRetransmissionDelay() const {
-  size_t number_retransmissions = consecutive_rto_count_;
-  // TODO(ianswett): Remove this flag now that EndToEndTest is no longer flaky.
-  if (FLAGS_limit_rto_increase_for_tests) {
-    const size_t kTailDropWindowSize = 5;
-    const size_t kTailDropMaxRetransmissions = 4;
-    if (pending_packets_.size() <= kTailDropWindowSize) {
-      // Avoid exponential backoff of RTO when there are only a few packets
-      // outstanding.  This helps avoid the situation where fake packet loss
-      // causes a packet and it's retransmission to be dropped causing
-      // test timouts.
-      if (number_retransmissions <= kTailDropMaxRetransmissions) {
-        number_retransmissions = 0;
-      } else {
-        number_retransmissions -= kTailDropMaxRetransmissions;
-      }
-    }
-  }
-
   QuicTime::Delta retransmission_delay = send_algorithm_->RetransmissionDelay();
   if (retransmission_delay.IsZero()) {
     // We are in the initial state, use default timeout values.
     retransmission_delay =
         QuicTime::Delta::FromMilliseconds(kDefaultRetransmissionTimeMs);
   }
   // Calculate exponential back off.
   retransmission_delay = retransmission_delay.Multiply(
-      1 << min<size_t>(number_retransmissions, kMaxRetransmissions));
+      1 << min<size_t>(consecutive_rto_count_, kMaxRetransmissions));
 
   // TODO(rch): This code should move to |send_algorithm_|.
   if (retransmission_delay.ToMilliseconds() < kMinRetransmissionTimeMs) {
     return QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs);
   }
   if (retransmission_delay.ToMilliseconds() > kMaxRetransmissionTimeMs) {
     return QuicTime::Delta::FromMilliseconds(kMaxRetransmissionTimeMs);
   }
   return retransmission_delay;
 }
@@ skipping 40 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net