Implement an early retransmit timer in QUIC's TcpLossAlgorithm to

net/quic/congestion_control/tcp_loss_algorithm.cc

 // Copyright (c) 2014 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_loss_algorithm.h"
 
 #include "net/quic/quic_protocol.h"
 
 namespace net {
 
 namespace {
+
 // TCP retransmits after 3 nacks.
 static const size_t kNumberOfNacksBeforeRetransmission = 3;
+
+// How many RTTs the algorithm waits before determining a packet is lost due
+// to early retransmission.
+static const double kEarlyRetransmitLossDelayMultiplier = 1.25;
+
 }
 
-TCPLossAlgorithm::TCPLossAlgorithm() { }
+TCPLossAlgorithm::TCPLossAlgorithm()
+    : loss_detection_timeout_(QuicTime::Zero()) { }
 
 // Uses nack counts to decide when packets are lost.
 SequenceNumberSet TCPLossAlgorithm::DetectLostPackets(
     const QuicUnackedPacketMap& unacked_packets,
     const QuicTime& time,
     QuicPacketSequenceNumber largest_observed,
     QuicTime::Delta srtt,
     QuicTime::Delta latest_rtt) {
   SequenceNumberSet lost_packets;
+  loss_detection_timeout_ = QuicTime::Zero();
+  QuicTime::Delta loss_delay =
+      srtt.Multiply(kEarlyRetransmitLossDelayMultiplier);
 
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets.begin();
        it != unacked_packets.end() && it->first <= largest_observed; ++it) {
     if (!it->second.pending) {
       continue;
     }
-    size_t num_nacks_needed = kNumberOfNacksBeforeRetransmission;
-    // Check for early retransmit(RFC5827) when the last packet gets acked and
-    // the there are fewer than 4 pending packets.
-    // TODO(ianswett): Set a retransmission timer instead of losing the packet
-    // and retransmitting immediately.
-    if (it->second.retransmittable_frames &&
-        unacked_packets.largest_sent_packet() == largest_observed) {
-      num_nacks_needed = largest_observed - it->first;
-    }
 
-    if (it->second.nack_count < num_nacks_needed) {
+    LOG_IF(DFATAL, it->second.nack_count == 0)
+        << "All packets less than largest observed should have been nacked.";
+    if (it->second.nack_count >= kNumberOfNacksBeforeRetransmission) {
+      lost_packets.insert(it->first);
       continue;
     }
 
-    lost_packets.insert(it->first);
+    // Only early retransmit(RFC5827) when the last packet gets acked and
+    // there are pending retransmittable packets.
+    // This also implements a timer-protected variant of FACK.
+    if (it->second.retransmittable_frames &&
+        unacked_packets.largest_sent_packet() == largest_observed) {
+      // Early retransmit marks the packet as lost once 1.25RTTs have passed
+      // since the packet was sent and otherwise sets an alarm.
+      if (time >= it->second.sent_time.Add(loss_delay)) {
+        lost_packets.insert(it->first);
+      } else {
+        // Set the timeout for the earliest retransmittable packet where early
+        // retransmit applies.
+        loss_detection_timeout_ = it->second.sent_time.Add(loss_delay);
+        break;
+      }
+    }
   }
 
   return lost_packets;
 }
 
 QuicTime TCPLossAlgorithm::GetLossTimeout() const {
-  return QuicTime::Zero();
+  return loss_detection_timeout_;
 }
 
 }  // namespace net