Landing Recent QUIC Changes.

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.h"
 #include "net/quic/congestion_control/rtt_stats.h"
@@ skipping 80 matching lines @@
   }
 }
 
 void TcpCubicSender::OnCongestionEvent(
     bool rtt_updated,
     QuicByteCount bytes_in_flight,
     const CongestionVector& acked_packets,
     const CongestionVector& lost_packets) {
   if (rtt_updated && InSlowStart() &&
       hybrid_slow_start_.ShouldExitSlowStart(rtt_stats_->latest_rtt(),
-                                             rtt_stats_->min_rtt(),
+                                             rtt_stats_->MinRtt(),
                                              congestion_window_)) {
     slowstart_threshold_ = congestion_window_;
   }
   for (CongestionVector::const_iterator it = lost_packets.begin();
        it != lost_packets.end(); ++it) {
     OnPacketLost(it->first, bytes_in_flight);
   }
   for (CongestionVector::const_iterator it = acked_packets.begin();
        it != acked_packets.end(); ++it) {
     OnPacketAcked(it->first, it->second.bytes_sent, bytes_in_flight);
@@ skipping 85 matching lines @@
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 QuicByteCount TcpCubicSender::SendWindow() const {
   // What's the current send window in bytes.
   return min(receive_window_, GetCongestionWindow());
 }
 
+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.
+  return BandwidthEstimate().Scale(InSlowStart() ? 2 : 1.25);
+}
+
 QuicBandwidth TcpCubicSender::BandwidthEstimate() const {
+  if (rtt_stats_->SmoothedRtt().IsZero()) {
+    LOG(DFATAL) << "In BandwidthEstimate(), smoothed RTT is zero!";
+    return QuicBandwidth::Zero();
+  }
   return QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(),
                                               rtt_stats_->SmoothedRtt());
 }
 
 bool TcpCubicSender::HasReliableBandwidthEstimate() const {
   return !InSlowStart() && !InRecovery();
 }
 
 QuicTime::Delta TcpCubicSender::RetransmissionDelay() const {
   if (!rtt_stats_->HasUpdates()) {
     return QuicTime::Delta::Zero();
   }
-  return QuicTime::Delta::FromMicroseconds(
-      rtt_stats_->SmoothedRtt().ToMicroseconds() +
-      4 * rtt_stats_->mean_deviation().ToMicroseconds());
+  return rtt_stats_->SmoothedRtt().Add(
+      rtt_stats_->mean_deviation().Multiply(4));
 }
 
 QuicByteCount TcpCubicSender::GetCongestionWindow() const {
   return congestion_window_ * kMaxSegmentSize;
 }
 
 bool TcpCubicSender::InSlowStart() const {
   return congestion_window_ < slowstart_threshold_;
 }
 
@@ skipping 54 matching lines @@
       ++congestion_window_;
       congestion_window_count_ = 0;
     }
 
     DVLOG(1) << "Reno; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_
              << " congestion window count: " << congestion_window_count_;
   } else {
     congestion_window_ = min(max_tcp_congestion_window_,
                              cubic_.CongestionWindowAfterAck(
-                                 congestion_window_, rtt_stats_->min_rtt()));
+                                 congestion_window_, rtt_stats_->MinRtt()));
     DVLOG(1) << "Cubic; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
   }
 }
 
 void TcpCubicSender::OnRetransmissionTimeout(bool packets_retransmitted) {
   largest_sent_at_last_cutback_ = 0;
   if (!packets_retransmitted) {
     return;
   }
@@ skipping 53 matching lines @@
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net