Land Recent QUIC changes.

net/quic/congestion_control/quic_congestion_manager.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/quic_congestion_manager.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/stl_util.h"
@@ skipping 30 matching lines @@
       receive_algorithm_(ReceiveAlgorithmInterface::Create(clock, type)),
       send_algorithm_(SendAlgorithmInterface::Create(clock, type)),
       largest_missing_(0),
       current_rtt_(QuicTime::Delta::Infinite()) {
 }
 
 QuicCongestionManager::~QuicCongestionManager() {
   STLDeleteValues(&packet_history_map_);
 }
 
-void QuicCongestionManager::SentPacket(QuicPacketSequenceNumber sequence_number,
-                                       QuicTime sent_time,
-                                       QuicByteCount bytes,
-                                       Retransmission retransmission) {
+void QuicCongestionManager::SentPacket(
+    QuicPacketSequenceNumber sequence_number,
+    QuicTime sent_time,
+    QuicByteCount bytes,
+    Retransmission retransmission,
+    HasRetransmittableData has_retransmittable_data) {
   DCHECK(!ContainsKey(pending_packets_, sequence_number));
-  send_algorithm_->SentPacket(sent_time, sequence_number, bytes,
-                              retransmission);
 
-  packet_history_map_[sequence_number] =
-      new class SendAlgorithmInterface::SentPacket(bytes, sent_time);
-  pending_packets_[sequence_number] = bytes;
-  CleanupPacketHistory();
+  if (send_algorithm_->SentPacket(sent_time, sequence_number, bytes,
+                                  retransmission, has_retransmittable_data)) {
+    packet_history_map_[sequence_number] =
+        new class SendAlgorithmInterface::SentPacket(bytes, sent_time);
+    pending_packets_[sequence_number] = bytes;
+    CleanupPacketHistory();
+  }
 }
 
 // Called when a packet is timed out.
 void QuicCongestionManager::AbandoningPacket(
     QuicPacketSequenceNumber sequence_number) {
   PendingPacketsMap::iterator it = pending_packets_.find(sequence_number);
   if (it != pending_packets_.end()) {
     // Shouldn't this report loss as well? (decrease cgst window).
     send_algorithm_->AbandoningPacket(sequence_number, it->second);
     pending_packets_.erase(it);
@@ skipping 76 matching lines @@
 }
 
 const QuicTime::Delta QuicCongestionManager::rtt() {
   return current_rtt_;
 }
 
 const QuicTime::Delta QuicCongestionManager::DefaultRetransmissionTime() {
   return QuicTime::Delta::FromMilliseconds(kDefaultRetransmissionTimeMs);
 }
 
+// Ensures that the Delayed Ack timer is always set to a value lesser
+// than the retransmission timer's minimum value (MinRTO). We want the
+// delayed ack to get back to the QUIC peer before the sender's
+// retransmission timer triggers.  Since we do not know the
+// reverse-path one-way delay, we assume equal delays for forward and
+// reverse paths, and ensure that the timer is set to less than half
+// of the MinRTO.
+// There may be a value in making this delay adaptive with the help of
+// the sender and a signaling mechanism -- if the sender uses a
+// different MinRTO, we may get spurious retransmissions. May not have
+// any benefits, but if the delayed ack becomes a significant source
+// of (likely, tail) latency, then consider such a mechanism.
+
+const QuicTime::Delta QuicCongestionManager::DelayedAckTime() {
+  return QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs/2);
+}
+
 const QuicTime::Delta QuicCongestionManager::GetRetransmissionDelay(
     size_t unacked_packets_count,
     size_t number_retransmissions) {
   QuicTime::Delta retransmission_delay = send_algorithm_->RetransmissionDelay();
   if (retransmission_delay.IsZero()) {
     // We are in the initial state, use default timeout values.
     if (unacked_packets_count <= kTailDropWindowSize) {
       if (number_retransmissions <= kTailDropMaxRetransmissions) {
         return QuicTime::Delta::FromMilliseconds(kDefaultRetransmissionTimeMs);
       }
@@ skipping 36 matching lines @@
     if (now.Subtract(history_it->second->SendTimestamp()) <= kHistoryPeriod) {
       return;
     }
     delete history_it->second;
     packet_history_map_.erase(history_it);
     history_it = packet_history_map_.begin();
   }
 }
 
 }  // namespace net