Switch to standard integer types in components/, part 4 of 4.

components/webcrypto/algorithms/aes_ctr_unittest.cc

 // Copyright 2014 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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "base/values.h"
 #include "components/webcrypto/algorithm_dispatch.h"
 #include "components/webcrypto/algorithms/test_helpers.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/status.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
@@ skipping 51 matching lines @@
                       key, CryptoData(test_cipher_text), &output));
     EXPECT_BYTES_EQ(test_plain_text, output);
   }
 }
 
 // The counter block must be exactly 16 bytes.
 TEST_F(WebCryptoAesCtrTest, InvalidCounterBlockLength) {
   const unsigned int kBadCounterBlockLengthBytes[] = {0, 15, 17};
 
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
-      std::vector<uint8>(16),  // 128-bit key of all zeros.
+      std::vector<uint8_t>(16),  // 128-bit key of all zeros.
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCtr),
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
   std::vector<uint8_t> input(32);
   std::vector<uint8_t> output;
 
   for (size_t i = 0; i < arraysize(kBadCounterBlockLengthBytes); ++i) {
     std::vector<uint8_t> bad_counter(kBadCounterBlockLengthBytes[i]);
 
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCtrCounter(),
               Encrypt(CreateAesCtrAlgorithm(bad_counter, 128), key,
                       CryptoData(input), &output));
 
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCtrCounter(),
               Decrypt(CreateAesCtrAlgorithm(bad_counter, 128), key,
                       CryptoData(input), &output));
   }
 }
 
 // The counter length cannot be less than 1 or greater than 128.
 TEST_F(WebCryptoAesCtrTest, InvalidCounterLength) {
   const uint8_t kBadCounterLengthBits[] = {0, 129};
 
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
-      std::vector<uint8>(16),  // 128-bit key of all zeros.
+      std::vector<uint8_t>(16),  // 128-bit key of all zeros.
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCtr),
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
   std::vector<uint8_t> counter(16);
   std::vector<uint8_t> input(32);
   std::vector<uint8_t> output;
 
   for (size_t i = 0; i < arraysize(kBadCounterLengthBits); ++i) {
     uint8_t bad_counter_length_bits = kBadCounterLengthBits[i];
 
@@ skipping 12 matching lines @@
 // Wrap-around is allowed, however if the counter repeats itself an error should
 // be thrown.
 //
 // Using a 4-bit counter it is possible to encrypt 16 blocks. However the 17th
 // block would end up wrapping back to the starting value.
 TEST_F(WebCryptoAesCtrTest, OverflowAndRepeatCounter) {
   const uint8_t kCounterLengthBits = 4;
   const uint8_t kStartCounter[] = {0, 1, 15};
 
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
-      std::vector<uint8>(16),  // 128-bit key of all zeros.
+      std::vector<uint8_t>(16),  // 128-bit key of all zeros.
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCtr),
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
   std::vector<uint8_t> buffer(272);
 
   // 16 and 17 AES blocks worth of data respectively (AES blocks are 16 bytes
   // long).
   CryptoData input_16(buffer.data(), 256);
   CryptoData input_17(buffer.data(), 272);
 
@@ skipping 15 matching lines @@
                       input_17, &output));
     EXPECT_EQ(Status::ErrorAesCtrInputTooLongCounterRepeated(),
               Decrypt(CreateAesCtrAlgorithm(counter, kCounterLengthBits), key,
                       input_17, &output));
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto