Change the QUIC CongestionMap to be based on a vector.

net/quic/congestion_control/send_algorithm_simulator.cc

 // Copyright 2014 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/congestion_control/send_algorithm_simulator.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/quic/crypto/quic_random.h"
 
 using std::list;
+using std::make_pair;
 using std::max;
 using std::min;
 using std::vector;
 
 namespace net {
 
 namespace {
 
 const QuicByteCount kPacketSize = 1200;
 
@@ skipping 213 matching lines @@
       return true;
     }
     last_packet = it->sequence_number;
   }
   return false;
 }
 
 void SendAlgorithmSimulator::HandlePendingAck(Transfer* transfer) {
   Sender* sender  = transfer->sender;
   DCHECK_LT(sender->last_acked, sender->next_acked);
-  SendAlgorithmInterface::CongestionMap acked_packets;
-  SendAlgorithmInterface::CongestionMap lost_packets;
+  SendAlgorithmInterface::CongestionVector acked_packets;
+  SendAlgorithmInterface::CongestionVector lost_packets;
   DVLOG(1) << "Acking packets from:" << sender->last_acked
              << " to " << sender->next_acked
              << " bytes_in_flight:" << transfer->bytes_in_flight
              << " Now():" << (clock_->Now().ToDebuggingValue() / 1000) << "ms";
   // Some entries may be missing from the sent_packets_ array, if they were
   // dropped due to buffer overruns.
   SentPacket largest_observed;
   list<SentPacket>::iterator it = sent_packets_.begin();
   while (sender->last_acked < sender->next_acked) {
     ++sender->last_acked;
     TransmissionInfo info = TransmissionInfo();
     info.bytes_sent = kPacketSize;
     info.in_flight = true;
     // Find the next SentPacket for this transfer.
     while (it->transfer != transfer) {
       DCHECK(it != sent_packets_.end());
       ++it;
     }
     // If it's missing from the array, it's a loss.
     if (it->sequence_number > sender->last_acked) {
       DVLOG(1) << "Lost packet:" << sender->last_acked
                << " dropped by buffer overflow.";
-      lost_packets[sender->last_acked] = info;
+      lost_packets.push_back(make_pair(sender->last_acked, info));
       continue;
     }
     if (it->lost) {
-      lost_packets[sender->last_acked] = info;
+      lost_packets.push_back(make_pair(sender->last_acked, info));
     } else {
-      acked_packets[sender->last_acked] = info;
+      acked_packets.push_back(make_pair(sender->last_acked, info));
     }
     // This packet has been acked or lost, remove it from sent_packets_.
     largest_observed = *it;
     sent_packets_.erase(it++);
   }
 
   DCHECK(largest_observed.ack_time.IsInitialized());
   DVLOG(1) << "Updating RTT from send_time:"
            << largest_observed.send_time.ToDebuggingValue() << " to ack_time:"
            << largest_observed.ack_time.ToDebuggingValue();
@@ skipping 75 matching lines @@
   }
   transfer->bytes_in_flight += kPacketSize;
 }
 
 // Advance the time by |delta| without sending anything.
 void SendAlgorithmSimulator::AdvanceTime(QuicTime::Delta delta) {
   clock_->AdvanceTime(delta);
 }
 
 }  // namespace net