adds std:: to stl types

net/quic/core/quic_connection_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_connection.h"
 
 #include <errno.h>
 #include <memory>
 #include <ostream>
 #include <utility>
@@ skipping 351 matching lines @@
 
   // Sets the amount of time that the writer should before the actual write.
   void SetWritePauseTimeDelta(QuicTime::Delta delta) {
     write_pause_time_delta_ = delta;
   }
 
   const QuicPacketHeader& header() { return framer_.header(); }
 
   size_t frame_count() const { return framer_.num_frames(); }
 
-  const vector<QuicAckFrame>& ack_frames() const {
+  const std::vector<QuicAckFrame>& ack_frames() const {
     return framer_.ack_frames();
   }
 
-  const vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
+  const std::vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
     return framer_.stop_waiting_frames();
   }
 
-  const vector<QuicConnectionCloseFrame>& connection_close_frames() const {
+  const std::vector<QuicConnectionCloseFrame>& connection_close_frames() const {
     return framer_.connection_close_frames();
   }
 
-  const vector<QuicRstStreamFrame>& rst_stream_frames() const {
+  const std::vector<QuicRstStreamFrame>& rst_stream_frames() const {
     return framer_.rst_stream_frames();
   }
 
-  const vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const {
+  const std::vector<std::unique_ptr<QuicStreamFrame>>& stream_frames() const {
     return framer_.stream_frames();
   }
 
-  const vector<QuicPingFrame>& ping_frames() const {
+  const std::vector<QuicPingFrame>& ping_frames() const {
     return framer_.ping_frames();
   }
 
   size_t last_packet_size() { return last_packet_size_; }
 
   const QuicVersionNegotiationPacket* version_negotiation_packet() {
     return framer_.version_negotiation_packet();
   }
 
   void set_is_write_blocked_data_buffered(bool buffered) {
@@ skipping 254 matching lines @@
        << (p.ack_response == AckResponse::kDefer ? "defer" : "immediate")
        << " }";
     return os;
   }
 
   QuicVersion version;
   AckResponse ack_response;
 };
 
 // Constructs various test permutations.
-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) {
     for (AckResponse ack_response :
          {AckResponse::kDefer, AckResponse::kImmediate}) {
       params.push_back(TestParams(all_supported_versions[i], ack_response));
     }
   }
   return params;
 }
 
@@ skipping 742 matching lines @@
 
 TEST_P(QuicConnectionTest, RejectUnencryptedStreamData) {
   // Process an unencrypted packet from the non-crypto stream.
   frame1_.stream_id = 3;
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_UNENCRYPTED_STREAM_DATA, _,
                                            ConnectionCloseSource::FROM_SELF));
   EXPECT_QUIC_BUG(ProcessDataPacket(kDefaultPathId, 1, !kEntropyFlag), "");
   EXPECT_FALSE(QuicConnectionPeer::GetConnectionClosePacket(&connection_) ==
                nullptr);
-  const vector<QuicConnectionCloseFrame>& connection_close_frames =
+  const std::vector<QuicConnectionCloseFrame>& connection_close_frames =
       writer_->connection_close_frames();
   EXPECT_EQ(1u, connection_close_frames.size());
   EXPECT_EQ(QUIC_UNENCRYPTED_STREAM_DATA,
             connection_close_frames[0].error_code);
 }
 
 TEST_P(QuicConnectionTest, TruncatedAck) {
   if (GetParam().version > QUIC_VERSION_33) {
     return;
   }
@@ skipping 1669 matching lines @@
   QuicConnectionPeer::SetPacketsBetweenMtuProbes(&connection_,
                                                  packets_between_probes_base);
   QuicConnectionPeer::SetNextMtuProbeAt(&connection_,
                                         packets_between_probes_base);
 
   // This tests sends more packets than strictly necessary to make sure that if
   // the connection was to send more discovery packets than needed, those would
   // get caught as well.
   const QuicPacketCount number_of_packets =
       packets_between_probes_base * (1 << (kMtuDiscoveryAttempts + 1));
-  vector<QuicPacketNumber> mtu_discovery_packets;
+  std::vector<QuicPacketNumber> mtu_discovery_packets;
   // Called by the first ack.
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   // Called on many acks.
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _))
       .Times(AnyNumber());
   for (QuicPacketCount i = 0; i < number_of_packets; i++) {
     SendStreamDataToPeer(3, "!", i, /*fin=*/false, nullptr);
     clock_.AdvanceTime(rtt);
 
     // Receive an ACK, which marks all data packets as received, and all MTU
@@ skipping 2181 matching lines @@
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_FALSE(writer_->connection_close_frames().empty());
   // Ack frame is not bundled in connection close packet.
   EXPECT_TRUE(writer_->ack_frames().empty());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net