Correctly handle NACK-based "retransmission" of packets which no longer

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 400 matching lines @@
         unacked_packets_.find(newest_transmission);
     if (HasCryptoHandshake(newest_it->second)) {
       --pending_crypto_packet_count_;
     }
     // If we have received an ack for a previous transmission of a packet,
     // we want to keep the "new" transmission of the packet unacked,
     // but prevent the data from being retransmitted.
     delete newest_it->second.retransmittable_frames;
     newest_it->second.retransmittable_frames = NULL;
     newest_it->second.previous_transmissions = NULL;
-    pending_retransmissions_.erase(newest_transmission);
   }
 
   // Clear out information all previous transmissions.
   ++previous_transmissions_it;
   while (previous_transmissions_it != previous_transmissions->rend()) {
     QuicPacketSequenceNumber previous_transmission = *previous_transmissions_it;
     ++previous_transmissions_it;
     // If the packet was TLP retransmitted, the old copy was not yet considered
     // lost or abandoned, so do that now.
     if (ContainsKey(pending_packets_, previous_transmission)) {
       send_algorithm_->OnPacketLost(previous_transmission, clock_->Now());
       OnPacketAbandoned(previous_transmission);
     }
     DiscardPacket(previous_transmission);
   }
 
   delete previous_transmissions;
 
+  if (ContainsKey(pending_retransmissions_, newest_transmission)) {
+    pending_retransmissions_.erase(newest_transmission);
+    if (!ContainsKey(pending_packets_, newest_transmission))  {
+      // If the newest transmission has already been marked for retransmission
+      // and has already been abandoned, then we should remove it from
+      // unacked_packets_, as well as cancel the retransmission.
+      DCHECK(ContainsKey(unacked_packets_, newest_transmission));
+      DCHECK(!unacked_packets_[newest_transmission].previous_transmissions);
+      unacked_packets_.erase(newest_transmission);
+    }
+  }
+
   UnackedPacketMap::iterator next_unacked = unacked_packets_.begin();
   while (next_unacked != unacked_packets_.end() &&
          next_unacked->first < sequence_number) {
     ++next_unacked;
   }
   return next_unacked;
 }
 
 void QuicSentPacketManager::DiscardPacket(
     QuicPacketSequenceNumber sequence_number) {
@@ skipping 283 matching lines @@
     // If the number of retransmissions has maxed out, don't lose or retransmit
     // any more packets.
     if (num_retransmitted >= kMaxRetransmissionsPerAck) {
       ++it;
       continue;
     }
 
     lost_packets.insert(sequence_number);
     if (transmission_info.retransmittable_frames) {
       ++num_retransmitted;
-      MarkForRetransmission(*it, NACK_RETRANSMISSION);
+      MarkForRetransmission(sequence_number, NACK_RETRANSMISSION);
+    } else {
+      // Since we will not retransmit this, we need to remove it from
+      // unacked_packets_.   This is either the current transmission of
+      // a packet whose previous transmission has been acked, or it
+      // is a packet that has been TLP retransmitted.
+      RemovePreviousTransmission(sequence_number);
+      unacked_packets_.erase(sequence_number);
     }
 
     ++it;
   }
   // Abandon packets after the loop over pending packets, because otherwise it
   // changes the early retransmit logic and iteration.
   for (SequenceNumberSet::const_iterator it = lost_packets.begin();
        it != lost_packets.end(); ++it) {
     // TODO(ianswett): OnPacketLost is also called from TCPCubicSender when
     // an FEC packet is lost, but FEC loss information should be shared among
     // congestion managers.  Additionally, if it's expected the FEC packet may
     // repair the loss, it should be recorded as a loss to the congestion
     // manager, but not retransmitted until it's known whether the FEC packet
     // arrived.
-    send_algorithm_->OnPacketLost(*it, ack_receive_time);
-    OnPacketAbandoned(*it);
+    QuicPacketSequenceNumber lost_packet = *it;
+    send_algorithm_->OnPacketLost(lost_packet, ack_receive_time);
+    OnPacketAbandoned(lost_packet);
   }
 }
 
 void QuicSentPacketManager::MaybeUpdateRTT(
     const ReceivedPacketInfo& received_info,
     const 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(received_info.largest_observed);
@@ skipping 160 matching lines @@
   if (using_pacing_) {
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
+void QuicSentPacketManager::RemovePreviousTransmission(
+    QuicPacketSequenceNumber sequence_number) {
+  SequenceNumberSet* previous_transmissions =
+      unacked_packets_[sequence_number].previous_transmissions;
+  if (!previous_transmissions) {
+    return;
+  }
+  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