Adds std:: to stl types (#049)

net/quic/core/crypto/crypto_server_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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <vector>
 
@@ skipping 15 matching lines @@
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_crypto_server_config_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::endl;
 using std::ostream;
 using std::string;
-using std::vector;
 
 namespace net {
 namespace test {
 
 namespace {
 
 class DummyProofVerifierCallback : public ProofVerifierCallback {
  public:
   DummyProofVerifierCallback() {}
   ~DummyProofVerifierCallback() override {}
@@ skipping 31 matching lines @@
   bool enable_stateless_rejects;
   // If true, this forces the server to send a stateless reject when
   // rejecting messages.  This should be a no-op if
   // enable_stateless_rejects is false.
   bool use_stateless_rejects;
   // Versions supported by client and server.
   QuicVersionVector supported_versions;
 };
 
 // Constructs various test permutations.
-vector<TestParams> GetTestParams() {
-  vector<TestParams> params;
+std::vector<TestParams> GetTestParams() {
+  std::vector<TestParams> params;
   static const bool kTrueFalse[] = {true, false};
   for (bool enable_stateless_rejects : kTrueFalse) {
     for (bool use_stateless_rejects : kTrueFalse) {
       // Start with all versions, remove highest on each iteration.
       QuicVersionVector supported_versions = AllSupportedVersions();
       while (!supported_versions.empty()) {
         params.push_back(TestParams(enable_stateless_rejects,
                                     use_stateless_rejects, supported_versions));
         supported_versions.erase(supported_versions.begin());
       }
@@ skipping 803 matching lines @@
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kSCFG, &scfg_str));
   std::unique_ptr<CryptoHandshakeMessage> scfg(
       CryptoFramer::ParseMessage(scfg_str));
   StringPiece scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   EXPECT_NE(scid, kOldConfigId);
 
   // Get certs from compressed certs.
   const CommonCertSets* common_cert_sets(CommonCertSets::GetInstanceQUIC());
-  vector<string> cached_certs;
+  std::vector<string> cached_certs;
 
-  vector<string> certs;
+  std::vector<string> certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(cert, cached_certs,
                                               common_cert_sets, &certs));
 
   // Check that the proof in the REJ message is valid.
   std::unique_ptr<ProofVerifier> proof_verifier(
       CryptoTestUtils::ProofVerifierForTesting());
   std::unique_ptr<ProofVerifyContext> verify_context(
       CryptoTestUtils::ProofVerifyContextForTesting());
   std::unique_ptr<ProofVerifyDetails> details;
   string error_details;
@@ skipping 355 matching lines @@
     EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   } else {
     // version 33.
     ASSERT_EQ(kSHLO, out_.tag());
     CheckServerHello(out_);
   }
 }
 
 }  // namespace test
 }  // namespace net