Landing Recent QUIC Changes.

net/quic/congestion_control/tcp_cubic_sender_test.cc

 // Copyright (c) 2012 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 <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/congestion_control/tcp_receiver.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using std::make_pair;
 using std::min;
 
 namespace net {
 namespace test {
 
 const uint32 kDefaultWindowTCP = 10 * kDefaultTCPMSS;
 
 // TODO(ianswett): Remove 10000 once b/10075719 is fixed.
 const QuicTcpCongestionWindow kDefaultMaxCongestionWindowTCP = 10000;
 
@@ skipping 51 matching lines @@
           clock_.Now(), bytes_in_flight_, HAS_RETRANSMITTABLE_DATA).IsZero();
     }
     return packets_sent;
   }
 
   // Normal is that TCP acks every other segment.
   void AckNPackets(int n) {
     sender_->rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(60),
                                   QuicTime::Delta::Zero(),
                                   clock_.Now());
-    SendAlgorithmInterface::CongestionMap acked_packets;
-    SendAlgorithmInterface::CongestionMap lost_packets;
+    SendAlgorithmInterface::CongestionVector acked_packets;
+    SendAlgorithmInterface::CongestionVector lost_packets;
     for (int i = 0; i < n; ++i) {
       ++acked_sequence_number_;
-      acked_packets[acked_sequence_number_] = standard_packet_;
+      acked_packets.push_back(
+          make_pair(acked_sequence_number_, standard_packet_));
     }
     sender_->OnCongestionEvent(
         true, bytes_in_flight_, acked_packets, lost_packets);
     bytes_in_flight_ -= n * kDefaultTCPMSS;
     clock_.AdvanceTime(one_ms_);
   }
 
   void LoseNPackets(int n) {
-    SendAlgorithmInterface::CongestionMap acked_packets;
-    SendAlgorithmInterface::CongestionMap lost_packets;
+    SendAlgorithmInterface::CongestionVector acked_packets;
+    SendAlgorithmInterface::CongestionVector lost_packets;
     for (int i = 0; i < n; ++i) {
       ++acked_sequence_number_;
-      lost_packets[acked_sequence_number_] = standard_packet_;
+      lost_packets.push_back(
+          make_pair(acked_sequence_number_, standard_packet_));
     }
     sender_->OnCongestionEvent(
         false, bytes_in_flight_, acked_packets, lost_packets);
     bytes_in_flight_ -= n * kDefaultTCPMSS;
   }
 
   // Does not increment acked_sequence_number_.
   void LosePacket(QuicPacketSequenceNumber sequence_number) {
-    SendAlgorithmInterface::CongestionMap acked_packets;
-    SendAlgorithmInterface::CongestionMap lost_packets;
-    lost_packets[sequence_number] = standard_packet_;
+    SendAlgorithmInterface::CongestionVector acked_packets;
+    SendAlgorithmInterface::CongestionVector lost_packets;
+    lost_packets.push_back(
+        make_pair(sequence_number, standard_packet_));
     sender_->OnCongestionEvent(
         false, bytes_in_flight_, acked_packets, lost_packets);
     bytes_in_flight_ -= kDefaultTCPMSS;
   }
 
   const QuicTime::Delta one_ms_;
   MockClock clock_;
   scoped_ptr<TcpCubicSenderPeer> sender_;
   scoped_ptr<TcpReceiver> receiver_;
   QuicPacketSequenceNumber sequence_number_;
@@ skipping 483 matching lines @@
   }
 
   // Next ack should cause congestion window to grow by 1MSS.
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net