Minor change to QUIC's retransmission to not link old retransmissions

net/quic/quic_unacked_packet_map.cc

 // Copyright 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/quic_unacked_packet_map.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_utils_chromium.h"
@@ skipping 77 matching lines @@
         *transmission_info->all_transmissions->begin();
     TransmissionInfo* old_info =
         &unacked_packets_[old_transmission - least_unacked_];
     // Don't remove old packets if they're still in flight.
     if (!old_info->in_flight) {
       old_info->all_transmissions->pop_front();
       // This will cause the packet be removed in RemoveObsoletePackets.
       old_info->all_transmissions = NULL;
     }
   }
-  if (transmission_info->all_transmissions == NULL) {
-    transmission_info->all_transmissions = new SequenceNumberList();
-    transmission_info->all_transmissions->push_back(old_sequence_number);
+  // Don't link old transmissions to new ones when version or
+  // encryption changes.
+  if (transmission_type == ALL_INITIAL_RETRANSMISSION ||
+      transmission_type == ALL_UNACKED_RETRANSMISSION) {
+    RemoveAckability(transmission_info);
+  } else {
+    if (transmission_info->all_transmissions == NULL) {
+      transmission_info->all_transmissions = new SequenceNumberList();
+      transmission_info->all_transmissions->push_back(old_sequence_number);
+    }
+    transmission_info->all_transmissions->push_back(new_sequence_number);
   }
-  transmission_info->all_transmissions->push_back(new_sequence_number);
   unacked_packets_.push_back(
       TransmissionInfo(frames,
                        transmission_info->sequence_number_length,
                        transmission_type,
                        transmission_info->all_transmissions));
+  RemoveObsoletePackets();
 }
 
 void QuicUnackedPacketMap::ClearAllPreviousRetransmissions() {
   while (!unacked_packets_.empty() && least_unacked_ < largest_observed_) {
     // If this packet is in flight, or has retransmittable data, then there is
     // no point in clearing out any further packets, because they would not
     // affect the high water mark.
     TransmissionInfo* info = &unacked_packets_.front();
     if (info->in_flight || info->retransmittable_frames != NULL) {
       break;
@@ skipping 54 matching lines @@
   for (SequenceNumberList::const_iterator it = all_transmissions->begin();
        it != all_transmissions->end(); ++it) {
     TransmissionInfo* transmission_info =
         &unacked_packets_[*it - least_unacked_];
     MaybeRemoveRetransmittableFrames(transmission_info);
     transmission_info->all_transmissions = NULL;
   }
   delete all_transmissions;
 }
 
+void QuicUnackedPacketMap::RemoveAckability(TransmissionInfo* info) {
+  DCHECK(info->retransmittable_frames == NULL);
+  info->is_unackable = true;
+  SequenceNumberList* all_transmissions = info->all_transmissions;
+  if (all_transmissions == NULL) {
+    return;
+  }
+  for (SequenceNumberList::const_iterator it = all_transmissions->begin();
+       it != all_transmissions->end(); ++it) {
+    TransmissionInfo* transmission_info =
+        &unacked_packets_[*it - least_unacked_];
+    transmission_info->all_transmissions = NULL;
+    transmission_info->is_unackable = true;
+  }
+  delete all_transmissions;
+}
+
 void QuicUnackedPacketMap::MaybeRemoveRetransmittableFrames(
     TransmissionInfo* transmission_info) {
   if (transmission_info->retransmittable_frames != NULL) {
     if (transmission_info->retransmittable_frames->HasCryptoHandshake()
             == IS_HANDSHAKE) {
       --pending_crypto_packet_count_;
     }
     delete transmission_info->retransmittable_frames;
     transmission_info->retransmittable_frames = NULL;
   }
@@ skipping 10 matching lines @@
     const TransmissionInfo& info) const {
   return sequence_number <= largest_observed_ &&
       !info.in_flight &&
       info.retransmittable_frames == NULL &&
       info.all_transmissions == NULL;
 }
 
 bool QuicUnackedPacketMap::IsPacketRemovable(
     QuicPacketSequenceNumber sequence_number,
     const TransmissionInfo& info) const {
-  return (sequence_number <= largest_observed_ ||
+  return (info.is_unackable ||
+          sequence_number <= largest_observed_ ||
           unacked_packets_.size() > kMaxTcpCongestionWindow) &&
       !info.in_flight &&
       info.retransmittable_frames == NULL &&
       info.all_transmissions == NULL;
 }
 
 bool QuicUnackedPacketMap::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   if (sequence_number < least_unacked_ ||
       sequence_number >= least_unacked_ + unacked_packets_.size()) {
@@ skipping 125 matching lines @@
   TransmissionInfo* info = &unacked_packets_[sequence_number - least_unacked_];
   DCHECK(!info->in_flight);
   DCHECK_NE(0u, info->bytes_sent);
   DCHECK(info->sent_time.IsInitialized());
 
   bytes_in_flight_ += info->bytes_sent;
   info->in_flight = true;
 }
 
 }  // namespace net