Land Recent QUIC changes.

net/quic/congestion_control/inter_arrival_sender_test.cc

 // Copyright (c) 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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/inter_arrival_sender.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using std::pair;
+
 namespace net {
 namespace test {
 
 class InterArrivalSenderTest : public ::testing::Test {
  protected:
   InterArrivalSenderTest()
      : rtt_(QuicTime::Delta::FromMilliseconds(60)),
        one_ms_(QuicTime::Delta::FromMilliseconds(1)),
        one_s_(QuicTime::Delta::FromMilliseconds(1000)),
        nine_ms_(QuicTime::Delta::FromMilliseconds(9)),
@@ skipping 32 matching lines @@
     }
   }
 
   void SendDelaySpikeFeedbackMessage(QuicTime::Delta spike_time) {
     QuicCongestionFeedbackFrame feedback;
     feedback.type = kInterArrival;
     feedback.inter_arrival.accumulated_number_of_lost_packets = 0;
     receive_clock_.AdvanceTime(spike_time);
     QuicTime receive_time = receive_clock_.ApproximateNow();
     feedback.inter_arrival.received_packet_times.insert(
-        std::pair<QuicPacketSequenceNumber, QuicTime>(
+        pair<QuicPacketSequenceNumber, QuicTime>(
             feedback_sequence_number_, receive_time));
     feedback_sequence_number_++;
 
     // We need to send feedback for 2 packets since they where sent at the
     // same time.
     feedback.inter_arrival.received_packet_times.insert(
-        std::pair<QuicPacketSequenceNumber, QuicTime>(
+        pair<QuicPacketSequenceNumber, QuicTime>(
             feedback_sequence_number_, receive_time));
     feedback_sequence_number_++;
 
     sender_.OnIncomingQuicCongestionFeedbackFrame(feedback, send_clock_.Now(),
                                                   sent_packets_);
   }
 
   void SendFeedbackMessageNPackets(int n,
                                    QuicTime::Delta delta_odd,
                                    QuicTime::Delta delta_even) {
     QuicCongestionFeedbackFrame feedback;
     feedback.type = kInterArrival;
     feedback.inter_arrival.accumulated_number_of_lost_packets = 0;
     for (int i = 0; i < n; ++i) {
       if (feedback_sequence_number_ % 2) {
         receive_clock_.AdvanceTime(delta_even);
       } else {
         receive_clock_.AdvanceTime(delta_odd);
       }
       QuicTime receive_time = receive_clock_.ApproximateNow();
       feedback.inter_arrival.received_packet_times.insert(
-          std::pair<QuicPacketSequenceNumber, QuicTime>(
+          pair<QuicPacketSequenceNumber, QuicTime>(
               feedback_sequence_number_, receive_time));
       feedback_sequence_number_++;
     }
     sender_.OnIncomingQuicCongestionFeedbackFrame(feedback, send_clock_.Now(),
                                                   sent_packets_);
   }
 
   QuicTime::Delta SenderDeltaSinceStart() {
     return send_clock_.ApproximateNow().Subtract(send_start_time_);
   }
@@ skipping 452 matching lines @@
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
     SendFeedbackMessageNPackets(2, nine_ms_, nine_ms_);
 
     // Make sure our bitrate is fixed at the expected_min_bitrate.
     EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
   }
 }
 
 }  // namespace test
 }  // namespace net