Cleanup in QUIC to merge the previous_transmissions_map in

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 60 matching lines @@
       send_algorithm_(SendAlgorithmInterface::Create(clock, type)),
       rtt_sample_(QuicTime::Delta::Infinite()),
       consecutive_rto_count_(0),
       using_pacing_(false) {
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {
   for (UnackedPacketMap::iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     delete it->second.retransmittable_frames;
-  }
-  while (!previous_transmissions_map_.empty()) {
-    SequenceNumberSet* previous_transmissions =
-        previous_transmissions_map_.begin()->second;
-    for (SequenceNumberSet::const_iterator it = previous_transmissions->begin();
-         it != previous_transmissions->end(); ++it) {
-      DCHECK(ContainsKey(previous_transmissions_map_, *it));
-      previous_transmissions_map_.erase(*it);
+    // Only delete previous_transmissions once, for the newest packet.
+    if (it->second.previous_transmissions != NULL &&
+        it->first == *it->second.previous_transmissions->rbegin()) {
+      delete it->second.previous_transmissions;
     }
-    delete previous_transmissions;
   }
   STLDeleteValues(&packet_history_map_);
 }
 
 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.";
@@ skipping 30 matching lines @@
 void QuicSentPacketManager::OnRetransmittedPacket(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number) {
   DCHECK(ContainsKey(unacked_packets_, old_sequence_number));
   DCHECK(ContainsKey(pending_retransmissions_, old_sequence_number));
   DCHECK(unacked_packets_.empty() ||
          unacked_packets_.rbegin()->first < new_sequence_number);
 
   pending_retransmissions_.erase(old_sequence_number);
 
-  RetransmittableFrames* frames =
-      unacked_packets_[old_sequence_number].retransmittable_frames;
+  UnackedPacketMap::iterator unacked_it =
+      unacked_packets_.find(old_sequence_number);
+  RetransmittableFrames* frames = unacked_it->second.retransmittable_frames;
   DCHECK(frames);
 
   // A notifier may be waiting to hear about ACKs for the original sequence
   // number. Inform them that the sequence number has changed.
   ack_notifier_manager_.UpdateSequenceNumber(old_sequence_number,
                                              new_sequence_number);
 
   // We keep the old packet in the unacked packet list until it, or one of
   // the retransmissions of it are acked.
-  unacked_packets_[old_sequence_number].retransmittable_frames = NULL;
+  unacked_it->second.retransmittable_frames = NULL;
   unacked_packets_[new_sequence_number] =
       TransmissionInfo(frames, GetSequenceNumberLength(old_sequence_number));
 
   // Keep track of all sequence numbers that this packet
   // has been transmitted as.
-  SequenceNumberSet* previous_transmissions;
-  PreviousTransmissionMap::iterator it =
-      previous_transmissions_map_.find(old_sequence_number);
-  if (it == previous_transmissions_map_.end()) {
+  SequenceNumberSet* previous_transmissions =
+      unacked_it->second.previous_transmissions;
+  if (previous_transmissions == NULL) {
     // This is the first retransmission of this packet, so create a new entry.
     previous_transmissions = new SequenceNumberSet;
-    previous_transmissions_map_[old_sequence_number] = previous_transmissions;
+    unacked_it->second.previous_transmissions = previous_transmissions;
     previous_transmissions->insert(old_sequence_number);
-  } else {
-    // Otherwise, use the existing entry.
-    previous_transmissions = it->second;
   }
   previous_transmissions->insert(new_sequence_number);
-  previous_transmissions_map_[new_sequence_number] = previous_transmissions;
+  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();
   bool new_least_unacked = !IsAwaitingPacket(received_info,
@@ skipping 51 matching lines @@
 
   // If we have received a truncated ack, then we need to
   // clear out some previous transmissions to allow the peer
   // to actually ACK new packets.
   if (received_info.is_truncated) {
     ClearPreviousRetransmissions(received_info.missing_packets.size() / 2);
   }
 }
 
 void QuicSentPacketManager::ClearPreviousRetransmissions(size_t num_to_clear) {
-  UnackedPacketMap::const_iterator it = unacked_packets_.begin();
+  UnackedPacketMap::iterator it = unacked_packets_.begin();
   while (it != unacked_packets_.end() && num_to_clear > 0) {
     QuicPacketSequenceNumber sequence_number = it->first;
-    ++it;
     // If this is not a previous transmission then there is no point
     // in clearing out any further packets, because it will not affect
     // the high water mark.
-    if (!IsPreviousTransmission(sequence_number)) {
+    SequenceNumberSet* previous_transmissions =
+        it->second.previous_transmissions;
+    if (previous_transmissions == NULL) {
+      break;
+    }
+    QuicPacketSequenceNumber newest_transmission =
+        *previous_transmissions->rbegin();
+    if (sequence_number == newest_transmission) {
       break;
     }
 
-    DCHECK(ContainsKey(previous_transmissions_map_, sequence_number));
-    DCHECK(!HasRetransmittableFrames(sequence_number));
-    unacked_packets_.erase(sequence_number);
-    SequenceNumberSet* previous_transmissions =
-        previous_transmissions_map_[sequence_number];
-    previous_transmissions_map_.erase(sequence_number);
+    DCHECK(it->second.retransmittable_frames == NULL);
     previous_transmissions->erase(sequence_number);
     if (previous_transmissions->size() == 1) {
-      previous_transmissions_map_.erase(*previous_transmissions->begin());
+      unacked_packets_[newest_transmission].previous_transmissions = NULL;
       delete previous_transmissions;
     }
+    unacked_packets_.erase(it++);
     --num_to_clear;
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   if (!ContainsKey(unacked_packets_, sequence_number)) {
     return false;
   }
 
@@ skipping 61 matching lines @@
   return PendingRetransmission(sequence_number,
                                pending_retransmissions_.begin()->second,
                                *retransmittable_frames,
                                GetSequenceNumberLength(sequence_number));
 }
 
 bool QuicSentPacketManager::IsPreviousTransmission(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
 
-  PreviousTransmissionMap::const_iterator it =
-      previous_transmissions_map_.find(sequence_number);
-  if (it == previous_transmissions_map_.end()) {
+  UnackedPacketMap::const_iterator it = unacked_packets_.find(sequence_number);
+  if (it->second.previous_transmissions == NULL) {
     return false;
   }
 
-  SequenceNumberSet* previous_transmissions = it->second;
+  SequenceNumberSet* previous_transmissions = it->second.previous_transmissions;
   DCHECK(!previous_transmissions->empty());
   return *previous_transmissions->rbegin() != sequence_number;
 }
 
-QuicPacketSequenceNumber QuicSentPacketManager::GetMostRecentTransmission(
-    QuicPacketSequenceNumber sequence_number) const {
-  DCHECK(ContainsKey(unacked_packets_, sequence_number));
-
-  PreviousTransmissionMap::const_iterator it =
-      previous_transmissions_map_.find(sequence_number);
-  if (it == previous_transmissions_map_.end()) {
-    return sequence_number;
-  }
-
-  SequenceNumberSet* previous_transmissions =
-      previous_transmissions_map_.find(sequence_number)->second;
-  DCHECK(!previous_transmissions->empty());
-  return *previous_transmissions->rbegin();
-}
-
 QuicSentPacketManager::UnackedPacketMap::iterator
 QuicSentPacketManager::MarkPacketReceivedByPeer(
     QuicPacketSequenceNumber sequence_number) {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
 
   // If this packet has never been retransmitted, then simply drop it.
-  PreviousTransmissionMap::const_iterator previous_it =
-      previous_transmissions_map_.find(sequence_number);
-  if (previous_it == previous_transmissions_map_.end()) {
+  UnackedPacketMap::const_iterator previous_it =
+      unacked_packets_.find(sequence_number);
+  if (previous_it->second.previous_transmissions == NULL) {
     UnackedPacketMap::iterator next_unacked =
         unacked_packets_.find(sequence_number);
     ++next_unacked;
     DiscardPacket(sequence_number);
     return next_unacked;
   }
 
-  SequenceNumberSet* previous_transmissions = previous_it->second;
+  SequenceNumberSet* previous_transmissions =
+      previous_it->second.previous_transmissions;
   DCHECK(!previous_transmissions->empty());
   SequenceNumberSet::reverse_iterator previous_transmissions_it =
       previous_transmissions->rbegin();
   QuicPacketSequenceNumber newest_transmission = *previous_transmissions_it;
   if (newest_transmission == sequence_number) {
     DiscardPacket(newest_transmission);
   } else {
     // 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 unacked_packets_[newest_transmission].retransmittable_frames;
     unacked_packets_[newest_transmission].retransmittable_frames = NULL;
+    unacked_packets_[newest_transmission].previous_transmissions = NULL;
     pending_retransmissions_.erase(newest_transmission);
   }
-  previous_transmissions_map_.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;
-    DCHECK(ContainsKey(previous_transmissions_map_, previous_transmission));
-    previous_transmissions_map_.erase(previous_transmission);
     DiscardPacket(previous_transmission);
   }
 
   delete previous_transmissions;
 
   UnackedPacketMap::iterator next_unacked = unacked_packets_.begin();
   while (next_unacked != unacked_packets_.end() &&
          next_unacked->first < sequence_number) {
     ++next_unacked;
   }
@@ skipping 370 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net