Adds std:: to stl types (#049)

net/quic/core/crypto/cert_compressor.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 "net/quic/core/crypto/cert_compressor.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/logging.h"
 #include "net/quic/core/quic_utils.h"
 #include "third_party/zlib/zlib.h"
 
 using base::StringPiece;
 using std::string;
-using std::vector;
 
 namespace net {
 
 namespace {
 
 // kCommonCertSubstrings contains ~1500 bytes of common certificate substrings
 // in order to help zlib. This was generated via a fairly dumb algorithm from
 // the Alexa Top 5000 set - we could probably do better.
 static const unsigned char kCommonCertSubstrings[] = {
     0x04, 0x02, 0x30, 0x00, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04,
@@ skipping 143 matching lines @@
   Type type;
   uint64_t hash;
   uint64_t set_hash;
   uint32_t index;
 };
 
 // MatchCerts returns a vector of CertEntries describing how to most
 // efficiently represent |certs| to a peer who has the common sets identified
 // by |client_common_set_hashes| and who has cached the certificates with the
 // 64-bit, FNV-1a hashes in |client_cached_cert_hashes|.
-vector<CertEntry> MatchCerts(const vector<string>& certs,
-                             StringPiece client_common_set_hashes,
-                             StringPiece client_cached_cert_hashes,
-                             const CommonCertSets* common_sets) {
-  vector<CertEntry> entries;
+std::vector<CertEntry> MatchCerts(const std::vector<string>& certs,
+                                  StringPiece client_common_set_hashes,
+                                  StringPiece client_cached_cert_hashes,
+                                  const CommonCertSets* common_sets) {
+  std::vector<CertEntry> entries;
   entries.reserve(certs.size());
 
   const bool cached_valid =
       client_cached_cert_hashes.size() % sizeof(uint64_t) == 0 &&
       !client_cached_cert_hashes.empty();
 
-  for (vector<string>::const_iterator i = certs.begin(); i != certs.end();
+  for (std::vector<string>::const_iterator i = certs.begin(); i != certs.end();
        ++i) {
     CertEntry entry;
 
     if (cached_valid) {
       bool cached = false;
 
       uint64_t hash = QuicUtils::FNV1a_64_Hash(i->data(), i->size());
       // This assumes that the machine is little-endian.
       for (size_t j = 0; j < client_cached_cert_hashes.size();
            j += sizeof(uint64_t)) {
@@ skipping 26 matching lines @@
 
     entry.type = CertEntry::COMPRESSED;
     entries.push_back(entry);
   }
 
   return entries;
 }
 
 // CertEntriesSize returns the size, in bytes, of the serialised form of
 // |entries|.
-size_t CertEntriesSize(const vector<CertEntry>& entries) {
+size_t CertEntriesSize(const std::vector<CertEntry>& entries) {
   size_t entries_size = 0;
 
-  for (vector<CertEntry>::const_iterator i = entries.begin();
+  for (std::vector<CertEntry>::const_iterator i = entries.begin();
        i != entries.end(); ++i) {
     entries_size++;
     switch (i->type) {
       case CertEntry::COMPRESSED:
         break;
       case CertEntry::CACHED:
         entries_size += sizeof(uint64_t);
         break;
       case CertEntry::COMMON:
         entries_size += sizeof(uint64_t) + sizeof(uint32_t);
         break;
     }
   }
 
   entries_size++;  // for end marker
 
   return entries_size;
 }
 
 // SerializeCertEntries serialises |entries| to |out|, which must have enough
 // space to contain them.
-void SerializeCertEntries(uint8_t* out, const vector<CertEntry>& entries) {
-  for (vector<CertEntry>::const_iterator i = entries.begin();
+void SerializeCertEntries(uint8_t* out, const std::vector<CertEntry>& entries) {
+  for (std::vector<CertEntry>::const_iterator i = entries.begin();
        i != entries.end(); ++i) {
     *out++ = static_cast<uint8_t>(i->type);
     switch (i->type) {
       case CertEntry::COMPRESSED:
         break;
       case CertEntry::CACHED:
         memcpy(out, &i->hash, sizeof(i->hash));
         out += sizeof(uint64_t);
         break;
       case CertEntry::COMMON:
         // Assumes a little-endian machine.
         memcpy(out, &i->set_hash, sizeof(i->set_hash));
         out += sizeof(i->set_hash);
         memcpy(out, &i->index, sizeof(uint32_t));
         out += sizeof(uint32_t);
         break;
     }
   }
 
   *out++ = 0;  // end marker
 }
 
 // ZlibDictForEntries returns a string that contains the zlib pre-shared
 // dictionary to use in order to decompress a zlib block following |entries|.
 // |certs| is one-to-one with |entries| and contains the certificates for those
 // entries that are CACHED or COMMON.
-string ZlibDictForEntries(const vector<CertEntry>& entries,
-                          const vector<string>& certs) {
+string ZlibDictForEntries(const std::vector<CertEntry>& entries,
+                          const std::vector<string>& certs) {
   string zlib_dict;
 
   // The dictionary starts with the common and cached certs in reverse order.
   size_t zlib_dict_size = 0;
   for (size_t i = certs.size() - 1; i < certs.size(); i--) {
     if (entries[i].type != CertEntry::COMPRESSED) {
       zlib_dict_size += certs[i].size();
     }
   }
 
@@ skipping 10 matching lines @@
 
   zlib_dict += string(reinterpret_cast<const char*>(kCommonCertSubstrings),
                       sizeof(kCommonCertSubstrings));
 
   DCHECK_EQ(zlib_dict.size(), zlib_dict_size);
 
   return zlib_dict;
 }
 
 // HashCerts returns the FNV-1a hashes of |certs|.
-vector<uint64_t> HashCerts(const vector<string>& certs) {
-  vector<uint64_t> ret;
+std::vector<uint64_t> HashCerts(const std::vector<string>& certs) {
+  std::vector<uint64_t> ret;
   ret.reserve(certs.size());
 
-  for (vector<string>::const_iterator i = certs.begin(); i != certs.end();
+  for (std::vector<string>::const_iterator i = certs.begin(); i != certs.end();
        ++i) {
     ret.push_back(QuicUtils::FNV1a_64_Hash(i->data(), i->size()));
   }
 
   return ret;
 }
 
 // ParseEntries parses the serialised form of a vector of CertEntries from
 // |in_out| and writes them to |out_entries|. CACHED and COMMON entries are
 // resolved using |cached_certs| and |common_sets| and written to |out_certs|.
 // |in_out| is updated to contain the trailing data.
 bool ParseEntries(StringPiece* in_out,
-                  const vector<string>& cached_certs,
+                  const std::vector<string>& cached_certs,
                   const CommonCertSets* common_sets,
-                  vector<CertEntry>* out_entries,
-                  vector<string>* out_certs) {
+                  std::vector<CertEntry>* out_entries,
+                  std::vector<string>* out_certs) {
   StringPiece in = *in_out;
-  vector<uint64_t> cached_hashes;
+  std::vector<uint64_t> cached_hashes;
 
   out_entries->clear();
   out_certs->clear();
 
   for (;;) {
     if (in.empty()) {
       return false;
     }
     CertEntry entry;
     const uint8_t type_byte = in[0];
@@ skipping 92 matching lines @@
     z_ = nullptr;
   }
 
   z_stream* z_;
   const Type type_;
 };
 
 }  // anonymous namespace
 
 // static
-string CertCompressor::CompressChain(const vector<string>& certs,
+string CertCompressor::CompressChain(const std::vector<string>& certs,
                                      StringPiece client_common_set_hashes,
                                      StringPiece client_cached_cert_hashes,
                                      const CommonCertSets* common_sets) {
-  const vector<CertEntry> entries = MatchCerts(
+  const std::vector<CertEntry> entries = MatchCerts(
       certs, client_common_set_hashes, client_cached_cert_hashes, common_sets);
   DCHECK_EQ(entries.size(), certs.size());
 
   size_t uncompressed_size = 0;
   for (size_t i = 0; i < entries.size(); i++) {
     if (entries[i].type == CertEntry::COMPRESSED) {
       uncompressed_size += 4 /* uint32_t length */ + certs[i].size();
     }
   }
 
@@ skipping 77 matching lines @@
   if (rv != Z_STREAM_END) {
     return "";
   }
 
   result.resize(result.size() - z.avail_out);
   return result;
 }
 
 // static
 bool CertCompressor::DecompressChain(StringPiece in,
-                                     const vector<string>& cached_certs,
+                                     const std::vector<string>& cached_certs,
                                      const CommonCertSets* common_sets,
-                                     vector<string>* out_certs) {
-  vector<CertEntry> entries;
+                                     std::vector<string>* out_certs) {
+  std::vector<CertEntry> entries;
   if (!ParseEntries(&in, cached_certs, common_sets, &entries, out_certs)) {
     return false;
   }
   DCHECK_EQ(entries.size(), out_certs->size());
 
   std::unique_ptr<uint8_t[]> uncompressed_data;
   StringPiece uncompressed;
 
   if (!in.empty()) {
     if (in.size() < sizeof(uint32_t)) {
@@ skipping 64 matching lines @@
   }
 
   if (!uncompressed.empty()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace net