Switch to standard integer types in net/.

net/socket/nss_ssl_util.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/socket/nss_ssl_util.h"
 
 #include <nss.h>
 #include <secerr.h>
 #include <ssl.h>
 #include <sslerr.h>
@@ skipping 19 matching lines @@
 #endif
 
 namespace net {
 
 namespace {
 
 // CiphersRemove takes a zero-terminated array of cipher suite ids in
 // |to_remove| and sets every instance of them in |ciphers| to zero. It returns
 // true if it found and removed every element of |to_remove|. It assumes that
 // there are no duplicates in |ciphers| nor in |to_remove|.
-bool CiphersRemove(const uint16* to_remove, uint16* ciphers, size_t num) {
+bool CiphersRemove(const uint16_t* to_remove, uint16_t* ciphers, size_t num) {
   size_t i, found = 0;
 
   for (i = 0; ; i++) {
     if (to_remove[i] == 0)
       break;
 
     for (size_t j = 0; j < num; j++) {
       if (to_remove[i] == ciphers[j]) {
         ciphers[j] = 0;
         found++;
         break;
       }
     }
   }
 
   return found == i;
 }
 
 // CiphersCompact takes an array of cipher suite ids in |ciphers|, where some
 // entries are zero, and moves the entries so that all the non-zero elements
 // are compacted at the end of the array.
-void CiphersCompact(uint16* ciphers, size_t num) {
+void CiphersCompact(uint16_t* ciphers, size_t num) {
   size_t j = num - 1;
 
   for (size_t i = num - 1; i < num; i--) {
     if (ciphers[i] == 0)
       continue;
     ciphers[j--] = ciphers[i];
   }
 }
 
 // CiphersCopy copies the zero-terminated array |in| to |out|. It returns the
 // number of cipher suite ids copied.
-size_t CiphersCopy(const uint16* in, uint16* out) {
+size_t CiphersCopy(const uint16_t* in, uint16_t* out) {
   for (size_t i = 0; ; i++) {
     if (in[i] == 0)
       return i;
     out[i] = in[i];
   }
 }
 
 scoped_ptr<base::Value> NetLogSSLErrorCallback(
     int net_error,
     int ssl_lib_error,
@@ skipping 54 matching lines @@
     SSL_OptionSetDefault(SSL_SECURITY, PR_TRUE);
 
     // Calculate the order of ciphers that we'll use for NSS sockets. (Note
     // that, even if a cipher is specified in the ordering, it must still be
     // enabled in order to be included in a ClientHello.)
     //
     // Our top preference cipher suites are either forward-secret AES-GCM or
     // forward-secret ChaCha20-Poly1305. If the local machine has AES-NI then
     // we prefer AES-GCM, otherwise ChaCha20. The remainder of the cipher suite
     // preference is inheriented from NSS. */
-    static const uint16 chacha_ciphers[] = {
-      TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-      TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-      0,
+    static const uint16_t chacha_ciphers[] = {
+        TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+        TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, 0,
     };
-    static const uint16 aes_gcm_ciphers[] = {
-      TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-      TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-      TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
-      0,
+    static const uint16_t aes_gcm_ciphers[] = {
+        TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+        TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+        TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, 0,
     };
-    scoped_ptr<uint16[]> ciphers(new uint16[num_ciphers]);
-    memcpy(ciphers.get(), ssl_ciphers, sizeof(uint16)*num_ciphers);
+    scoped_ptr<uint16_t[]> ciphers(new uint16_t[num_ciphers]);
+    memcpy(ciphers.get(), ssl_ciphers, sizeof(uint16_t) * num_ciphers);
 
     if (CiphersRemove(chacha_ciphers, ciphers.get(), num_ciphers) &&
         CiphersRemove(aes_gcm_ciphers, ciphers.get(), num_ciphers)) {
       CiphersCompact(ciphers.get(), num_ciphers);
 
-      const uint16* preference_ciphers = chacha_ciphers;
-      const uint16* other_ciphers = aes_gcm_ciphers;
+      const uint16_t* preference_ciphers = chacha_ciphers;
+      const uint16_t* other_ciphers = aes_gcm_ciphers;
       base::CPU cpu;
 
       if (cpu.has_aesni() && cpu.has_avx()) {
         preference_ciphers = aes_gcm_ciphers;
         other_ciphers = chacha_ciphers;
       }
       unsigned i = CiphersCopy(preference_ciphers, ciphers.get());
       CiphersCopy(other_ciphers, &ciphers[i]);
 
       if ((model_fd_ = memio_CreateIOLayer(1, 1)) == NULL ||
@@ skipping 224 matching lines @@
       base::Bind(&NetLogSSLFailedNSSFunctionCallback,
                  function, param, PR_GetError()));
 }
 
 NetLog::ParametersCallback CreateNetLogSSLErrorCallback(int net_error,
                                                         int ssl_lib_error) {
   return base::Bind(&NetLogSSLErrorCallback, net_error, ssl_lib_error);
 }
 
 }  // namespace net