Replace uses of uint8 with uint8_t.

content/child/webcrypto/webcrypto_impl.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 "content/child/webcrypto/webcrypto_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 91 matching lines @@
 }
 
 void CompleteWithError(const Status& status, blink::WebCryptoResult* result) {
   DCHECK(status.IsError());
 
   result->completeWithError(status.error_type(),
                             blink::WebString::fromUTF8(status.error_details()));
 }
 
 void CompleteWithBufferOrError(const Status& status,
-                               const std::vector<uint8>& buffer,
+                               const std::vector<uint8_t>& buffer,
                                blink::WebCryptoResult* result) {
   if (status.IsError()) {
     CompleteWithError(status, result);
   } else {
     if (buffer.size() > UINT_MAX) {
       // WebArrayBuffers have a smaller range than std::vector<>, so
       // theoretically this could overflow.
       CompleteWithError(Status::ErrorUnexpected(), result);
     } else {
       result->completeWithBuffer(webcrypto::Uint8VectorStart(buffer),
@@ skipping 69 matching lines @@
                const unsigned char* data,
                unsigned int data_size,
                const blink::WebCryptoResult& result)
       : BaseState(result),
         algorithm(algorithm),
         key(key),
         data(data, data + data_size) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const blink::WebCryptoKey key;
-  const std::vector<uint8> data;
+  const std::vector<uint8_t> data;
 
-  std::vector<uint8> buffer;
+  std::vector<uint8_t> buffer;
 };
 
 typedef EncryptState DecryptState;
 typedef EncryptState DigestState;
 
 struct GenerateKeyState : public BaseState {
   GenerateKeyState(const blink::WebCryptoAlgorithm& algorithm,
                    bool extractable,
                    blink::WebCryptoKeyUsageMask usage_mask,
                    const blink::WebCryptoResult& result)
@@ skipping 26 matching lines @@
                  const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
         key_data(key_data, key_data + key_data_size),
         algorithm(algorithm),
         extractable(extractable),
         usage_mask(usage_mask),
         key(blink::WebCryptoKey::createNull()) {}
 
   const blink::WebCryptoKeyFormat format;
-  const std::vector<uint8> key_data;
+  const std::vector<uint8_t> key_data;
   const blink::WebCryptoAlgorithm algorithm;
   const bool extractable;
   const blink::WebCryptoKeyUsageMask usage_mask;
 
   blink::WebCryptoKey key;
 };
 
 struct ExportKeyState : public BaseState {
   ExportKeyState(blink::WebCryptoKeyFormat format,
                  const blink::WebCryptoKey& key,
                  const blink::WebCryptoResult& result)
       : BaseState(result), format(format), key(key) {}
 
   const blink::WebCryptoKeyFormat format;
   const blink::WebCryptoKey key;
 
-  std::vector<uint8> buffer;
+  std::vector<uint8_t> buffer;
 };
 
 typedef EncryptState SignState;
 
 struct VerifySignatureState : public BaseState {
   VerifySignatureState(const blink::WebCryptoAlgorithm& algorithm,
                        const blink::WebCryptoKey& key,
                        const unsigned char* signature,
                        unsigned int signature_size,
                        const unsigned char* data,
                        unsigned int data_size,
                        const blink::WebCryptoResult& result)
       : BaseState(result),
         algorithm(algorithm),
         key(key),
         signature(signature, signature + signature_size),
         data(data, data + data_size),
         verify_result(false) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const blink::WebCryptoKey key;
-  const std::vector<uint8> signature;
-  const std::vector<uint8> data;
+  const std::vector<uint8_t> signature;
+  const std::vector<uint8_t> data;
 
   bool verify_result;
 };
 
 struct WrapKeyState : public BaseState {
   WrapKeyState(blink::WebCryptoKeyFormat format,
                const blink::WebCryptoKey& key,
                const blink::WebCryptoKey& wrapping_key,
                const blink::WebCryptoAlgorithm& wrap_algorithm,
                const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
         key(key),
         wrapping_key(wrapping_key),
         wrap_algorithm(wrap_algorithm) {}
 
   const blink::WebCryptoKeyFormat format;
   const blink::WebCryptoKey key;
   const blink::WebCryptoKey wrapping_key;
   const blink::WebCryptoAlgorithm wrap_algorithm;
 
-  std::vector<uint8> buffer;
+  std::vector<uint8_t> buffer;
 };
 
 struct UnwrapKeyState : public BaseState {
   UnwrapKeyState(blink::WebCryptoKeyFormat format,
                  const unsigned char* wrapped_key,
                  unsigned wrapped_key_size,
                  const blink::WebCryptoKey& wrapping_key,
                  const blink::WebCryptoAlgorithm& unwrap_algorithm,
                  const blink::WebCryptoAlgorithm& unwrapped_key_algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
         wrapped_key(wrapped_key, wrapped_key + wrapped_key_size),
         wrapping_key(wrapping_key),
         unwrap_algorithm(unwrap_algorithm),
         unwrapped_key_algorithm(unwrapped_key_algorithm),
         extractable(extractable),
         usages(usages),
         unwrapped_key(blink::WebCryptoKey::createNull()) {}
 
   const blink::WebCryptoKeyFormat format;
-  const std::vector<uint8> wrapped_key;
+  const std::vector<uint8_t> wrapped_key;
   const blink::WebCryptoKey wrapping_key;
   const blink::WebCryptoAlgorithm unwrap_algorithm;
   const blink::WebCryptoAlgorithm unwrapped_key_algorithm;
   const bool extractable;
   const blink::WebCryptoKeyUsageMask usages;
 
   blink::WebCryptoKey unwrapped_key;
 };
 
 // --------------------------------------------------------------------
@@ skipping 414 matching lines @@
       &key);
 }
 
 bool WebCryptoImpl::serializeKeyForClone(
     const blink::WebCryptoKey& key,
     blink::WebVector<unsigned char>& key_data) {
   return webcrypto::SerializeKeyForClone(key, &key_data);
 }
 
 }  // namespace content