Simplify QuicSentPacketManager MarkPacketHandled to take an iterator

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 186 matching lines @@
       continue;
     }
 
     // Packet was acked, so remove it from our unacked packet list.
     DVLOG(1) << ENDPOINT << "Got an ack for packet " << sequence_number;
     // If data is associated with the most recent transmission of this
     // packet, then inform the caller.
     if (it->second.pending) {
       packets_acked_[sequence_number] = it->second;
     }
-    it = MarkPacketHandled(sequence_number, delta_largest_observed);
+    it = MarkPacketHandled(it, delta_largest_observed);
   }
 
   // Discard any retransmittable frames associated with revived packets.
   for (SequenceNumberSet::const_iterator revived_it =
            received_info.revived_packets.begin();
        revived_it != received_info.revived_packets.end(); ++revived_it) {
     MarkPacketRevived(*revived_it, delta_largest_observed);
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   return unacked_packets_.HasRetransmittableFrames(sequence_number);
 }
 
 void QuicSentPacketManager::RetransmitUnackedPackets(
     RetransmissionType retransmission_type) {
   QuicUnackedPacketMap::const_iterator unacked_it = unacked_packets_.begin();
   while (unacked_it != unacked_packets_.end()) {
     const RetransmittableFrames* frames =
         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.all_transmissions->size() == 1 &&
-        retransmission_type == ALL_PACKETS) {
-      unacked_it = MarkPacketHandled(unacked_it->first,
-                                     QuicTime::Delta::Zero());
-      continue;
-    }
-    // If it had no other transmissions, we handle it above.  If it has
-    // other transmissions, one of them must have retransmittable frames,
-    // so that gets resolved the same way as other retransmissions.
     // TODO(ianswett): Consider adding a new retransmission type which removes
     // all these old packets from unacked and retransmits them as new sequence
     // numbers with no connection to the previous ones.
     if (frames != NULL && (retransmission_type == ALL_PACKETS ||
                            frames->encryption_level() == ENCRYPTION_INITIAL)) {
       MarkForRetransmission(unacked_it->first, ALL_UNACKED_RETRANSMISSION);
     }
     ++unacked_it;
   }
 }
@@ skipping 86 matching lines @@
   // 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, largest_observed_);
 }
 
 QuicUnackedPacketMap::const_iterator QuicSentPacketManager::MarkPacketHandled(
-    QuicPacketSequenceNumber sequence_number,
+    QuicUnackedPacketMap::const_iterator it,
     QuicTime::Delta delta_largest_observed) {
-  if (!unacked_packets_.IsUnacked(sequence_number)) {
-    LOG(DFATAL) << "Packet is not unacked: " << sequence_number;
-    return unacked_packets_.end();
-  }
-  const TransmissionInfo& transmission_info =
-      unacked_packets_.GetTransmissionInfo(sequence_number);
+  LOG_IF(DFATAL, it == unacked_packets_.end())
+      << "MarkPacketHandled must be passed a valid iterator entry.";
+  const QuicPacketSequenceNumber sequence_number = it->first;
+  const TransmissionInfo& transmission_info = it->second;
 
   QuicPacketSequenceNumber newest_transmission =
       *transmission_info.all_transmissions->rbegin();
   // Remove the most recent packet, if it is pending retransmission.
   pending_retransmissions_.erase(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.
@@ skipping 383 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net