Landing Recent QUIC changes until Mon May 8 21:42:46 2017 +0000

net/quic/core/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/core/quic_sent_packet_manager.h"
 
 #include <algorithm>
 #include <string>
 
 #include "net/quic/chromium/quic_utils_chromium.h"
@@ skipping 99 matching lines @@
     SetSendAlgorithm(kBBR);
   }
   if (config.HasClientRequestedIndependentOption(kRENO, perspective_)) {
     if (config.HasClientRequestedIndependentOption(kBYTE, perspective_)) {
       SetSendAlgorithm(kRenoBytes);
     } else {
       SetSendAlgorithm(kReno);
     }
   } else if (config.HasClientRequestedIndependentOption(kBYTE, perspective_)) {
     SetSendAlgorithm(kCubic);
+  } else if (FLAGS_quic_reloadable_flag_quic_enable_pcc &&
+             config.HasClientRequestedIndependentOption(kTPCC, perspective_)) {
+    SetSendAlgorithm(kPCC);
   }
-  using_pacing_ = !FLAGS_quic_disable_pacing_for_perf_tests;
+
+  // The PCCSender implements its own version of pacing through the
+  // SendAlgorithm::TimeUntilSend() function.  Do not wrap a
+  // PacingSender around it, since wrapping a PacingSender around an
+  // already paced SendAlgorithm produces a DCHECK.  TODO(fayang):
+  // Change this if/when the PCCSender uses the PacingSender.
+  using_pacing_ = !FLAGS_quic_disable_pacing_for_perf_tests &&
+                  send_algorithm_->GetCongestionControlType() != kPCC;
 
   if (config.HasClientSentConnectionOption(k1CON, perspective_)) {
     send_algorithm_->SetNumEmulatedConnections(1);
   }
   if (config.HasClientSentConnectionOption(kNCON, perspective_)) {
     n_connection_simulation_ = true;
   }
   if (config.HasClientSentConnectionOption(kNTLP, perspective_)) {
     max_tail_loss_probes_ = 0;
   }
@@ skipping 657 matching lines @@
   QuicTime::Delta srtt = rtt_stats_.smoothed_rtt();
   if (srtt.IsZero()) {
     srtt = QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us());
   }
   if (enable_half_rtt_tail_loss_probe_ && consecutive_tlp_count_ == 0u) {
     return QuicTime::Delta::FromMilliseconds(
         std::max(kMinTailLossProbeTimeoutMs,
                  static_cast<int64_t>(0.5 * srtt.ToMilliseconds())));
   }
   if (!unacked_packets_.HasMultipleInFlightPackets()) {
-    return std::max(2 * srtt,
-                    1.5 * srtt + QuicTime::Delta::FromMilliseconds(
-                                     kMinRetransmissionTimeMs / 2));
+    return std::max(2 * srtt, 1.5 * srtt + QuicTime::Delta::FromMilliseconds(
+                                               kMinRetransmissionTimeMs / 2));
   }
   return QuicTime::Delta::FromMilliseconds(
       std::max(kMinTailLossProbeTimeoutMs,
                static_cast<int64_t>(2 * srtt.ToMilliseconds())));
 }
 
 const QuicTime::Delta QuicSentPacketManager::GetRetransmissionDelay() const {
   QuicTime::Delta retransmission_delay = QuicTime::Delta::Zero();
   if (rtt_stats_.smoothed_rtt().IsZero()) {
     // We are in the initial state, use default timeout values.
@@ skipping 135 matching lines @@
 
 void QuicSentPacketManager::OnApplicationLimited() {
   send_algorithm_->OnApplicationLimited(unacked_packets_.bytes_in_flight());
 }
 
 const SendAlgorithmInterface* QuicSentPacketManager::GetSendAlgorithm() const {
   return send_algorithm_.get();
 }
 
 }  // namespace net