Switch to standard integer types in crypto/.

crypto/encryptor_nss.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 <cryptohi.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 
 #include "base/logging.h"
 #include "crypto/nss_util.h"
 #include "crypto/symmetric_key.h"
 
 namespace crypto {
 
 namespace {
 
@@ skipping 91 matching lines @@
   return Crypt(context.get(), ciphertext, plaintext);
 }
 
 bool Encryptor::Crypt(PK11Context* context,
                       const base::StringPiece& input,
                       std::string* output) {
   size_t output_len = input.size() + AES_BLOCK_SIZE;
   CHECK_GT(output_len, input.size());
 
   output->resize(output_len);
-  uint8* output_data =
-      reinterpret_cast<uint8*>(const_cast<char*>(output->data()));
+  uint8_t* output_data =
+      reinterpret_cast<uint8_t*>(const_cast<char*>(output->data()));
 
   int input_len = input.size();
-  uint8* input_data =
-      reinterpret_cast<uint8*>(const_cast<char*>(input.data()));
+  uint8_t* input_data =
+      reinterpret_cast<uint8_t*>(const_cast<char*>(input.data()));
 
   int op_len;
   SECStatus rv = PK11_CipherOp(context,
                                output_data,
                                &op_len,
                                output_len,
                                input_data,
                                input_len);
 
   if (SECSuccess != rv) {
@@ skipping 20 matching lines @@
                          std::string* output) {
   if (!counter_.get()) {
     LOG(ERROR) << "Counter value not set in CTR mode.";
     return false;
   }
 
   size_t output_len = ((input.size() + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE) *
       AES_BLOCK_SIZE;
   CHECK_GE(output_len, input.size());
   output->resize(output_len);
-  uint8* output_data =
-      reinterpret_cast<uint8*>(const_cast<char*>(output->data()));
+  uint8_t* output_data =
+      reinterpret_cast<uint8_t*>(const_cast<char*>(output->data()));
 
   size_t mask_len;
   bool ret = GenerateCounterMask(input.size(), output_data, &mask_len);
   if (!ret)
     return false;
 
   CHECK_EQ(mask_len, output_len);
   int op_len;
   SECStatus rv = PK11_CipherOp(context,
                                output_data,
                                &op_len,
                                output_len,
                                output_data,
                                mask_len);
   if (SECSuccess != rv)
     return false;
   CHECK_EQ(static_cast<int>(mask_len), op_len);
 
   unsigned int digest_len;
   rv = PK11_DigestFinal(context,
                         NULL,
                         &digest_len,
                         0);
   if (SECSuccess != rv)
     return false;
   CHECK(!digest_len);
 
   // Use |output_data| to mask |input|.
-  MaskMessage(
-      reinterpret_cast<uint8*>(const_cast<char*>(input.data())),
-      input.length(), output_data, output_data);
+  MaskMessage(reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())),
+              input.length(), output_data, output_data);
   output->resize(input.length());
   return true;
 }
 
 }  // namespace crypto