adds std:: to stl types

net/quic/core/quic_framer_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 "net/quic/core/quic_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 304 matching lines @@
   int packet_count_;
   int frame_count_;
   int complete_packets_;
   bool accept_packet_;
   bool accept_public_header_;
 
   std::unique_ptr<QuicPacketHeader> header_;
   std::unique_ptr<QuicPacketPublicHeader> public_header_;
   std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
   std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
-  vector<std::unique_ptr<QuicStreamFrame>> stream_frames_;
-  vector<std::unique_ptr<QuicAckFrame>> ack_frames_;
-  vector<std::unique_ptr<QuicStopWaitingFrame>> stop_waiting_frames_;
-  vector<std::unique_ptr<QuicPaddingFrame>> padding_frames_;
-  vector<std::unique_ptr<QuicPingFrame>> ping_frames_;
+  std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames_;
+  std::vector<std::unique_ptr<QuicAckFrame>> ack_frames_;
+  std::vector<std::unique_ptr<QuicStopWaitingFrame>> stop_waiting_frames_;
+  std::vector<std::unique_ptr<QuicPaddingFrame>> padding_frames_;
+  std::vector<std::unique_ptr<QuicPingFrame>> ping_frames_;
   QuicRstStreamFrame rst_stream_frame_;
   QuicConnectionCloseFrame connection_close_frame_;
   QuicGoAwayFrame goaway_frame_;
   QuicWindowUpdateFrame window_update_frame_;
   QuicBlockedFrame blocked_frame_;
   QuicPathCloseFrame path_close_frame_;
-  vector<std::unique_ptr<string>> stream_data_;
+  std::vector<std::unique_ptr<string>> stream_data_;
 };
 
 class QuicFramerTest : public ::testing::TestWithParam<QuicVersion> {
  public:
   QuicFramerTest()
       : encrypter_(new test::TestEncrypter()),
         decrypter_(new test::TestDecrypter()),
         start_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(0x10)),
         framer_(AllSupportedVersions(), start_, Perspective::IS_SERVER) {
     version_ = GetParam();
@@ skipping 228 matching lines @@
 
     // but large numbers should not (even if they're out of order).
     for (uint64_t j = 0; j < 10; j++) {
       uint64_t num = kEpoch - 1 - j;
       CheckCalculatePacketNumber(cur_epoch + num, last);
     }
   }
 }
 
 TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearNextMax) {
-  const uint64_t max_number = numeric_limits<uint64_t>::max();
+  const uint64_t max_number = std::numeric_limits<uint64_t>::max();
   const uint64_t max_epoch = max_number & ~kMask;
 
   // Cases where the last number was close to the end of the range
   for (uint64_t i = 0; i < 10; i++) {
     // Subtract 1, because the expected next packet number is 1 more than the
     // last packet number.
     QuicPacketNumber last = max_number - i - 1;
 
     // Small numbers should not wrap, because they have nowhere to go.
     for (uint64_t j = 0; j < 10; j++) {
@@ skipping 5877 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net