Land Recent QUIC Changes.

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/quic_ack_notifier_manager.h"
 
@@ skipping 14 matching lines @@
 QuicSentPacketManager::HelperInterface::~HelperInterface() {
 }
 
 QuicSentPacketManager::QuicSentPacketManager(bool is_server,
                                              HelperInterface* helper)
     : is_server_(is_server),
       helper_(helper) {
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {
-  STLDeleteValues(&unacked_packets_);
+  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);
     }
     delete previous_transmissions;
   }
 }
 
 void QuicSentPacketManager::OnSerializedPacket(
     const SerializedPacket& serialized_packet, QuicTime serialized_time) {
   if (serialized_packet.packet->is_fec_packet()) {
     DCHECK(!serialized_packet.retransmittable_frames);
     unacked_fec_packets_.insert(make_pair(
         serialized_packet.sequence_number, serialized_time));
     return;
   }
 
   if (serialized_packet.retransmittable_frames == NULL) {
     // Don't track ack/congestion feedback packets.
     return;
   }
 
   ack_notifier_manager_.OnSerializedPacket(serialized_packet);
 
   DCHECK(unacked_packets_.empty() ||
-         unacked_packets_.rbegin()->first <
-         serialized_packet.sequence_number);
+         unacked_packets_.rbegin()->first < serialized_packet.sequence_number);
   unacked_packets_[serialized_packet.sequence_number] =
-      serialized_packet.retransmittable_frames;
-  retransmission_map_[serialized_packet.sequence_number] =
-      RetransmissionInfo(serialized_packet.sequence_number,
-                         serialized_packet.sequence_number_length);
+      TransmissionInfo(serialized_packet.retransmittable_frames,
+                       serialized_packet.sequence_number_length);
+  nack_map_[serialized_packet.sequence_number] = 0;
 }
 
 void QuicSentPacketManager::OnRetransmittedPacket(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number) {
   DCHECK(ContainsKey(unacked_packets_, old_sequence_number));
-  DCHECK(ContainsKey(retransmission_map_, old_sequence_number));
+  DCHECK(ContainsKey(nack_map_, 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);
 
-  RetransmissionInfo retransmission_info(
-      new_sequence_number, GetSequenceNumberLength(old_sequence_number));
-  retransmission_info.number_retransmissions =
-      retransmission_map_[old_sequence_number].number_retransmissions + 1;
-  retransmission_map_.erase(old_sequence_number);
-  retransmission_map_[new_sequence_number] = retransmission_info;
+  nack_map_.erase(old_sequence_number);
+  nack_map_[new_sequence_number] = 0;
 
-  RetransmittableFrames* frames = unacked_packets_[old_sequence_number];
+  RetransmittableFrames* frames =
+      unacked_packets_[old_sequence_number].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);
 
-  if (FLAGS_track_retransmission_history) {
-    // 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] = NULL;
-  } else {
-    unacked_packets_.erase(old_sequence_number);
-  }
-  unacked_packets_[new_sequence_number] = frames;
+  // 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_packets_[new_sequence_number] =
+      TransmissionInfo(frames, GetSequenceNumberLength(old_sequence_number));
 
-  if (!FLAGS_track_retransmission_history) {
-    return;
-  }
   // 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()) {
     // 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;
     previous_transmissions->insert(old_sequence_number);
@@ skipping 47 matching lines @@
 
     // The peer got packets after this sequence number.  This is an explicit
     // nack.
 
     // TODO(rch): move this to the congestion manager, and fix the logic.
     // This is a packet which we planned on retransmitting and has not been
     // seen at the time of this ack being sent out.  See if it's our new
     // lowest unacked packet.
     DVLOG(1) << ENDPOINT << "still missing packet " << sequence_number;
     ++it;
-    RetransmissionMap::iterator retransmission_it =
-        retransmission_map_.find(sequence_number);
-    if (retransmission_it == retransmission_map_.end()) {
+    NackMap::iterator nack_it = nack_map_.find(sequence_number);
+    if (nack_it == nack_map_.end()) {
       continue;
     }
-    size_t nack_count = ++(retransmission_it->second.number_nacks);
-    helper_->OnPacketNacked(sequence_number, nack_count);
+    ++nack_it->second;
+    helper_->OnPacketNacked(sequence_number, nack_it->second);
   }
 
   // If we have received a trunacted ack, then we need to
   // clear out some previous transmissions to allow the peer
   // to actually ACK new packets.
   if (is_truncated_ack) {
     size_t num_to_clear = received_info.missing_packets.size() / 2;
     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)) {
         break;
       }
 
       DCHECK(ContainsKey(previous_transmissions_map_, sequence_number));
-      DCHECK(!ContainsKey(retransmission_map_, sequence_number));
+      DCHECK(!ContainsKey(nack_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);
       previous_transmissions->erase(sequence_number);
       if (previous_transmissions->size() == 1) {
         previous_transmissions_map_.erase(*previous_transmissions->begin());
         delete previous_transmissions;
       }
       --num_to_clear;
     }
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   if (!ContainsKey(unacked_packets_, sequence_number)) {
     return false;
   }
 
-  return unacked_packets_.find(sequence_number)->second != NULL;
+  return unacked_packets_.find(
+      sequence_number)->second.retransmittable_frames != NULL;
 }
 
 bool QuicSentPacketManager::MarkForRetransmission(
     QuicPacketSequenceNumber sequence_number,
     TransmissionType transmission_type) {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
   if (!HasRetransmittableFrames(sequence_number)) {
     return false;
   }
   // If it's already in the retransmission map, don't add it again, just let
   // the prior retransmission request win out.
   if (ContainsKey(pending_retransmissions_, sequence_number)) {
     return true;
   }
 
   pending_retransmissions_[sequence_number] = transmission_type;
   return true;
 }
 
 bool QuicSentPacketManager::HasPendingRetransmissions() const {
   return !pending_retransmissions_.empty();
 }
 
 QuicSentPacketManager::PendingRetransmission
     QuicSentPacketManager::NextPendingRetransmission() {
   DCHECK(!pending_retransmissions_.empty());
   QuicPacketSequenceNumber sequence_number =
       pending_retransmissions_.begin()->first;
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
-  DCHECK(unacked_packets_[sequence_number]);
+  DCHECK(unacked_packets_[sequence_number].retransmittable_frames);
 
   return PendingRetransmission(sequence_number,
                                pending_retransmissions_.begin()->second,
                                GetRetransmittableFrames(sequence_number),
                                GetSequenceNumberLength(sequence_number));
 }
 
 bool QuicSentPacketManager::IsPreviousTransmission(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
@@ skipping 49 matching lines @@
   bool is_new_packet = new_packet == sequence_number;
   if (is_new_packet) {
     DiscardPacket(new_packet);
   } else {
     if (next_unacked->first == new_packet) {
       ++next_unacked;
     }
     // 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_[new_packet];
-    unacked_packets_[new_packet] = NULL;
+    delete unacked_packets_[new_packet].retransmittable_frames;
+    unacked_packets_[new_packet].retransmittable_frames = NULL;
     pending_retransmissions_.erase(new_packet);
   }
   previous_transmissions_map_.erase(new_packet);
 
   // 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));
@@ skipping 14 matching lines @@
       }
   return next_unacked;
 }
 
 void QuicSentPacketManager::DiscardPacket(
     QuicPacketSequenceNumber sequence_number) {
   UnackedPacketMap::iterator unacked_it =
       unacked_packets_.find(sequence_number);
   // Packet was not meant to be retransmitted.
   if (unacked_it == unacked_packets_.end()) {
-    DCHECK(!ContainsKey(retransmission_map_, sequence_number));
+    DCHECK(!ContainsKey(nack_map_, sequence_number));
     return;
   }
 
-  // Delete the unacked packet.
-  delete unacked_it->second;
+  // Delete the retransmittable frames.
+  delete unacked_it->second.retransmittable_frames;
   unacked_packets_.erase(unacked_it);
-  retransmission_map_.erase(sequence_number);
+  nack_map_.erase(sequence_number);
   pending_retransmissions_.erase(sequence_number);
   return;
 }
 
 void QuicSentPacketManager::HandleAckForSentFecPackets(
     const ReceivedPacketInfo& received_info) {
   UnackedFecPacketMap::iterator it = unacked_fec_packets_.begin();
   while (it != unacked_fec_packets_.end()) {
     QuicPacketSequenceNumber sequence_number = it->first;
     if (sequence_number > received_info.largest_observed) {
@@ skipping 16 matching lines @@
 
 void QuicSentPacketManager::DiscardFecPacket(
     QuicPacketSequenceNumber sequence_number) {
   DCHECK(ContainsKey(unacked_fec_packets_, sequence_number));
   unacked_fec_packets_.erase(sequence_number);
 }
 
 bool QuicSentPacketManager::IsRetransmission(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(HasRetransmittableFrames(sequence_number));
-  RetransmissionMap::const_iterator it =
-      retransmission_map_.find(sequence_number);
-  return it != retransmission_map_.end() &&
-      it->second.number_retransmissions > 0;
-}
-
-size_t QuicSentPacketManager::GetRetransmissionCount(
-    QuicPacketSequenceNumber sequence_number) const {
-  DCHECK(HasRetransmittableFrames(sequence_number));
-  DCHECK(ContainsKey(retransmission_map_, sequence_number));
-  RetransmissionMap::const_iterator it =
-      retransmission_map_.find(sequence_number);
-  return it->second.number_retransmissions;
+  return HasRetransmittableFrames(sequence_number) &&
+      ContainsKey(previous_transmissions_map_, sequence_number);
 }
 
 bool QuicSentPacketManager::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   return ContainsKey(unacked_packets_, sequence_number);
 }
 
 bool QuicSentPacketManager::IsFecUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   return ContainsKey(unacked_fec_packets_, sequence_number);
 }
 
 const RetransmittableFrames& QuicSentPacketManager::GetRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
-  DCHECK(ContainsKey(retransmission_map_, sequence_number));
+  DCHECK(ContainsKey(nack_map_, sequence_number));
 
-  return *unacked_packets_.find(sequence_number)->second;
+  return *unacked_packets_.find(sequence_number)->second.retransmittable_frames;
 }
 
 QuicSequenceNumberLength QuicSentPacketManager::GetSequenceNumberLength(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
-  DCHECK(ContainsKey(retransmission_map_, sequence_number));
 
-  return retransmission_map_.find(
-      sequence_number)->second.sequence_number_length;
+  return unacked_packets_.find(sequence_number)->second.sequence_number_length;
 }
 
 QuicTime QuicSentPacketManager::GetFecSentTime(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK(ContainsKey(unacked_fec_packets_, sequence_number));
 
   return unacked_fec_packets_.find(sequence_number)->second;
 }
 
 bool QuicSentPacketManager::HasUnackedPackets() const {
   return !unacked_packets_.empty();
 }
 
-size_t QuicSentPacketManager::GetNumUnackedPackets() const {
-  return unacked_packets_.size();
+size_t QuicSentPacketManager::GetNumRetransmittablePackets() const {
+  size_t num_unacked_packets = 0;
+  for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
+       it != unacked_packets_.end(); ++it) {
+    QuicPacketSequenceNumber sequence_number = it->first;
+    if (HasRetransmittableFrames(sequence_number)) {
+      ++num_unacked_packets;
+    }
+  }
+  return num_unacked_packets;
 }
 
 bool QuicSentPacketManager::HasUnackedFecPackets() const {
   return !unacked_fec_packets_.empty();
 }
 
 QuicPacketSequenceNumber
 QuicSentPacketManager::GetLeastUnackedSentPacket() const {
   if (unacked_packets_.empty()) {
     // If there are no unacked packets, set the least unacked packet to
@@ skipping 18 matching lines @@
 SequenceNumberSet QuicSentPacketManager::GetUnackedPackets() const {
   SequenceNumberSet unacked_packets;
   for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     unacked_packets.insert(it->first);
   }
   return unacked_packets;
 }
 
 }  // namespace net