Land Recent QUIC changes.

net/quic/congestion_control/inter_arrival_sender.cc

 // Copyright (c) 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/congestion_control/inter_arrival_sender.h"
 
 namespace net {
 
 namespace {
 const int64 kProbeBitrateKBytesPerSecond = 1200;  // 9.6 Mbit/s
 const float kPacketLossBitrateReduction = 0.7f;
 const float kUncertainSafetyMargin = 0.7f;
 const float kMaxBitrateReduction = 0.9f;
 const float kMinBitrateReduction = 0.05f;
 const uint64 kMinBitrateKbit = 10;
 const int kInitialRttMs = 60;  // At a typical RTT 60 ms.
+const float kAlpha = 0.125f;
+const float kOneMinusAlpha = 1 - kAlpha;
 
 static const int kBitrateSmoothingPeriodMs = 1000;
 static const int kMinBitrateSmoothingPeriodMs = 500;
 
 }  // namespace
 
 InterArrivalSender::InterArrivalSender(const QuicClock* clock)
     : probing_(true),
       current_bandwidth_(QuicBandwidth::Zero()),
       smoothed_rtt_(QuicTime::Delta::Zero()),
@@ skipping 166 matching lines @@
              << available_channel_estimate.ToKBitsPerSecond() << " Kbits/s "
              << " channel estimate:"
              << channel_estimate.ToKBitsPerSecond() << " Kbits/s ";
   return false;
 }
 
 void InterArrivalSender::OnIncomingAck(
     QuicPacketSequenceNumber /*acked_sequence_number*/,
     QuicByteCount acked_bytes,
     QuicTime::Delta rtt) {
-  DCHECK(!rtt.IsZero());
-  DCHECK(!rtt.IsInfinite());
+  // RTT can't be negative.
+  DCHECK_LE(0, rtt.ToMicroseconds());
+
+  if (probing_) {
+    probe_->OnAcknowledgedPacket(acked_bytes);
+  }
+
+  if (rtt.IsInfinite()) {
+    return;
+  }
+
   if (smoothed_rtt_.IsZero()) {
     smoothed_rtt_ = rtt;
   } else {
     smoothed_rtt_ = QuicTime::Delta::FromMicroseconds(
-        (smoothed_rtt_.ToMicroseconds() * 3 + rtt.ToMicroseconds()) / 4);
+        kOneMinusAlpha * smoothed_rtt_.ToMicroseconds() +
+        kAlpha * rtt.ToMicroseconds());
   }
-  state_machine_->set_rtt(SmoothedRtt());
-  if (probing_) {
-    probe_->OnAcknowledgedPacket(acked_bytes);
-  }
+  state_machine_->set_rtt(smoothed_rtt_);
 }
 
 void InterArrivalSender::OnIncomingLoss(QuicTime ack_receive_time) {
   // Packet loss was reported.
   if (!probing_) {
     if (!state_machine_->PacketLossEvent()) {
       // Less than one RTT since last PacketLossEvent.
       return;
     }
     // Calculate new pace rate.
@@ skipping 73 matching lines @@
   return current_bandwidth_;
 }
 
 QuicTime::Delta InterArrivalSender::SmoothedRtt() {
   if (smoothed_rtt_.IsZero()) {
     return QuicTime::Delta::FromMilliseconds(kInitialRttMs);
   }
   return smoothed_rtt_;
 }
 
+QuicTime::Delta InterArrivalSender::RetransmissionDelay() {
+  // TODO(pwestin): Calculate and return retransmission delay.
+  // Use 2 * the smoothed RTT for now.
+  return smoothed_rtt_.Add(smoothed_rtt_);
+}
+
 void InterArrivalSender::EstimateNewBandwidth(QuicTime feedback_receive_time,
                                               QuicBandwidth sent_bandwidth) {
   QuicBandwidth new_bandwidth = bitrate_ramp_up_->GetNewBitrate(sent_bandwidth);
   if (current_bandwidth_ == new_bandwidth) {
     return;
   }
   current_bandwidth_ = new_bandwidth;
   state_machine_->IncreaseBitrateDecision();
 
   QuicBandwidth channel_estimate = QuicBandwidth::Zero();
@@ skipping 162 matching lines @@
   bitrate_ramp_up_->Reset(new_rate, current_bandwidth_, channel_estimate);
   if (new_rate != current_bandwidth_) {
     current_bandwidth_ = new_rate;
     paced_sender_->UpdateBandwidthEstimate(feedback_receive_time,
                                            current_bandwidth_);
     state_machine_->DecreaseBitrateDecision();
   }
 }
 
 }  // namespace net