Land Recent QUIC Changes.

net/quic/congestion_control/time_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/congestion_control/time_loss_algorithm.h"
 
 #include "net/quic/quic_protocol.h"
 
 namespace net {
+namespace {
 
-namespace {
-// TCP retransmits after 3 nacks.
-static const size_t kNumberOfNacksBeforeRetransmission = 3;
-}
+// The minimum delay before a packet will be considered lost,
+// regardless of SRTT.  Half of the minimum TLP, since the loss algorithm only
+// triggers when a nack has been receieved for the packet.
+static const size_t kMinLossDelayMs = 5;
 
-TCPLossAlgorithm::TCPLossAlgorithm() { }
+// How many RTTs the algorithm waits before determining a packet is lost.
+static const double kLossDelayMultiplier = 1.25;
 
-// Uses nack counts to decide when packets are lost.
-SequenceNumberSet TCPLossAlgorithm::DetectLostPackets(
+}  // namespace
+
+TimeLossAlgorithm::TimeLossAlgorithm()
+    : loss_detection_timeout_(QuicTime::Zero()) { }
+
+SequenceNumberSet TimeLossAlgorithm::DetectLostPackets(
     const QuicUnackedPacketMap& unacked_packets,
     const QuicTime& time,
     QuicPacketSequenceNumber largest_observed,
-    QuicTime::Delta srtt) {
+    QuicTime::Delta srtt,
+    QuicTime::Delta latest_rtt) {
   SequenceNumberSet lost_packets;
+  loss_detection_timeout_ = QuicTime::Zero();
+  QuicTime::Delta loss_delay = QuicTime::Delta::Max(
+      QuicTime::Delta::FromMilliseconds(kMinLossDelayMs),
+      QuicTime::Delta::Max(srtt, latest_rtt).Multiply(kLossDelayMultiplier));
 
   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;
+    LOG_IF(DFATAL, it->second.nack_count == 0)
+        << "All packets less than largest observed should have been nacked.";
+
+    // Packets are sent in order, so break when we haven't waited long enough
+    // to lose any more packets and leave the loss_time_ set for the timeout.
+    QuicTime when_lost = it->second.sent_time.Add(loss_delay);
+    if (time < when_lost) {
+      loss_detection_timeout_ = when_lost;
+      break;
     }
-
-    if (it->second.nack_count < num_nacks_needed) {
-      continue;
-    }
-
     lost_packets.insert(it->first);
   }
 
   return lost_packets;
 }
 
+// loss_time_ is updated in DetectLostPackets, which must be called every time
+// an ack is received or the timeout expires.
+QuicTime TimeLossAlgorithm::GetLossTimeout() const {
+  return loss_detection_timeout_;
+}
+
 }  // namespace net