Change TransmissionInfo's all_transmissions SequenceNumberSet* to

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 340 matching lines @@
   // TODO(ianswett): Currently the RTO can fire while there are pending NACK
   // retransmissions for the same data, which is not ideal.
   if (ContainsKey(pending_retransmissions_, sequence_number)) {
     return;
   }
 
   pending_retransmissions_[sequence_number] = transmission_type;
 }
 
 void QuicSentPacketManager::RecordSpuriousRetransmissions(
-    const SequenceNumberSet& all_transmissions,
+    const SequenceNumberList& all_transmissions,
     QuicPacketSequenceNumber acked_sequence_number) {
   if (acked_sequence_number < first_rto_transmission_) {
     // Cancel all pending RTO transmissions and restore their in flight status.
     // Replace SRTT with latest_rtt and increase the variance to prevent
     // a spurious RTO from happening again.
     rtt_stats_.ExpireSmoothedMetrics();
     for (PendingRetransmissionMap::const_iterator it =
              pending_retransmissions_.begin();
          it != pending_retransmissions_.end(); ++it) {
       DCHECK_EQ(it->second, RTO_RETRANSMISSION);
       unacked_packets_.RestoreInFlight(it->first);
     }
     pending_retransmissions_.clear();
     send_algorithm_->RevertRetransmissionTimeout();
     first_rto_transmission_ = 0;
     ++stats_->spurious_rto_count;
   }
-  for (SequenceNumberSet::const_iterator
-            it = all_transmissions.upper_bound(acked_sequence_number),
-            end = all_transmissions.end();
-        it != end;
-        ++it) {
+  for (SequenceNumberList::const_reverse_iterator it =
+           all_transmissions.rbegin();
+       it != all_transmissions.rend() && *it > acked_sequence_number; ++it) {
     const TransmissionInfo& retransmit_info =
         unacked_packets_.GetTransmissionInfo(*it);
 
     stats_->bytes_spuriously_retransmitted += retransmit_info.bytes_sent;
     ++stats_->packets_spuriously_retransmitted;
     if (debug_delegate_ != NULL) {
       debug_delegate_->OnSpuriousPacketRetransmition(
           retransmit_info.transmission_type,
           retransmit_info.bytes_sent);
     }
@@ skipping 37 matching lines @@
 void QuicSentPacketManager::MarkPacketRevived(
     QuicPacketSequenceNumber sequence_number,
     QuicTime::Delta delta_largest_observed) {
   if (!unacked_packets_.IsUnacked(sequence_number)) {
     return;
   }
 
   const TransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(sequence_number);
   QuicPacketSequenceNumber newest_transmission =
-      *transmission_info.all_transmissions->rbegin();
+      transmission_info.all_transmissions == NULL ?
+          sequence_number : *transmission_info.all_transmissions->rbegin();
   // This packet has been revived at the receiver. If we were going to
   // retransmit it, do not retransmit it anymore.
   pending_retransmissions_.erase(newest_transmission);
 
   // The AckNotifierManager needs to be notified for revived packets,
   // since it indicates the packet arrived from the appliction's perspective.
   if (transmission_info.retransmittable_frames) {
     ack_notifier_manager_.OnPacketAcked(
         newest_transmission, delta_largest_observed);
   }
 
   unacked_packets_.RemoveRetransmittability(sequence_number);
 }
 
 void QuicSentPacketManager::MarkPacketHandled(
     QuicPacketSequenceNumber sequence_number,
     const TransmissionInfo& info,
     QuicTime::Delta delta_largest_observed) {
   QuicPacketSequenceNumber newest_transmission =
-      *info.all_transmissions->rbegin();
+      info.all_transmissions == NULL ?
+          sequence_number : *info.all_transmissions->rbegin();
   // Remove the most recent packet, if it is pending retransmission.
   pending_retransmissions_.erase(newest_transmission);
 
-  // Notify observers about the ACKed packet.
-  {
-    // The AckNotifierManager needs to be notified about the most recent
-    // transmission, since that's the one only one it tracks.
-    ack_notifier_manager_.OnPacketAcked(newest_transmission,
-                                        delta_largest_observed);
-    if (newest_transmission != sequence_number) {
-      RecordSpuriousRetransmissions(*info.all_transmissions, sequence_number);
+  // The AckNotifierManager needs to be notified about the most recent
+  // transmission, since that's the one only one it tracks.
+  ack_notifier_manager_.OnPacketAcked(newest_transmission,
+                                      delta_largest_observed);
+  if (newest_transmission != sequence_number) {
+    RecordSpuriousRetransmissions(*info.all_transmissions, sequence_number);
+    // Remove the most recent packet from flight if it's a crypto handshake
+    // packet, since they won't be acked now that one has been processed.
+    // Other crypto handshake packets won't be in flight, only the newest
+    // transmission of a crypto packet is in flight at once.
+    // TODO(ianswett): Instead of handling all crypto packets special,
+    // only handle NULL encrypted packets in a special way.
+    if (HasCryptoHandshake(
+        unacked_packets_.GetTransmissionInfo(newest_transmission))) {
+      unacked_packets_.RemoveFromInFlight(newest_transmission);
     }
   }
 
-  // Two cases for MarkPacketHandled:
-  // 1) Handle the most recent or a crypto packet, so remove all transmissions.
-  // 2) Handle old transmission, keep all other pending transmissions,
-  //    but disassociate them from one another.
-
-  // If it's a crypto handshake packet, discard it and all retransmissions,
-  // since they won't be acked now that one has been processed.
-  // TODO(ianswett): Instead of handling all crypto packets in a special way,
-  // only handle NULL encrypted packets in a special way.
-  if (HasCryptoHandshake(
-          unacked_packets_.GetTransmissionInfo(newest_transmission))) {
-    unacked_packets_.RemoveFromInFlight(newest_transmission);
-  }
   unacked_packets_.RemoveFromInFlight(sequence_number);
   unacked_packets_.RemoveRetransmittability(sequence_number);
 }
 
 bool QuicSentPacketManager::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   return unacked_packets_.IsUnacked(sequence_number);
 }
 
 bool QuicSentPacketManager::HasUnackedPackets() const {
@@ skipping 376 matching lines @@
 
   // Set up a pacing sender with a 5 millisecond alarm granularity.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(5),
                        kInitialUnpacedBurst));
 }
 
 }  // namespace net