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 94 matching lines @@
     MaybeEnablePacing();
   }
   send_algorithm_->SetFromConfig(config, is_server_);
 }
 
 void QuicSentPacketManager::SetMaxPacketSize(QuicByteCount max_packet_size) {
   send_algorithm_->SetMaxPacketSize(max_packet_size);
 }
 
 void QuicSentPacketManager::OnSerializedPacket(
-    const SerializedPacket& serialized_packet, QuicTime serialized_time) {
-  if (serialized_packet.packet->is_fec_packet()) {
-    DCHECK(!serialized_packet.retransmittable_frames);
-    unacked_fec_packets_.insert(make_pair(
-        serialized_packet.sequence_number, serialized_time));
-    return;
-  }
-
-  if (serialized_packet.retransmittable_frames == NULL) {
+    const SerializedPacket& serialized_packet) {
+  if (serialized_packet.retransmittable_frames == NULL &&
+      !serialized_packet.packet->is_fec_packet()) {
     // Don't track ack/congestion feedback packets.
     return;
   }
 
   ack_notifier_manager_.OnSerializedPacket(serialized_packet);
 
   DCHECK(unacked_packets_.empty() ||
          unacked_packets_.rbegin()->first < serialized_packet.sequence_number);
   unacked_packets_[serialized_packet.sequence_number] =
       TransmissionInfo(serialized_packet.retransmittable_frames,
@@ skipping 42 matching lines @@
   previous_transmissions->insert(new_sequence_number);
   previous_transmissions_map_[new_sequence_number] = 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 =
-      min(GetLeastUnackedSentPacket(), GetLeastUnackedFecPacket());
+      GetLeastUnackedSentPacket();
   bool new_least_unacked = !IsAwaitingPacket(received_info,
                                              least_unacked_sent_before);
 
   HandleAckForSentPackets(received_info);
-  HandleAckForSentFecPackets(received_info);
 
   SequenceNumberSet retransmission_packets =
       OnIncomingAckFrame(received_info, ack_receive_time);
 
   for (SequenceNumberSet::const_iterator it = retransmission_packets.begin();
        it != retransmission_packets.end(); ++it) {
     DCHECK(!ContainsKey(pending_packets_, *it));
     MarkForRetransmission(*it, NACK_RETRANSMISSION);
   }
 
@@ skipping 237 matching lines @@
     return;
   }
 
   // Delete the retransmittable frames.
   delete unacked_it->second.retransmittable_frames;
   unacked_packets_.erase(unacked_it);
   pending_retransmissions_.erase(sequence_number);
   return;
 }
 
-void QuicSentPacketManager::HandleAckForSentFecPackets(
-    const ReceivedPacketInfo& received_info) {
-  UnackedFecPacketMap::iterator it = unacked_fec_packets_.begin();
-  while (it != unacked_fec_packets_.end()) {
-    QuicPacketSequenceNumber sequence_number = it->first;
-    if (sequence_number > received_info.largest_observed) {
-      break;
-    }
-
-    if (!IsAwaitingPacket(received_info, sequence_number)) {
-      DVLOG(1) << ENDPOINT << "Got an ack for fec packet: " << sequence_number;
-      unacked_fec_packets_.erase(it++);
-    } else {
-      // TODO(rch): treat these packets more consistently.  They should
-      // be subject to NACK and RTO based loss.  (Thought obviously, they
-      // should not be retransmitted.)
-      DVLOG(1) << ENDPOINT << "Still missing ack for fec packet: "
-               << sequence_number;
-      ++it;
-    }
-  }
-}
-
-void QuicSentPacketManager::DiscardFecPacket(
-    QuicPacketSequenceNumber sequence_number) {
-  DCHECK(ContainsKey(unacked_fec_packets_, sequence_number));
-  unacked_fec_packets_.erase(sequence_number);
-}
-
 bool QuicSentPacketManager::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   return ContainsKey(unacked_packets_, sequence_number);
 }
 
 QuicSequenceNumberLength QuicSentPacketManager::GetSequenceNumberLength(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
 
   return unacked_packets_.find(sequence_number)->second.sequence_number_length;
 }
 
-QuicTime QuicSentPacketManager::GetFecSentTime(
-    QuicPacketSequenceNumber sequence_number) const {
-  DCHECK(ContainsKey(unacked_fec_packets_, sequence_number));
-
-  return unacked_fec_packets_.find(sequence_number)->second;
-}
-
 bool QuicSentPacketManager::HasUnackedPackets() const {
   return !unacked_packets_.empty();
 }
 
 size_t QuicSentPacketManager::GetNumRetransmittablePackets() const {
   size_t num_unacked_packets = 0;
   for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     QuicPacketSequenceNumber sequence_number = it->first;
     if (HasRetransmittableFrames(sequence_number)) {
       ++num_unacked_packets;
     }
   }
   return num_unacked_packets;
 }
 
-bool QuicSentPacketManager::HasUnackedFecPackets() const {
-  return !unacked_fec_packets_.empty();
-}
-
 QuicPacketSequenceNumber
 QuicSentPacketManager::GetLeastUnackedSentPacket() const {
   if (unacked_packets_.empty()) {
     // If there are no unacked packets, set the least unacked packet to
     // the sequence number of the next packet sent.
     return helper_->GetNextPacketSequenceNumber();
   }
 
   return unacked_packets_.begin()->first;
 }
 
-QuicPacketSequenceNumber
-QuicSentPacketManager::GetLeastUnackedFecPacket() const {
-  if (unacked_fec_packets_.empty()) {
-    // If there are no unacked packets, set the least unacked packet to
-    // the sequence number of the next packet sent.
-    return helper_->GetNextPacketSequenceNumber();
-  }
-
-  return unacked_fec_packets_.begin()->first;
-}
-
 SequenceNumberSet QuicSentPacketManager::GetUnackedPackets() const {
   SequenceNumberSet unacked_packets;
   for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     unacked_packets.insert(it->first);
   }
   return unacked_packets;
 }
 
 void QuicSentPacketManager::OnPacketSent(
     QuicPacketSequenceNumber sequence_number,
     QuicTime sent_time,
     QuicByteCount bytes,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   DCHECK_LT(0u, sequence_number);
   DCHECK(!ContainsKey(pending_packets_, sequence_number));
+  if (ContainsKey(unacked_packets_, sequence_number)) {
+    unacked_packets_[sequence_number].sent_time = sent_time;
+  }
 
   // Only track packets the send algorithm wants us to track.
   if (!send_algorithm_->OnPacketSent(sent_time, sequence_number, bytes,
                                      transmission_type,
                                      has_retransmittable_data)) {
     return;
   }
   packet_history_map_[sequence_number] = new SendAlgorithmInterface::SentPacket(
       bytes, sent_time, has_retransmittable_data);
   pending_packets_.insert(sequence_number);
   CleanupPacketHistory();
 }
 
 void QuicSentPacketManager::OnRetransmissionTimeout() {
-  ++consecutive_rto_count_;
-  send_algorithm_->OnRetransmissionTimeout();
   // Abandon all pending packets to ensure the congestion window
   // opens up before we attempt to retransmit packets.
-  for (SequenceNumberSet::const_iterator it = pending_packets_.begin();
-       it != pending_packets_.end(); ++it) {
+  QuicTime::Delta retransmission_delay = GetRetransmissionDelay();
+  QuicTime max_send_time =
+      clock_->ApproximateNow().Subtract(retransmission_delay);
+  for (SequenceNumberSet::iterator it = pending_packets_.begin();
+       it != pending_packets_.end();) {
     QuicPacketSequenceNumber sequence_number = *it;
     DCHECK(ContainsKey(packet_history_map_, sequence_number));
-    send_algorithm_->OnPacketAbandoned(
-        sequence_number, packet_history_map_[sequence_number]->bytes_sent());
+    DCHECK(ContainsKey(unacked_packets_, sequence_number));
+    const TransmissionInfo& transmission_info =
+        unacked_packets_.find(sequence_number)->second;
+    // Abandon retransmittable packet and old non-retransmittable packets.
+    if (transmission_info.retransmittable_frames ||
+        transmission_info.sent_time <= max_send_time) {
+      pending_packets_.erase(it++);
+      send_algorithm_->OnPacketAbandoned(
+          sequence_number, packet_history_map_[sequence_number]->bytes_sent());
+    } else {
+      ++it;
+    }
   }
-  pending_packets_.clear();
 
   // Attempt to send all the unacked packets when the RTO fires, let the
   // congestion manager decide how many to send immediately and the remaining
   // packets will be queued for future sending.
   DVLOG(1) << "OnRetransmissionTimeout() fired with "
            << unacked_packets_.size() << " unacked packets.";
 
   // Retransmit any packet with retransmittable frames.
+  bool packets_retransmitted = false;
   for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     if (it->second.retransmittable_frames != NULL) {
+      packets_retransmitted = true;
       MarkForRetransmission(it->first, RTO_RETRANSMISSION);
     }
   }
-}
 
-QuicTime QuicSentPacketManager::OnAbandonFecTimeout() {
-  // Abandon all the FEC packets older than the current RTO, then reschedule
-  // the alarm if there are more pending fec packets.
-  QuicTime::Delta retransmission_delay = GetRetransmissionDelay();
-  QuicTime max_send_time =
-      clock_->ApproximateNow().Subtract(retransmission_delay);
-  while (HasUnackedFecPackets()) {
-    QuicPacketSequenceNumber oldest_unacked_fec = GetLeastUnackedFecPacket();
-    QuicTime fec_sent_time = GetFecSentTime(oldest_unacked_fec);
-    if (fec_sent_time > max_send_time) {
-      return fec_sent_time.Add(retransmission_delay);
-    }
-    DiscardFecPacket(oldest_unacked_fec);
-    OnPacketAbandoned(oldest_unacked_fec);
+  // Only inform the sent packet manager of an RTO if data was retransmitted.
+  if (packets_retransmitted) {
+    ++consecutive_rto_count_;
+    send_algorithm_->OnRetransmissionTimeout();
   }
-
-  return QuicTime::Zero();
 }
 
 void QuicSentPacketManager::OnPacketAbandoned(
     QuicPacketSequenceNumber sequence_number) {
   SequenceNumberSet::iterator it = pending_packets_.find(sequence_number);
   if (it != pending_packets_.end()) {
     DCHECK(ContainsKey(packet_history_map_, sequence_number));
     send_algorithm_->OnPacketAbandoned(
         sequence_number, packet_history_map_[sequence_number]->bytes_sent());
     pending_packets_.erase(it);
@@ skipping 119 matching lines @@
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(
     QuicTime now,
     TransmissionType transmission_type,
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
   return send_algorithm_->TimeUntilSend(now, transmission_type, retransmittable,
                                         handshake);
 }
 
-const QuicTime::Delta QuicSentPacketManager::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
@@ skipping 85 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net