Adds std:: to stl types (#049)

net/quic/core/crypto/quic_crypto_client_config.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/crypto/quic_crypto_client_config.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/quic/core/crypto/cert_compressor.h"
 #include "net/quic/core/crypto/chacha20_poly1305_encrypter.h"
 #include "net/quic/core/crypto/channel_id.h"
 #include "net/quic/core/crypto/common_cert_set.h"
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/crypto/curve25519_key_exchange.h"
 #include "net/quic/core/crypto/key_exchange.h"
 #include "net/quic/core/crypto/p256_key_exchange.h"
 #include "net/quic/core/crypto/proof_verifier.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 
 using base::StringPiece;
-using std::map;
 using std::string;
-using std::queue;
-using std::vector;
 
 namespace net {
 
 namespace {
 
 // Tracks the reason (the state of the server config) for sending inchoate
 // ClientHello to the server.
 void RecordInchoateClientHelloReason(
     QuicCryptoClientConfig::CachedState::ServerConfigState state) {
   UMA_HISTOGRAM_ENUMERATION(
@@ skipping 141 matching lines @@
     SetProofInvalid();
     scfg_.reset(new_scfg_storage.release());
   }
   return SERVER_CONFIG_VALID;
 }
 
 void QuicCryptoClientConfig::CachedState::InvalidateServerConfig() {
   server_config_.clear();
   scfg_.reset();
   SetProofInvalid();
-  queue<QuicConnectionId> empty_queue;
+  std::queue<QuicConnectionId> empty_queue;
   swap(server_designated_connection_ids_, empty_queue);
 }
 
-void QuicCryptoClientConfig::CachedState::SetProof(const vector<string>& certs,
-                                                   StringPiece cert_sct,
-                                                   StringPiece chlo_hash,
-                                                   StringPiece signature) {
+void QuicCryptoClientConfig::CachedState::SetProof(
+    const std::vector<string>& certs,
+    StringPiece cert_sct,
+    StringPiece chlo_hash,
+    StringPiece signature) {
   bool has_changed = signature != server_config_sig_ ||
                      chlo_hash != chlo_hash_ || certs_.size() != certs.size();
 
   if (!has_changed) {
     for (size_t i = 0; i < certs_.size(); i++) {
       if (certs_[i] != certs[i]) {
         has_changed = true;
         break;
       }
     }
@@ skipping 15 matching lines @@
   server_config_.clear();
   source_address_token_.clear();
   certs_.clear();
   cert_sct_.clear();
   chlo_hash_.clear();
   server_config_sig_.clear();
   server_config_valid_ = false;
   proof_verify_details_.reset();
   scfg_.reset();
   ++generation_counter_;
-  queue<QuicConnectionId> empty_queue;
+  std::queue<QuicConnectionId> empty_queue;
   swap(server_designated_connection_ids_, empty_queue);
 }
 
 void QuicCryptoClientConfig::CachedState::ClearProof() {
   SetProofInvalid();
   certs_.clear();
   cert_sct_.clear();
   chlo_hash_.clear();
   server_config_sig_.clear();
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofValid() {
   server_config_valid_ = true;
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofInvalid() {
   server_config_valid_ = false;
   ++generation_counter_;
 }
 
 bool QuicCryptoClientConfig::CachedState::Initialize(
     StringPiece server_config,
     StringPiece source_address_token,
-    const vector<string>& certs,
-    StringPiece cert_sct,
+    const std::vector<string>& certs,
+    const string& cert_sct,
     StringPiece chlo_hash,
     StringPiece signature,
     QuicWallTime now,
     QuicWallTime expiration_time) {
   DCHECK(server_config_.empty());
 
   if (server_config.empty()) {
     RecordDiskCacheServerConfigState(SERVER_CONFIG_EMPTY);
     return false;
   }
 
   string error_details;
   ServerConfigState state =
       SetServerConfig(server_config, now, expiration_time, &error_details);
   RecordDiskCacheServerConfigState(state);
   if (state != SERVER_CONFIG_VALID) {
     DVLOG(1) << "SetServerConfig failed with " << error_details;
     return false;
   }
 
+  chlo_hash.CopyToString(&chlo_hash_);
   signature.CopyToString(&server_config_sig_);
   source_address_token.CopyToString(&source_address_token_);
-  cert_sct.CopyToString(&cert_sct_);
-  chlo_hash.CopyToString(&chlo_hash_);
   certs_ = certs;
+  cert_sct_ = cert_sct;
   return true;
 }
 
 const string& QuicCryptoClientConfig::CachedState::server_config() const {
   return server_config_;
 }
 
 const string& QuicCryptoClientConfig::CachedState::source_address_token()
     const {
   return source_address_token_;
 }
 
-const vector<string>& QuicCryptoClientConfig::CachedState::certs() const {
+const std::vector<string>& QuicCryptoClientConfig::CachedState::certs() const {
   return certs_;
 }
 
 const string& QuicCryptoClientConfig::CachedState::cert_sct() const {
   return cert_sct_;
 }
 
 const string& QuicCryptoClientConfig::CachedState::chlo_hash() const {
   return chlo_hash_;
 }
@@ skipping 149 matching lines @@
   out->SetStringPiece(kNONP, StringPiece(proof_nonce, arraysize(proof_nonce)));
 
   out->SetVector(kPDMD, QuicTagVector{kX509});
 
   if (common_cert_sets) {
     out->SetStringPiece(kCCS, common_cert_sets->GetCommonHashes());
   }
 
   out->SetStringPiece(kCertificateSCTTag, "");
 
-  const vector<string>& certs = cached->certs();
+  const std::vector<string>& certs = cached->certs();
   // We save |certs| in the QuicCryptoNegotiatedParameters so that, if the
   // client config is being used for multiple connections, another connection
   // doesn't update the cached certificates and cause us to be unable to
   // process the server's compressed certificate chain.
   out_params->cached_certs = certs;
   if (!certs.empty()) {
-    vector<uint64_t> hashes;
+    std::vector<uint64_t> hashes;
     hashes.reserve(certs.size());
-    for (vector<string>::const_iterator i = certs.begin(); i != certs.end();
-         ++i) {
+    for (std::vector<string>::const_iterator i = certs.begin();
+         i != certs.end(); ++i) {
       hashes.push_back(QuicUtils::FNV1a_64_Hash(i->data(), i->size()));
     }
     out->SetVector(kCCRT, hashes);
   }
 }
 
 QuicErrorCode QuicCryptoClientConfig::FillClientHello(
     const QuicServerId& server_id,
     QuicConnectionId connection_id,
     const QuicVersion actual_version,
@@ skipping 113 matching lines @@
       return QUIC_CRYPTO_INTERNAL_ERROR;
   }
 
   if (!out_params->client_key_exchange->CalculateSharedKey(
           public_value, &out_params->initial_premaster_secret)) {
     *error_details = "Key exchange failure";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
   out->SetStringPiece(kPUBS, out_params->client_key_exchange->public_value());
 
-  const vector<string>& certs = cached->certs();
+  const std::vector<string>& certs = cached->certs();
   if (certs.empty()) {
     *error_details = "No certs to calculate XLCT";
     return QUIC_CRYPTO_INTERNAL_ERROR;
   }
   out->SetValue(kXLCT, CryptoUtils::ComputeLeafCertHash(certs[0]));
 
   if (channel_id_key) {
     // In order to calculate the encryption key for the CETV block we need to
     // serialise the client hello as it currently is (i.e. without the CETV
     // block). For this, the client hello is serialized without padding.
@@ skipping 93 matching lines @@
   }
 
   return QUIC_NO_ERROR;
 }
 
 QuicErrorCode QuicCryptoClientConfig::CacheNewServerConfig(
     const CryptoHandshakeMessage& message,
     QuicWallTime now,
     QuicVersion version,
     StringPiece chlo_hash,
-    const vector<string>& cached_certs,
+    const std::vector<string>& cached_certs,
     CachedState* cached,
     string* error_details) {
   DCHECK(error_details != nullptr);
 
   StringPiece scfg;
   if (!message.GetStringPiece(kSCFG, &scfg)) {
     *error_details = "Missing SCFG";
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
   }
 
@@ skipping 16 matching lines @@
 
   StringPiece token;
   if (message.GetStringPiece(kSourceAddressTokenTag, &token)) {
     cached->set_source_address_token(token);
   }
 
   StringPiece proof, cert_bytes, cert_sct;
   bool has_proof = message.GetStringPiece(kPROF, &proof);
   bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes);
   if (has_proof && has_cert) {
-    vector<string> certs;
+    std::vector<string> certs;
     if (!CertCompressor::DecompressChain(cert_bytes, cached_certs,
                                          common_cert_sets, &certs)) {
       *error_details = "Certificate data invalid";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
     message.GetStringPiece(kCertificateSCTTag, &cert_sct);
     cached->SetProof(certs, cert_sct, chlo_hash, proof);
   } else {
     // Secure QUIC: clear existing proof as we have been sent a new SCFG
@@ skipping 211 matching lines @@
   }
 
   // Update canonical version to point at the "most recent" entry.
   canonical_server_map_[suffix_server_id] = server_id;
 
   server_state->InitializeFrom(*canonical_state);
   return true;
 }
 
 }  // namespace net