adds std:: to stl types (#049)

net/quic/core/quic_received_packet_manager_test.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/core/quic_received_packet_manager.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "net/quic/core/quic_connection_stats.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/test_tools/quic_received_packet_manager_peer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using std::pair;
-using std::vector;
-
 namespace net {
 namespace test {
 
 class EntropyTrackerPeer {
  public:
   static QuicPacketNumber first_gap(
       const QuicReceivedPacketManager::EntropyTracker& tracker) {
     return tracker.first_gap_;
   }
   static QuicPacketNumber largest_observed(
@@ skipping 161 matching lines @@
   explicit TestParams(QuicVersion version) : version(version) {}
 
   friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
     os << "{ version: " << QuicVersionToString(p.version) << " }";
     return os;
   }
 
   QuicVersion version;
 };
 
-vector<TestParams> GetTestParams() {
-  vector<TestParams> params;
+std::vector<TestParams> GetTestParams() {
+  std::vector<TestParams> params;
   QuicVersionVector all_supported_versions = AllSupportedVersions();
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
     params.push_back(TestParams(all_supported_versions[i]));
   }
   return params;
 }
 
 class QuicReceivedPacketManagerTest
     : public ::testing::TestWithParam<TestParams> {
  protected:
@@ skipping 20 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(QuicReceivedPacketManagerTest,
                         QuicReceivedPacketManagerTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicReceivedPacketManagerTest, ReceivedPacketEntropyHash) {
   if (GetParam().version > QUIC_VERSION_33) {
     return;
   }
-  vector<pair<QuicPacketNumber, QuicPacketEntropyHash>> entropies;
+  std::vector<std::pair<QuicPacketNumber, QuicPacketEntropyHash>> entropies;
   entropies.push_back(std::make_pair(1, 12));
   entropies.push_back(std::make_pair(7, 1));
   entropies.push_back(std::make_pair(2, 33));
   entropies.push_back(std::make_pair(5, 3));
   entropies.push_back(std::make_pair(8, 34));
 
   for (size_t i = 0; i < entropies.size(); ++i) {
     RecordPacketReceipt(entropies[i].first, entropies[i].second);
   }
 
@@ skipping 31 matching lines @@
   }
   EXPECT_EQ(0, received_manager_.EntropyHash(0));
   RecordPacketReceipt(4, 5);
   EXPECT_EQ(0, received_manager_.EntropyHash(3));
 }
 
 TEST_P(QuicReceivedPacketManagerTest, SetCumulativeEntropyUpTo) {
   if (GetParam().version > QUIC_VERSION_33) {
     return;
   }
-  vector<pair<QuicPacketNumber, QuicPacketEntropyHash>> entropies;
+  std::vector<std::pair<QuicPacketNumber, QuicPacketEntropyHash>> entropies;
   entropies.push_back(std::make_pair(1, 12));
   entropies.push_back(std::make_pair(2, 1));
   entropies.push_back(std::make_pair(3, 33));
   entropies.push_back(std::make_pair(4, 3));
   entropies.push_back(std::make_pair(6, 34));
   entropies.push_back(std::make_pair(7, 29));
 
   QuicPacketEntropyHash entropy_hash = 0;
   for (size_t i = 0; i < entropies.size(); ++i) {
     RecordPacketReceipt(entropies[i].first, entropies[i].second);
@@ skipping 82 matching lines @@
                       QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1));
 
   EXPECT_EQ(4u, stats_.max_sequence_reordering);
   EXPECT_EQ(1000, stats_.max_time_reordering_us);
   EXPECT_EQ(1u, stats_.packets_reordered);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net