adds std:: to stl types (#049)

net/tools/quic/quic_dispatcher_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/tools/quic/quic_dispatcher.h"
 
 #include <memory>
 #include <ostream>
 #include <string>
 
@@ skipping 28 matching lines @@
 
 using base::IntToString;
 using base::StringPiece;
 using net::EpollServer;
 using net::test::ConstructEncryptedPacket;
 using net::test::CryptoTestUtils;
 using net::test::MockQuicConnection;
 using net::test::MockQuicConnectionHelper;
 using std::ostream;
 using std::string;
-using std::vector;
 using testing::CreateFunctor;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Return;
 using testing::WithoutArgs;
 using testing::_;
 
 static const size_t kDefaultMaxConnectionsInStore = 100;
 static const size_t kMaxConnectionsWithoutCHLO =
@@ skipping 520 matching lines @@
   // This only enables the stateless reject feature via the feature-flag.
   // This should be a no-op if the peer does not support them.
   bool enable_stateless_rejects_via_flag;
   // Whether or not the client supports stateless rejects.
   bool client_supports_statelesss_rejects;
   // Should the initial crypto handshake succeed or not.
   bool crypto_handshake_successful;
 };
 
 // Constructs various test permutations for stateless rejects.
-vector<StatelessRejectTestParams> GetStatelessRejectTestParams() {
-  vector<StatelessRejectTestParams> params;
+std::vector<StatelessRejectTestParams> GetStatelessRejectTestParams() {
+  std::vector<StatelessRejectTestParams> params;
   for (bool enable_stateless_rejects_via_flag : {true, false}) {
     for (bool client_supports_statelesss_rejects : {true, false}) {
       for (bool crypto_handshake_successful : {true, false}) {
         params.push_back(StatelessRejectTestParams(
             enable_stateless_rejects_via_flag,
             client_supports_statelesss_rejects, crypto_handshake_successful));
       }
     }
   }
   return params;
@@ skipping 474 matching lines @@
     return os;
   }
 
   // This only enables the stateless reject feature via the feature-flag.
   // This should be a no-op if the peer does not support them.
   bool enable_stateless_rejects_via_flag;
   // Whether to do cheap stateless or not.
   bool support_cheap_stateless_reject;
 };
 
-vector<BufferedPacketStoreTestParams> GetBufferedPacketStoreTestParams() {
-  vector<BufferedPacketStoreTestParams> params;
+std::vector<BufferedPacketStoreTestParams> GetBufferedPacketStoreTestParams() {
+  std::vector<BufferedPacketStoreTestParams> params;
   for (bool enable_stateless_rejects_via_flag : {true, false}) {
     for (bool support_cheap_stateless_reject : {true, false}) {
       params.push_back(BufferedPacketStoreTestParams(
           enable_stateless_rejects_via_flag, support_cheap_stateless_reject));
     }
   }
   return params;
 }
 
 // A dispatcher whose stateless rejector will always ACCEPTs CHLO.
@@ skipping 926 matching lines @@
   check.Call(2);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
   EXPECT_FALSE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net