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 23 matching lines @@
 
 namespace net {
 
 QuicCongestionManager::QuicCongestionManager(
     const QuicClock* clock,
     CongestionFeedbackType type)
     : clock_(clock),
       receive_algorithm_(ReceiveAlgorithmInterface::Create(clock, type)),
       send_algorithm_(SendAlgorithmInterface::Create(clock, type)),
       largest_missing_(0),
-      current_rtt_(QuicTime::Delta::Infinite()) {
+      rtt_sample_(QuicTime::Delta::Infinite()) {
 }
 
 QuicCongestionManager::~QuicCongestionManager() {
   STLDeleteValues(&packet_history_map_);
 }
 
 void QuicCongestionManager::SetFromConfig(const QuicConfig& config,
                                           bool is_server) {
   if (config.initial_round_trip_time_us() > 0 &&
-      current_rtt_.IsInfinite()) {
+      rtt_sample_.IsInfinite()) {
     // The initial rtt should already be set on the client side.
     DLOG_IF(INFO, !is_server)
         << "Client did not set an initial RTT, but did negotiate one.";
-    current_rtt_ =
+    rtt_sample_ =
         QuicTime::Delta::FromMicroseconds(config.initial_round_trip_time_us());
   }
   send_algorithm_->SetFromConfig(config, is_server);
 }
 
 void QuicCongestionManager::OnPacketSent(
     QuicPacketSequenceNumber sequence_number,
     QuicTime sent_time,
     QuicByteCount bytes,
     TransmissionType transmission_type,
@@ skipping 27 matching lines @@
       frame, feedback_receive_time, packet_history_map_);
 }
 
 void QuicCongestionManager::OnIncomingAckFrame(const QuicAckFrame& frame,
                                                QuicTime ack_receive_time) {
   // We calculate the RTT based on the highest ACKed sequence number, the lower
   // sequence numbers will include the ACK aggregation delay.
   SendAlgorithmInterface::SentPacketsMap::iterator history_it =
       packet_history_map_.find(frame.received_info.largest_observed);
   // TODO(satyamshekhar): largest_observed might be missing.
-  if (history_it != packet_history_map_.end() &&
-      !frame.received_info.delta_time_largest_observed.IsInfinite()) {
+  if (history_it != packet_history_map_.end()) {
     QuicTime::Delta send_delta = ack_receive_time.Subtract(
         history_it->second->SendTimestamp());
     if (send_delta > frame.received_info.delta_time_largest_observed) {
-      current_rtt_ = send_delta.Subtract(
+      rtt_sample_ = send_delta.Subtract(
           frame.received_info.delta_time_largest_observed);
+    } else if (rtt_sample_.IsInfinite()) {
+      // Even though we received information from the peer suggesting
+      // an invalid (negative) RTT, we can use the send delta as an
+      // approximation until we get a better estimate.
+      rtt_sample_ = send_delta;
     }
   }
   // We want to.
   // * Get all packets lower(including) than largest_observed
   //   from pending_packets_.
   // * Remove all missing packets.
   // * Send each ACK in the list to send_algorithm_.
   PendingPacketsMap::iterator it, it_upper;
   it = pending_packets_.begin();
   it_upper = pending_packets_.upper_bound(frame.received_info.largest_observed);
 
   bool new_packet_loss_reported = false;
   while (it != it_upper) {
     QuicPacketSequenceNumber sequence_number = it->first;
     if (!IsAwaitingPacket(frame.received_info, sequence_number)) {
       // Not missing, hence implicitly acked.
-      send_algorithm_->OnIncomingAck(sequence_number, it->second, current_rtt_);
+      send_algorithm_->OnIncomingAck(sequence_number, it->second, rtt_sample_);
       pending_packets_.erase(it++);  // Must be incremented post to work.
     } else {
       if (sequence_number > largest_missing_) {
         // We have a new loss reported.
         new_packet_loss_reported = true;
         largest_missing_ = sequence_number;
       }
       ++it;
     }
   }
@@ skipping 24 matching lines @@
 
 void QuicCongestionManager::RecordIncomingPacket(
     QuicByteCount bytes,
     QuicPacketSequenceNumber sequence_number,
     QuicTime timestamp,
     bool revived) {
   receive_algorithm_->RecordIncomingPacket(bytes, sequence_number, timestamp,
                                            revived);
 }
 
-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) const {
+  if (unacked_packets_count <= kTailDropWindowSize) {
+    // Avoid exponential backoff of RTO when there are only a few packets
+    // outstanding.  This helps avoid the situation where fake packet loss
+    // causes a packet and it's retransmission to be dropped causing
+    // test timouts.
+    if (number_retransmissions <= kTailDropMaxRetransmissions) {
+      number_retransmissions = 0;
+    } else {
+      number_retransmissions -= kTailDropMaxRetransmissions;
+    }
+  }
+
   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);
-      }
-      number_retransmissions -= kTailDropMaxRetransmissions;
-    }
     retransmission_delay =
         QuicTime::Delta::FromMilliseconds(kDefaultRetransmissionTimeMs);
   }
   // Calculate exponential back off.
   retransmission_delay = QuicTime::Delta::FromMilliseconds(
       retransmission_delay.ToMilliseconds() * static_cast<size_t>(
           (1 << min<size_t>(number_retransmissions, kMaxRetransmissions))));
 
   // TODO(rch): This code should move to |send_algorithm_|.
   if (retransmission_delay.ToMilliseconds() < kMinRetransmissionTimeMs) {
@@ skipping 32 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