Land Recent QUIC Changes.

net/quic/quic_sent_packet_manager.cc

 // Copyright 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/quic_sent_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/quic_ack_notifier_manager.h"
@@ skipping 86 matching lines @@
 }
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.initial_round_trip_time_us() > 0 &&
       rtt_sample_.IsInfinite()) {
     // The initial rtt should already be set on the client side.
     DVLOG_IF(1, !is_server_)
         << "Client did not set an initial RTT, but did negotiate one.";
     rtt_sample_ =
         QuicTime::Delta::FromMicroseconds(config.initial_round_trip_time_us());
+    send_algorithm_->UpdateRtt(rtt_sample_);
   }
   if (config.congestion_control() == kPACE) {
     MaybeEnablePacing();
   }
   send_algorithm_->SetFromConfig(config, is_server_);
 }
 
 void QuicSentPacketManager::SetMaxPacketSize(QuicByteCount max_packet_size) {
   send_algorithm_->SetMaxPacketSize(max_packet_size);
 }
@@ skipping 57 matching lines @@
   }
   previous_transmissions->insert(new_sequence_number);
   unacked_packets_[new_sequence_number].previous_transmissions =
       previous_transmissions;
 
   DCHECK(HasRetransmittableFrames(new_sequence_number));
 }
 
 bool QuicSentPacketManager::OnIncomingAck(
     const ReceivedPacketInfo& received_info, QuicTime ack_receive_time) {
-  // Determine if the least unacked sequence number is being acked.
-  QuicPacketSequenceNumber least_unacked_sent_before =
-      GetLeastUnackedSentPacket();
-  // TODO(ianswett): Consider a non-TCP metric for determining the connection
-  // is making progress, since QUIC has out of order delivery.
-  bool new_least_unacked = !IsAwaitingPacket(received_info,
-                                             least_unacked_sent_before);
-
+  // We rely on delta_time_largest_observed to compute an RTT estimate, so
+  // we only update rtt when the largest observed gets acked.
+  bool largest_observed_acked =
+      ContainsKey(unacked_packets_, received_info.largest_observed);
   MaybeUpdateRTT(received_info, ack_receive_time);
   HandleAckForSentPackets(received_info);
   MaybeRetransmitOnAckFrame(received_info, ack_receive_time);
 
-  if (new_least_unacked) {
+  // Anytime we are making forward progress and have a new RTT estimate, reset
+  // the backoff counters.
+  if (largest_observed_acked) {
     // Reset all retransmit counters any time a new packet is acked.
     consecutive_rto_count_ = 0;
     consecutive_tlp_count_ = 0;
     consecutive_crypto_retransmission_count_ = 0;
   }
 
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
   return true;
 }
@@ skipping 90 matching lines @@
 void QuicSentPacketManager::RetransmitUnackedPackets(
     RetransmissionType retransmission_type) {
   if (unacked_packets_.empty()) {
     return;
   }
 
   for (UnackedPacketMap::iterator unacked_it = unacked_packets_.begin();
        unacked_it != unacked_packets_.end(); ++unacked_it) {
     const RetransmittableFrames* frames =
         unacked_it->second.retransmittable_frames;
-    if (frames == NULL) {
-      continue;
-    }
     if (retransmission_type == ALL_PACKETS ||
-        frames->encryption_level() == ENCRYPTION_INITIAL) {
-      // TODO(satyamshekhar): Think about congestion control here.
-      // Specifically, about the retransmission count of packets being sent
-      // proactively to achieve 0 (minimal) RTT.
-      if (unacked_it->second.retransmittable_frames) {
+        (frames != NULL && frames->encryption_level() == ENCRYPTION_INITIAL)) {
+      if (frames) {
         OnPacketAbandoned(unacked_it);
         MarkForRetransmission(unacked_it->first, NACK_RETRANSMISSION);
       } else {
         DiscardUnackedPacket(unacked_it->first);
       }
     }
   }
 }
 
 void QuicSentPacketManager::MarkForRetransmission(
@@ skipping 65 matching lines @@
 QuicSentPacketManager::UnackedPacketMap::iterator
 QuicSentPacketManager::MarkPacketHandled(
     QuicPacketSequenceNumber sequence_number, ReceivedByPeer received_by_peer) {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
 
   // If this packet is pending, remove it and inform the send algorithm.
   UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
   if (it->second.pending) {
     size_t bytes_sent = packet_history_map_[sequence_number]->bytes_sent();
     if (received_by_peer == RECEIVED_BY_PEER) {
-      send_algorithm_->OnPacketAcked(sequence_number, bytes_sent, rtt_sample_);
+      send_algorithm_->OnPacketAcked(sequence_number, bytes_sent);
     } else {
       // It's been abandoned.
       send_algorithm_->OnPacketAbandoned(sequence_number, bytes_sent);
     }
     it->second.pending = false;
   }
 
   // If this packet has never been retransmitted, then simply drop it.
   if (it->second.previous_transmissions == NULL) {
     ++it;
@@ skipping 131 matching lines @@
   return unacked_packets;
 }
 
 bool QuicSentPacketManager::OnPacketSent(
     QuicPacketSequenceNumber sequence_number,
     QuicTime sent_time,
     QuicByteCount bytes,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   DCHECK_LT(0u, sequence_number);
-  // In some edge cases, on some platforms (such as Windows), it is possible
-  // that we were write-blocked when we tried to send a packet, and then decided
-  // not to send the packet (such as when the encryption key changes, and we
-  // "discard" the unsent packet).  In that rare case, we may indeed
-  // asynchronously (later) send the packet, calling this method, but the
-  // sequence number may already be erased from unacked_packets_ map. In that
-  // case, we can just return false since the packet will not be tracked for
-  // retransmission.
-  if (!ContainsKey(unacked_packets_, sequence_number))
+  UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
+  // In rare circumstances, the packet could be serialized, sent, and then acked
+  // before OnPacketSent is called.
+  if (it == unacked_packets_.end()) {
     return false;
-  DCHECK(!unacked_packets_[sequence_number].pending);
-  UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
+  }
+  DCHECK(!it->second.pending);
 
   // Only track packets the send algorithm wants us to track.
   if (!send_algorithm_->OnPacketSent(sent_time, sequence_number, bytes,
                                      transmission_type,
                                      has_retransmittable_data)) {
     DCHECK(it->second.retransmittable_frames == NULL);
     unacked_packets_.erase(it);
     // Do not reset the retransmission timer, since the packet isn't tracked.
     return false;
   }
@@ skipping 223 matching lines @@
   // sequence numbers will include the ACK aggregation delay.
   UnackedPacketMap::iterator unacked_it =
       unacked_packets_.find(received_info.largest_observed);
   if (unacked_it == unacked_packets_.end()) {
     return;
   }
   const TransmissionInfo* transmission_info = &unacked_it->second;
   if (transmission_info == NULL) {
     return;
   }
+  // Don't update the RTT if it hasn't been sent.
+  if (transmission_info->sent_time == QuicTime::Zero()) {
+    return;
+  }
 
   QuicTime::Delta send_delta =
       ack_receive_time.Subtract(transmission_info->sent_time);
   if (send_delta > received_info.delta_time_largest_observed) {
     rtt_sample_ = send_delta.Subtract(
         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;
   }
+  send_algorithm_->UpdateRtt(rtt_sample_);
 }
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(
     QuicTime now,
     TransmissionType transmission_type,
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
   return send_algorithm_->TimeUntilSend(now, transmission_type, retransmittable,
                                         handshake);
 }
@@ skipping 167 matching lines @@
   }
   previous_transmissions->erase(sequence_number);
   if (previous_transmissions->size() == 1) {
     QuicPacketSequenceNumber current = *previous_transmissions->begin();
     unacked_packets_[current].previous_transmissions = NULL;
     delete previous_transmissions;
   }
 }
 
 }  // namespace net