Deprecate FLAGS_quic_track_single_retransmission.

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_bug_tracker.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/quic_utils_chromium.h"
 
 using std::max;
 
 namespace net {
 
 QuicUnackedPacketMap::QuicUnackedPacketMap()
     : largest_sent_packet_(0),
       largest_observed_(0),
       least_unacked_(1),
       bytes_in_flight_(0),
-      pending_crypto_packet_count_(0),
-      track_single_retransmission_(FLAGS_quic_track_single_retransmission) {}
+      pending_crypto_packet_count_(0) {}
 
 QuicUnackedPacketMap::~QuicUnackedPacketMap() {
   QuicPacketNumber index = least_unacked_;
   for (UnackedPacketMap::iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it, ++index) {
     QuicUtils::DeleteFrames(&it->retransmittable_frames);
-    // Only delete all_transmissions once, for the newest packet.
-    if (it->all_transmissions != nullptr &&
-        index == *it->all_transmissions->rbegin()) {
-      delete it->all_transmissions;
-    }
   }
 }
 
 void QuicUnackedPacketMap::AddSentPacket(SerializedPacket* packet,
                                          QuicPacketNumber old_packet_number,
                                          TransmissionType transmission_type,
                                          QuicTime sent_time,
                                          QuicByteCount bytes_sent,
                                          bool set_in_flight) {
   QuicPacketNumber packet_number = packet->packet_number;
@@ skipping 75 matching lines @@
   info->has_crypto_handshake = transmission_info->has_crypto_handshake;
   transmission_info->has_crypto_handshake = false;
   info->needs_padding = transmission_info->needs_padding;
 
   // Transfer the AckListeners if any are present.
   info->ack_listeners.swap(transmission_info->ack_listeners);
   QUIC_BUG_IF(frames == nullptr)
       << "Attempt to retransmit packet with no "
       << "retransmittable frames: " << old_packet_number;
 
-  // Only keep one transmission older than largest observed, because only the
-  // most recent is expected to possibly be a spurious retransmission.
-  if (!track_single_retransmission_) {
-    while (transmission_info->all_transmissions != nullptr &&
-           transmission_info->all_transmissions->size() > 1 &&
-           *(++transmission_info->all_transmissions->begin()) <
-               largest_observed_) {
-      QuicPacketNumber old_transmission =
-          *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) {
-        break;
-      }
-      old_info->all_transmissions->pop_front();
-      // This will cause the packet be removed in RemoveObsoletePackets.
-      old_info->all_transmissions = nullptr;
-    }
-  }
   // 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 (track_single_retransmission_) {
-      transmission_info->retransmission = new_packet_number;
-    } else {
-      if (transmission_info->all_transmissions == nullptr) {
-        transmission_info->all_transmissions = new PacketNumberList();
-        transmission_info->all_transmissions->push_back(old_packet_number);
-      }
-      transmission_info->all_transmissions->push_back(new_packet_number);
-    }
-  }
-  if (!track_single_retransmission_) {
-    info->all_transmissions = transmission_info->all_transmissions;
+    transmission_info->retransmission = new_packet_number;
   }
   // Proactively remove obsolete packets so the least unacked can be raised.
   RemoveObsoletePackets();
 }
 
 bool QuicUnackedPacketMap::HasRetransmittableFrames(
     QuicPacketNumber packet_number) const {
   DCHECK_GE(packet_number, least_unacked_);
   DCHECK_LT(packet_number, least_unacked_ + unacked_packets_.size());
   return !unacked_packets_[packet_number - least_unacked_]
               .retransmittable_frames.empty();
 }
 
 void QuicUnackedPacketMap::NackPacket(QuicPacketNumber packet_number,
                                       uint16_t min_nacks) {
   DCHECK_GE(packet_number, least_unacked_);
   DCHECK_LT(packet_number, least_unacked_ + unacked_packets_.size());
   unacked_packets_[packet_number - least_unacked_].nack_count = max(
       min_nacks, unacked_packets_[packet_number - least_unacked_].nack_count);
 }
 
 void QuicUnackedPacketMap::RemoveRetransmittability(TransmissionInfo* info) {
-  if (track_single_retransmission_) {
-    while (info->retransmission != 0) {
-      const QuicPacketNumber retransmission = info->retransmission;
-      info->retransmission = 0;
-      info = &unacked_packets_[retransmission - least_unacked_];
-    }
-    MaybeRemoveRetransmittableFrames(info);
-    return;
+  while (info->retransmission != 0) {
+    const QuicPacketNumber retransmission = info->retransmission;
+    info->retransmission = 0;
+    info = &unacked_packets_[retransmission - least_unacked_];
   }
-  PacketNumberList* all_transmissions = info->all_transmissions;
-  if (all_transmissions == nullptr) {
-    MaybeRemoveRetransmittableFrames(info);
-    return;
-  }
-  // TODO(ianswett): Consider adding a check to ensure there are retransmittable
-  // frames associated with this packet.
-  for (QuicPacketNumber packet_number : *all_transmissions) {
-    TransmissionInfo* transmission_info =
-        &unacked_packets_[packet_number - least_unacked_];
-    MaybeRemoveRetransmittableFrames(transmission_info);
-    transmission_info->all_transmissions = nullptr;
-  }
-  delete all_transmissions;
+  MaybeRemoveRetransmittableFrames(info);
 }
 
 void QuicUnackedPacketMap::RemoveRetransmittability(
     QuicPacketNumber packet_number) {
   DCHECK_GE(packet_number, least_unacked_);
   DCHECK_LT(packet_number, least_unacked_ + unacked_packets_.size());
   TransmissionInfo* info = &unacked_packets_[packet_number - least_unacked_];
   RemoveRetransmittability(info);
 }
 
 void QuicUnackedPacketMap::RemoveAckability(TransmissionInfo* info) {
   DCHECK(info->retransmittable_frames.empty());
+  DCHECK_EQ(0u, info->retransmission);
   info->is_unackable = true;
-  if (track_single_retransmission_) {
-    DCHECK_EQ(0u, info->retransmission);
-    return;
-  }
-  PacketNumberList* all_transmissions = info->all_transmissions;
-  if (all_transmissions == nullptr) {
-    return;
-  }
-  for (QuicPacketNumber packet_number : *all_transmissions) {
-    TransmissionInfo* transmission_info =
-        &unacked_packets_[packet_number - least_unacked_];
-    transmission_info->all_transmissions = nullptr;
-    transmission_info->is_unackable = true;
-  }
-  delete all_transmissions;
 }
 
 void QuicUnackedPacketMap::MaybeRemoveRetransmittableFrames(
     TransmissionInfo* transmission_info) {
   if (transmission_info->has_crypto_handshake) {
     DCHECK(!transmission_info->retransmittable_frames.empty());
     DCHECK_LT(0u, pending_crypto_packet_count_);
     --pending_crypto_packet_count_;
     transmission_info->has_crypto_handshake = false;
   }
@@ skipping 18 matching lines @@
     const TransmissionInfo& info) const {
   // Packet contributes to congestion control if it is considered inflight.
   return info.in_flight;
 }
 
 bool QuicUnackedPacketMap::IsPacketUsefulForRetransmittableData(
     const TransmissionInfo& info) const {
   // Packet may have retransmittable frames, or the data may have been
   // retransmitted with a new packet number.
   return !info.retransmittable_frames.empty() ||
-         info.all_transmissions != nullptr ||
          // Allow for an extra 1 RTT before stopping to track old packets.
          info.retransmission > largest_observed_;
 }
 
 bool QuicUnackedPacketMap::IsPacketUseless(QuicPacketNumber packet_number,
                                            const TransmissionInfo& info) const {
   return !IsPacketUsefulForMeasuringRtt(packet_number, info) &&
          !IsPacketUsefulForCongestionControl(info) &&
          !IsPacketUsefulForRetransmittableData(info);
 }
@@ skipping 129 matching lines @@
     }
   }
   return false;
 }
 
 QuicPacketNumber QuicUnackedPacketMap::GetLeastUnacked() const {
   return least_unacked_;
 }
 
 }  // namespace net