Switch to standard integer types in net/.

net/quic/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/crypto/cert_compressor.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/quic_utils.h"
 #include "third_party/zlib/zlib.h"
@@ skipping 148 matching lines @@
     COMPRESSED = 1,
     // CACHED means that the certificate is already known to the peer and will
     // be replaced by its 64-bit hash (in |hash|).
     CACHED = 2,
     // COMMON means that the certificate is in a common certificate set known
     // to the peer with hash |set_hash| and certificate index |index|.
     COMMON = 3,
   };
 
   Type type;
-  uint64 hash;
-  uint64 set_hash;
-  uint32 index;
+  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;
   entries.reserve(certs.size());
 
   const bool cached_valid =
-      client_cached_cert_hashes.size() % sizeof(uint64) == 0 &&
+      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();
        ++i) {
     CertEntry entry;
 
     if (cached_valid) {
       bool cached = false;
 
-      uint64 hash = QuicUtils::FNV1a_64_Hash(i->data(), i->size());
+      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)) {
-        uint64 cached_hash;
+           j += sizeof(uint64_t)) {
+        uint64_t cached_hash;
         memcpy(&cached_hash, client_cached_cert_hashes.data() + j,
-               sizeof(uint64));
+               sizeof(uint64_t));
         if (hash != cached_hash) {
           continue;
         }
 
         entry.type = CertEntry::CACHED;
         entry.hash = hash;
         entries.push_back(entry);
         cached = true;
         break;
       }
@@ skipping 23 matching lines @@
 size_t CertEntriesSize(const vector<CertEntry>& entries) {
   size_t entries_size = 0;
 
   for (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);
+        entries_size += sizeof(uint64_t);
         break;
       case CertEntry::COMMON:
-        entries_size += sizeof(uint64) + sizeof(uint32);
+        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* out, const vector<CertEntry>& entries) {
+void SerializeCertEntries(uint8_t* out, const vector<CertEntry>& entries) {
   for (vector<CertEntry>::const_iterator i = entries.begin();
        i != entries.end(); ++i) {
-    *out++ = static_cast<uint8>(i->type);
+    *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);
+        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));
-        out += sizeof(uint32);
+        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
@@ skipping 23 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> HashCerts(const vector<string>& certs) {
-  vector<uint64> ret;
+vector<uint64_t> HashCerts(const vector<string>& certs) {
+  vector<uint64_t> ret;
   ret.reserve(certs.size());
 
   for (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 CommonCertSets* common_sets,
                   vector<CertEntry>* out_entries,
                   vector<string>* out_certs) {
   StringPiece in = *in_out;
-  vector<uint64> cached_hashes;
+  vector<uint64_t> cached_hashes;
 
   out_entries->clear();
   out_certs->clear();
 
   for (;;) {
     if (in.empty()) {
       return false;
     }
     CertEntry entry;
-    const uint8 type_byte = in[0];
+    const uint8_t type_byte = in[0];
     in.remove_prefix(1);
 
     if (type_byte == 0) {
       break;
     }
 
     entry.type = static_cast<CertEntry::Type>(type_byte);
 
     switch (entry.type) {
       case CertEntry::COMPRESSED:
         out_certs->push_back(string());
         break;
       case CertEntry::CACHED: {
-        if (in.size() < sizeof(uint64)) {
+        if (in.size() < sizeof(uint64_t)) {
           return false;
         }
-        memcpy(&entry.hash, in.data(), sizeof(uint64));
-        in.remove_prefix(sizeof(uint64));
+        memcpy(&entry.hash, in.data(), sizeof(uint64_t));
+        in.remove_prefix(sizeof(uint64_t));
 
         if (cached_hashes.size() != cached_certs.size()) {
           cached_hashes = HashCerts(cached_certs);
         }
         bool found = false;
         for (size_t i = 0; i < cached_hashes.size(); i++) {
           if (cached_hashes[i] == entry.hash) {
             out_certs->push_back(cached_certs[i]);
             found = true;
             break;
           }
         }
         if (!found) {
           return false;
         }
         break;
       }
       case CertEntry::COMMON: {
         if (!common_sets) {
           return false;
         }
-        if (in.size() < sizeof(uint64) + sizeof(uint32)) {
+        if (in.size() < sizeof(uint64_t) + sizeof(uint32_t)) {
           return false;
         }
-        memcpy(&entry.set_hash, in.data(), sizeof(uint64));
-        in.remove_prefix(sizeof(uint64));
-        memcpy(&entry.index, in.data(), sizeof(uint32));
-        in.remove_prefix(sizeof(uint32));
+        memcpy(&entry.set_hash, in.data(), sizeof(uint64_t));
+        in.remove_prefix(sizeof(uint64_t));
+        memcpy(&entry.index, in.data(), sizeof(uint32_t));
+        in.remove_prefix(sizeof(uint32_t));
 
         StringPiece cert = common_sets->GetCert(entry.set_hash, entry.index);
         if (cert.empty()) {
           return false;
         }
         out_certs->push_back(cert.as_string());
         break;
       }
       default:
         return false;
@@ skipping 47 matching lines @@
                                      StringPiece client_common_set_hashes,
                                      StringPiece client_cached_cert_hashes,
                                      const CommonCertSets* common_sets) {
   const 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 length */ + certs[i].size();
+      uncompressed_size += 4 /* uint32_t length */ + certs[i].size();
     }
   }
 
   size_t compressed_size = 0;
   z_stream z;
   ScopedZLib scoped_z(ScopedZLib::DEFLATE);
 
   if (uncompressed_size > 0) {
     memset(&z, 0, sizeof(z));
     int rv = deflateInit(&z, Z_DEFAULT_COMPRESSION);
     DCHECK_EQ(Z_OK, rv);
     if (rv != Z_OK) {
       return "";
     }
     scoped_z.reset(&z);
 
     string zlib_dict = ZlibDictForEntries(entries, certs);
 
-    rv = deflateSetDictionary(&z, reinterpret_cast<const uint8*>(&zlib_dict[0]),
-                              zlib_dict.size());
+    rv = deflateSetDictionary(
+        &z, reinterpret_cast<const uint8_t*>(&zlib_dict[0]), zlib_dict.size());
     DCHECK_EQ(Z_OK, rv);
     if (rv != Z_OK) {
       return "";
     }
 
     compressed_size = deflateBound(&z, uncompressed_size);
   }
 
   const size_t entries_size = CertEntriesSize(entries);
 
   string result;
   result.resize(entries_size + (uncompressed_size > 0 ? 4 : 0) +
                 compressed_size);
 
-  uint8* j = reinterpret_cast<uint8*>(&result[0]);
+  uint8_t* j = reinterpret_cast<uint8_t*>(&result[0]);
   SerializeCertEntries(j, entries);
   j += entries_size;
 
   if (uncompressed_size == 0) {
     return result;
   }
 
-  uint32 uncompressed_size_32 = uncompressed_size;
-  memcpy(j, &uncompressed_size_32, sizeof(uint32));
-  j += sizeof(uint32);
+  uint32_t uncompressed_size_32 = uncompressed_size;
+  memcpy(j, &uncompressed_size_32, sizeof(uint32_t));
+  j += sizeof(uint32_t);
 
   int rv;
 
   z.next_out = j;
   z.avail_out = compressed_size;
 
   for (size_t i = 0; i < certs.size(); i++) {
     if (entries[i].type != CertEntry::COMPRESSED) {
       continue;
     }
 
-    uint32 length32 = certs[i].size();
-    z.next_in = reinterpret_cast<uint8*>(&length32);
+    uint32_t length32 = certs[i].size();
+    z.next_in = reinterpret_cast<uint8_t*>(&length32);
     z.avail_in = sizeof(length32);
     rv = deflate(&z, Z_NO_FLUSH);
     DCHECK_EQ(Z_OK, rv);
     DCHECK_EQ(0u, z.avail_in);
     if (rv != Z_OK || z.avail_in) {
       return "";
     }
 
     z.next_in =
-        const_cast<uint8*>(reinterpret_cast<const uint8*>(certs[i].data()));
+        const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(certs[i].data()));
     z.avail_in = certs[i].size();
     rv = deflate(&z, Z_NO_FLUSH);
     DCHECK_EQ(Z_OK, rv);
     DCHECK_EQ(0u, z.avail_in);
     if (rv != Z_OK || z.avail_in) {
       return "";
     }
   }
 
   z.avail_in = 0;
@@ skipping 11 matching lines @@
 bool CertCompressor::DecompressChain(StringPiece in,
                                      const vector<string>& cached_certs,
                                      const CommonCertSets* common_sets,
                                      vector<string>* out_certs) {
   vector<CertEntry> entries;
   if (!ParseEntries(&in, cached_certs, common_sets, &entries, out_certs)) {
     return false;
   }
   DCHECK_EQ(entries.size(), out_certs->size());
 
-  scoped_ptr<uint8[]> uncompressed_data;
+  scoped_ptr<uint8_t[]> uncompressed_data;
   StringPiece uncompressed;
 
   if (!in.empty()) {
-    if (in.size() < sizeof(uint32)) {
+    if (in.size() < sizeof(uint32_t)) {
       return false;
     }
 
-    uint32 uncompressed_size;
+    uint32_t uncompressed_size;
     memcpy(&uncompressed_size, in.data(), sizeof(uncompressed_size));
-    in.remove_prefix(sizeof(uint32));
+    in.remove_prefix(sizeof(uint32_t));
 
     if (uncompressed_size > 128 * 1024) {
       return false;
     }
 
-    uncompressed_data.reset(new uint8[uncompressed_size]);
+    uncompressed_data.reset(new uint8_t[uncompressed_size]);
     z_stream z;
     ScopedZLib scoped_z(ScopedZLib::INFLATE);
 
     memset(&z, 0, sizeof(z));
     z.next_out = uncompressed_data.get();
     z.avail_out = uncompressed_size;
-    z.next_in = const_cast<uint8*>(reinterpret_cast<const uint8*>(in.data()));
+    z.next_in =
+        const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(in.data()));
     z.avail_in = in.size();
 
     if (Z_OK != inflateInit(&z)) {
       return false;
     }
     scoped_z.reset(&z);
 
     int rv = inflate(&z, Z_FINISH);
     if (rv == Z_NEED_DICT) {
       string zlib_dict = ZlibDictForEntries(entries, *out_certs);
-      const uint8* dict = reinterpret_cast<const uint8*>(zlib_dict.data());
+      const uint8_t* dict = reinterpret_cast<const uint8_t*>(zlib_dict.data());
       if (Z_OK != inflateSetDictionary(&z, dict, zlib_dict.size())) {
         return false;
       }
       rv = inflate(&z, Z_FINISH);
     }
 
     if (Z_STREAM_END != rv || z.avail_out > 0 || z.avail_in > 0) {
       return false;
     }
 
     uncompressed = StringPiece(reinterpret_cast<char*>(uncompressed_data.get()),
                                uncompressed_size);
   }
 
   for (size_t i = 0; i < entries.size(); i++) {
     switch (entries[i].type) {
       case CertEntry::COMPRESSED:
-        if (uncompressed.size() < sizeof(uint32)) {
+        if (uncompressed.size() < sizeof(uint32_t)) {
           return false;
         }
-        uint32 cert_len;
+        uint32_t cert_len;
         memcpy(&cert_len, uncompressed.data(), sizeof(cert_len));
-        uncompressed.remove_prefix(sizeof(uint32));
+        uncompressed.remove_prefix(sizeof(uint32_t));
         if (uncompressed.size() < cert_len) {
           return false;
         }
         (*out_certs)[i] = uncompressed.substr(0, cert_len).as_string();
         uncompressed.remove_prefix(cert_len);
         break;
       case CertEntry::CACHED:
       case CertEntry::COMMON:
         break;
     }
   }
 
   if (!uncompressed.empty()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace net