Rename previous_transmissions to all_transmission in the QUIC unacked

net/quic/quic_sent_packet_manager.cc

Index: net/quic/quic_sent_packet_manager.cc
diff --git a/net/quic/quic_sent_packet_manager.cc b/net/quic/quic_sent_packet_manager.cc
index 748d6734d6dcc44a4227352075489adcc5aba763..bcdbc51c00d5b3722322cf886ea1daae5945ece0 100644
--- a/net/quic/quic_sent_packet_manager.cc
+++ b/net/quic/quic_sent_packet_manager.cc
@@ -63,6 +63,39 @@ COMPILE_ASSERT(kHistoryPeriodMs >= kBitrateSmoothingPeriodMs,
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
+
+QuicSentPacketManager::TransmissionInfo::TransmissionInfo()
+    : retransmittable_frames(NULL),
+      sequence_number_length(PACKET_1BYTE_SEQUENCE_NUMBER),
+      sent_time(QuicTime::Zero()),
+      all_transmissions(NULL),
+      pending(false) { }
+
+QuicSentPacketManager::TransmissionInfo::TransmissionInfo(
+    RetransmittableFrames* retransmittable_frames,
+    QuicPacketSequenceNumber sequence_number,
+    QuicSequenceNumberLength sequence_number_length)
+    : retransmittable_frames(retransmittable_frames),
+      sequence_number_length(sequence_number_length),
+      sent_time(QuicTime::Zero()),
+      all_transmissions(new SequenceNumberSet),
+      pending(false) {
+  all_transmissions->insert(sequence_number);
+}
+
+QuicSentPacketManager::TransmissionInfo::TransmissionInfo(
+    RetransmittableFrames* retransmittable_frames,
+    QuicPacketSequenceNumber sequence_number,
+    QuicSequenceNumberLength sequence_number_length,
+    SequenceNumberSet* all_transmissions)
+    : retransmittable_frames(retransmittable_frames),
+      sequence_number_length(sequence_number_length),
+      sent_time(QuicTime::Zero()),
+      all_transmissions(all_transmissions),
+      pending(false) {
+  all_transmissions->insert(sequence_number);
+}
+
 QuicSentPacketManager::QuicSentPacketManager(bool is_server,
                                              const QuicClock* clock,
                                              QuicConnectionStats* stats,
@@ -84,10 +117,9 @@ QuicSentPacketManager::~QuicSentPacketManager() {
   for (UnackedPacketMap::iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     delete it->second.retransmittable_frames;
-    // 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;
+    // Only delete all_transmissions once, for the newest packet.
+    if (it->first == *it->second.all_transmissions->rbegin()) {
+      delete it->second.all_transmissions;
     }
   }
   STLDeleteValues(&packet_history_map_);
@@ -126,10 +158,12 @@ void QuicSentPacketManager::OnSerializedPacket(
     }
   }
 
+  QuicPacketSequenceNumber sequence_number = serialized_packet.sequence_number;
   DCHECK(unacked_packets_.empty() ||
-         unacked_packets_.rbegin()->first < serialized_packet.sequence_number);
-  unacked_packets_[serialized_packet.sequence_number] =
+         unacked_packets_.rbegin()->first < sequence_number);
+  unacked_packets_[sequence_number] =
       TransmissionInfo(serialized_packet.retransmittable_frames,
+                       serialized_packet.sequence_number,
                        serialized_packet.sequence_number_length);
 }
 
@@ -157,21 +191,9 @@ void QuicSentPacketManager::OnRetransmittedPacket(
   // the retransmissions of it are acked.
   transmission_info->retransmittable_frames = NULL;
   unacked_packets_[new_sequence_number] =
-      TransmissionInfo(frames, transmission_info->sequence_number_length);
-
-  // Keep track of all sequence numbers that this packet
-  // has been transmitted as.
-  SequenceNumberSet* previous_transmissions =
-      transmission_info->previous_transmissions;
-  if (previous_transmissions == NULL) {
-    // This is the first retransmission of this packet, so create a new entry.
-    previous_transmissions = new SequenceNumberSet;
-    transmission_info->previous_transmissions = previous_transmissions;
-    previous_transmissions->insert(old_sequence_number);
-  }
-  previous_transmissions->insert(new_sequence_number);
-  unacked_packets_[new_sequence_number].previous_transmissions =
-      previous_transmissions;
+      TransmissionInfo(frames, new_sequence_number,
+                       transmission_info->sequence_number_length,
+                       transmission_info->all_transmissions);
 }
 
 bool QuicSentPacketManager::OnIncomingAck(
@@ -245,9 +267,8 @@ void QuicSentPacketManager::ClearPreviousRetransmissions(size_t num_to_clear) {
     // 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.
-    SequenceNumberSet* previous_transmissions =
-        it->second.previous_transmissions;
-    if (previous_transmissions == NULL) {
+    SequenceNumberSet* all_transmissions = it->second.all_transmissions;
+    if (all_transmissions->size() == 1) {
       if (it->second.retransmittable_frames == NULL) {
         // This is a current transmission, but a previous transmission has
         // been acked, so it's safe to remove.
@@ -257,8 +278,7 @@ void QuicSentPacketManager::ClearPreviousRetransmissions(size_t num_to_clear) {
       }
       break;
     }
-    QuicPacketSequenceNumber newest_transmission =
-        *previous_transmissions->rbegin();
+    QuicPacketSequenceNumber newest_transmission = *all_transmissions->rbegin();
     if (sequence_number == newest_transmission) {
       break;
     }
@@ -267,12 +287,9 @@ void QuicSentPacketManager::ClearPreviousRetransmissions(size_t num_to_clear) {
     }
 
     DCHECK(it->second.retransmittable_frames == NULL);
-    previous_transmissions->erase(sequence_number);
-    if (previous_transmissions->size() == 1) {
-      unacked_packets_[newest_transmission].previous_transmissions = NULL;
-      delete previous_transmissions;
-    }
-    unacked_packets_.erase(it++);
+    DCHECK_LT(1u, all_transmissions->size());
+    ++it;
+    RemovePacket(sequence_number);
     --num_to_clear;
   }
 }
@@ -296,7 +313,7 @@ void QuicSentPacketManager::RetransmitUnackedPackets(
         unacked_it->second.retransmittable_frames;
     // Only mark it as handled if it can't be retransmitted and there are no
     // pending retransmissions which would be cleared.
-    if (frames == NULL && unacked_it->second.previous_transmissions == NULL &&
+    if (frames == NULL && unacked_it->second.all_transmissions->size() == 1 &&
         retransmission_type == ALL_PACKETS) {
       unacked_it = MarkPacketHandled(unacked_it->first, NOT_RECEIVED_BY_PEER);
       continue;
@@ -387,15 +404,11 @@ QuicSentPacketManager::MarkPacketHandled(
     it->second.pending = false;
   }
 
-  SequenceNumberSet* previous_transmissions = it->second.previous_transmissions;
-  if (previous_transmissions == NULL) {
-    previous_transmissions = new SequenceNumberSet;
-    previous_transmissions->insert(sequence_number);
-  }
-  DCHECK(!previous_transmissions->empty());
-  SequenceNumberSet::reverse_iterator previous_transmissions_it =
-      previous_transmissions->rbegin();
-  QuicPacketSequenceNumber newest_transmission = *previous_transmissions_it;
+  SequenceNumberSet* all_transmissions = it->second.all_transmissions;
+  DCHECK(!all_transmissions->empty());
+  SequenceNumberSet::reverse_iterator all_transmissions_it =
+      all_transmissions->rbegin();
+  QuicPacketSequenceNumber newest_transmission = *all_transmissions_it;
   if (newest_transmission != sequence_number) {
     ++stats_->packets_spuriously_retransmitted;
   }
@@ -405,8 +418,8 @@ QuicSentPacketManager::MarkPacketHandled(
   if (has_cryto_handshake) {
     --pending_crypto_packet_count_;
   }
-  while (previous_transmissions_it != previous_transmissions->rend()) {
-    QuicPacketSequenceNumber previous_transmission = *previous_transmissions_it;
+  while (all_transmissions_it != all_transmissions->rend()) {
+    QuicPacketSequenceNumber previous_transmission = *all_transmissions_it;
     TransmissionInfo* transmission_info =
         FindOrNull(unacked_packets_, previous_transmission);
     if (transmission_info->retransmittable_frames != NULL) {
@@ -431,11 +444,12 @@ QuicSentPacketManager::MarkPacketHandled(
     if (!transmission_info->pending) {
       unacked_packets_.erase(previous_transmission);
     } else {
-      transmission_info->previous_transmissions = NULL;
+      transmission_info->all_transmissions = new SequenceNumberSet;
+      transmission_info->all_transmissions->insert(previous_transmission);
     }
-    ++previous_transmissions_it;
+    ++all_transmissions_it;
   }
-  delete previous_transmissions;
+  delete all_transmissions;
 
   UnackedPacketMap::iterator next_unacked = unacked_packets_.begin();
   while (next_unacked != unacked_packets_.end() &&
@@ -445,6 +459,21 @@ QuicSentPacketManager::MarkPacketHandled(
   return next_unacked;
 }
 
+void QuicSentPacketManager::RemovePacket(
+    QuicPacketSequenceNumber sequence_number) {
+  UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
+  if (it == unacked_packets_.end()) {
+    LOG(DFATAL) << "packet is not unacked: " << sequence_number;
+    return;
+  }
+  const TransmissionInfo& transmission_info = it->second;
+  transmission_info.all_transmissions->erase(sequence_number);
+  if (transmission_info.all_transmissions->empty()) {
+    delete transmission_info.all_transmissions;
+  }
+  unacked_packets_.erase(it);
+}
+
 bool QuicSentPacketManager::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   return ContainsKey(unacked_packets_, sequence_number);
@@ -514,7 +543,7 @@ bool QuicSentPacketManager::OnPacketSent(
                                      transmission_type,
                                      has_retransmittable_data)) {
     DCHECK(it->second.retransmittable_frames == NULL);
-    unacked_packets_.erase(it);
+    RemovePacket(sequence_number);
     // Do not reset the retransmission timer, since the packet isn't tracked.
     return false;
   }
@@ -723,8 +752,8 @@ void QuicSentPacketManager::MaybeRetransmitOnAckFrame(
       // 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(it++);
+      ++it;
+      RemovePacket(sequence_number);
     }
   }
 }
@@ -929,19 +958,4 @@ void QuicSentPacketManager::MaybeEnablePacing() {
                        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