QuicSentPacketManager cleanup to simplify OnAbandonFECTimeout() and

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 583 matching lines @@
     }
   }
 }
 
 QuicTime QuicSentPacketManager::OnAbandonFecTimeout() {
   // Abandon all the FEC packets older than the current RTO, then reschedule
   // the alarm if there are more pending fec packets.
   QuicTime::Delta retransmission_delay = GetRetransmissionDelay();
   QuicTime max_send_time =
       clock_->ApproximateNow().Subtract(retransmission_delay);
-  while (HasUnackedFecPackets()) {
-    QuicPacketSequenceNumber oldest_unacked_fec = GetLeastUnackedFecPacket();
-    QuicTime fec_sent_time = GetFecSentTime(oldest_unacked_fec);
+  while (!unacked_fec_packets_.empty()) {
+    UnackedFecPacketMap::iterator it = unacked_fec_packets_.begin();
+    QuicTime fec_sent_time = it->second;
     if (fec_sent_time > max_send_time) {
       return fec_sent_time.Add(retransmission_delay);
     }
-    DiscardFecPacket(oldest_unacked_fec);
-    OnPacketAbandoned(oldest_unacked_fec);
+    OnPacketAbandoned(it->first);
+    unacked_fec_packets_.erase(it++);
   }
 
   return QuicTime::Zero();
 }
 
 void QuicSentPacketManager::OnPacketAbandoned(
     QuicPacketSequenceNumber sequence_number) {
   SequenceNumberSet::iterator it = pending_packets_.find(sequence_number);
   if (it != pending_packets_.end()) {
     DCHECK(ContainsKey(packet_history_map_, sequence_number));
@@ skipping 122 matching lines @@
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(
     QuicTime now,
     TransmissionType transmission_type,
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
   return send_algorithm_->TimeUntilSend(now, transmission_type, retransmittable,
                                         handshake);
 }
 
-const QuicTime::Delta QuicSentPacketManager::DefaultRetransmissionTime() {
-  return QuicTime::Delta::FromMilliseconds(kDefaultRetransmissionTimeMs);
-}
-
 // Ensures that the Delayed Ack timer is always set to a value lesser
 // than the retransmission timer's minimum value (MinRTO). We want the
 // delayed ack to get back to the QUIC peer before the sender's
 // retransmission timer triggers.  Since we do not know the
 // reverse-path one-way delay, we assume equal delays for forward and
 // reverse paths, and ensure that the timer is set to less than half
 // of the MinRTO.
 // There may be a value in making this delay adaptive with the help of
 // the sender and a signaling mechanism -- if the sender uses a
 // different MinRTO, we may get spurious retransmissions. May not have
@@ skipping 85 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net