Use the exact-width integer types defined in <stdint.h> rather than

net/cert/cert_verify_proc.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/cert/cert_verify_proc.h"
 
 #include <stdint.h>
 
-#include "base/basictypes.h"
 #include "base/metrics/histogram.h"
 #include "base/sha1.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 272 matching lines @@
     if (rv == OK)
       rv = MapCertStatusToNetError(verify_result->cert_status);
   }
 
   return rv;
 }
 
 // static
 bool CertVerifyProc::IsBlacklisted(X509Certificate* cert) {
   static const unsigned kComodoSerialBytes = 16;
-  static const uint8 kComodoSerials[][kComodoSerialBytes] = {
+  static const uint8_t kComodoSerials[][kComodoSerialBytes] = {
     // Not a real certificate. For testing only.
     {0x07,0x7a,0x59,0xbc,0xd5,0x34,0x59,0x60,0x1c,0xa6,0x90,0x72,0x67,0xa6,0xdd,0x1c},
 
     // The next nine certificates all expire on Fri Mar 14 23:59:59 2014.
     // Some serial numbers actually have a leading 0x00 byte required to
     // encode a positive integer in DER if the most significant bit is 0.
     // We omit the leading 0x00 bytes to make all serial numbers 16 bytes.
 
     // Subject: CN=mail.google.com
     // subjectAltName dNSName: mail.google.com, www.mail.google.com
@@ skipping 52 matching lines @@
   // CloudFlare revoked all certificates issued prior to April 2nd, 2014. Thus
   // all certificates where the CN ends with ".cloudflare.com" with a prior
   // issuance date are rejected.
   //
   // The old certs had a lifetime of five years, so this can be removed April
   // 2nd, 2019.
   const std::string& cn = cert->subject().common_name;
   static const char kCloudFlareCNSuffix[] = ".cloudflare.com";
   // kCloudFlareEpoch is the base::Time internal value for midnight at the
   // beginning of April 2nd, 2014, UTC.
-  static const int64 kCloudFlareEpoch = INT64_C(13040870400000000);
+  static const int64_t kCloudFlareEpoch = INT64_C(13040870400000000);
   if (cn.size() > arraysize(kCloudFlareCNSuffix) - 1 &&
       cn.compare(cn.size() - (arraysize(kCloudFlareCNSuffix) - 1),
                  arraysize(kCloudFlareCNSuffix) - 1,
                  kCloudFlareCNSuffix) == 0 &&
       cert->valid_start() < base::Time::FromInternalValue(kCloudFlareEpoch)) {
     return true;
   }
 
   return false;
 }
 
 // static
 // NOTE: This implementation assumes and enforces that the hashes are SHA1.
 bool CertVerifyProc::IsPublicKeyBlacklisted(
     const HashValueVector& public_key_hashes) {
   static const unsigned kNumHashes = 17;
-  static const uint8 kHashes[kNumHashes][base::kSHA1Length] = {
+  static const uint8_t kHashes[kNumHashes][base::kSHA1Length] = {
     // Subject: CN=DigiNotar Root CA
     // Issuer: CN=Entrust.net x2 and self-signed
     {0x41, 0x0f, 0x36, 0x36, 0x32, 0x58, 0xf3, 0x0b, 0x34, 0x7d,
      0x12, 0xce, 0x48, 0x63, 0xe4, 0x33, 0x43, 0x78, 0x06, 0xa8},
     // Subject: CN=DigiNotar Cyber CA
     // Issuer: CN=GTE CyberTrust Global Root
     {0xc4, 0xf9, 0x66, 0x37, 0x16, 0xcd, 0x5e, 0x71, 0xd6, 0x95,
      0x0b, 0x5f, 0x33, 0xce, 0x04, 0x1c, 0x95, 0xb4, 0x35, 0xd1},
     // Subject: CN=DigiNotar Services 1024 CA
     // Issuer: CN=Entrust.net
@@ skipping 119 matching lines @@
       return false;
   }
 
   return true;
 }
 
 // PublicKeyDomainLimitation contains a SHA1, SPKI hash and a pointer to an
 // array of fixed-length strings that contain the domains that the SPKI is
 // allowed to issue for.
 struct PublicKeyDomainLimitation {
-  uint8 public_key[base::kSHA1Length];
+  uint8_t public_key[base::kSHA1Length];
   const char (*domains)[kMaxDomainLength];
 };
 
 // static
 bool CertVerifyProc::HasNameConstraintsViolation(
     const HashValueVector& public_key_hashes,
     const std::string& common_name,
     const std::vector<std::string>& dns_names,
     const std::vector<std::string>& ip_addrs) {
   static const char kDomainsANSSI[][kMaxDomainLength] = {
@@ skipping 128 matching lines @@
     return true;
 
   // For certificates issued after 1 April 2015: 39 months.
   if (start >= time_2015_04_01 && month_diff > 39)
     return true;
 
   return false;
 }
 
 }  // namespace net