Switch to standard integer types in crypto/.

crypto/encryptor_openssl.cc

 // Copyright (c) 2011 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 "crypto/encryptor.h"
 
 #include <openssl/aes.h>
 #include <openssl/evp.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "crypto/openssl_util.h"
 #include "crypto/symmetric_key.h"
 
 namespace crypto {
 
 namespace {
 
@@ skipping 77 matching lines @@
   output->clear();
 
   const EVP_CIPHER* cipher = GetCipherForKey(key_);
   DCHECK(cipher);  // Already handled in Init();
 
   const std::string& key = key_->key();
   DCHECK_EQ(EVP_CIPHER_iv_length(cipher), iv_.length());
   DCHECK_EQ(EVP_CIPHER_key_length(cipher), key.length());
 
   ScopedCipherCTX ctx;
-  if (!EVP_CipherInit_ex(ctx.get(), cipher, NULL,
-                         reinterpret_cast<const uint8*>(key.data()),
-                         reinterpret_cast<const uint8*>(iv_.data()),
-                         do_encrypt))
+  if (!EVP_CipherInit_ex(
+          ctx.get(), cipher, NULL, reinterpret_cast<const uint8_t*>(key.data()),
+          reinterpret_cast<const uint8_t*>(iv_.data()), do_encrypt))
     return false;
 
   // When encrypting, add another block size of space to allow for any padding.
   const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0);
   CHECK_GT(output_size, 0u);
   CHECK_GT(output_size + 1, input.size());
-  uint8* out_ptr =
-      reinterpret_cast<uint8*>(base::WriteInto(&result, output_size + 1));
+  uint8_t* out_ptr =
+      reinterpret_cast<uint8_t*>(base::WriteInto(&result, output_size + 1));
   int out_len;
   if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len,
-                        reinterpret_cast<const uint8*>(input.data()),
+                        reinterpret_cast<const uint8_t*>(input.data()),
                         input.length()))
     return false;
 
   // Write out the final block plus padding (if any) to the end of the data
   // just written.
   int tail_len;
   if (!EVP_CipherFinal_ex(ctx.get(), out_ptr + out_len, &tail_len))
     return false;
 
   out_len += tail_len;
   DCHECK_LE(out_len, static_cast<int>(output_size));
   result.resize(out_len);
 
   output->swap(result);
   return true;
 }
 
 bool Encryptor::CryptCTR(bool do_encrypt,
                          const base::StringPiece& input,
                          std::string* output) {
   if (!counter_.get()) {
     LOG(ERROR) << "Counter value not set in CTR mode.";
     return false;
   }
 
   AES_KEY aes_key;
-  if (AES_set_encrypt_key(reinterpret_cast<const uint8*>(key_->key().data()),
+  if (AES_set_encrypt_key(reinterpret_cast<const uint8_t*>(key_->key().data()),
                           key_->key().size() * 8, &aes_key) != 0) {
     return false;
   }
 
   const size_t out_size = input.size();
   CHECK_GT(out_size, 0u);
   CHECK_GT(out_size + 1, input.size());
 
   std::string result;
-  uint8* out_ptr =
-      reinterpret_cast<uint8*>(base::WriteInto(&result, out_size + 1));
+  uint8_t* out_ptr =
+      reinterpret_cast<uint8_t*>(base::WriteInto(&result, out_size + 1));
 
   uint8_t ivec[AES_BLOCK_SIZE] = { 0 };
   uint8_t ecount_buf[AES_BLOCK_SIZE] = { 0 };
   unsigned int block_offset = 0;
 
   counter_->Write(ivec);
 
-  AES_ctr128_encrypt(reinterpret_cast<const uint8*>(input.data()), out_ptr,
+  AES_ctr128_encrypt(reinterpret_cast<const uint8_t*>(input.data()), out_ptr,
                      input.size(), &aes_key, ivec, ecount_buf, &block_offset);
 
   // AES_ctr128_encrypt() updates |ivec|. Update the |counter_| here.
   SetCounter(base::StringPiece(reinterpret_cast<const char*>(ivec),
                                AES_BLOCK_SIZE));
 
   output->swap(result);
   return true;
 }
 
 }  // namespace crypto