[style] Consistently use "unsigned int" rather than just "unsigned".

content/renderer/webcrypto/webcrypto_impl_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 "content/renderer/webcrypto/webcrypto_impl.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 84 matching lines @@
   dict->SetString("kty", "oct");
   dict->SetString("alg", "A128CBC");
   dict->SetString("use", "enc");
   dict->SetBoolean("extractable", false);
   dict->SetString("k", "GADWrMRHwQfoNaXU5fZvTg==");
 }
 
 blink::WebCryptoAlgorithm CreateAesGcmAlgorithm(
     const std::vector<uint8>& iv,
     const std::vector<uint8>& additional_data,
-    unsigned tag_length_bits) {
+    unsigned int tag_length_bits) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdAesGcm,
       new blink::WebCryptoAesGcmParams(
           webcrypto::Uint8VectorStart(iv), iv.size(),
           true,
           webcrypto::Uint8VectorStart(additional_data),
           additional_data.size(),
           true, tag_length_bits));
 }
 
@@ skipping 64 matching lines @@
 blink::WebCryptoAlgorithm CreateAesKwKeyGenAlgorithm(
     unsigned short key_length_bits) {
   return CreateAesKeyGenAlgorithm(blink::WebCryptoAlgorithmIdAesKw,
                                   key_length_bits);
 }
 
 // The following key pair is comprised of the SPKI (public key) and PKCS#8
 // (private key) representations of the key pair provided in Example 1 of the
 // NIST test vectors at
 // ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt
-const unsigned kModulusLength = 1024;
+const unsigned int kModulusLength = 1024;
 const char* const kPublicKeySpkiDerHex =
     "30819f300d06092a864886f70d010101050003818d0030818902818100a5"
     "6e4a0e701017589a5187dc7ea841d156f2ec0e36ad52a44dfeb1e61f7ad9"
     "91d8c51056ffedb162b4c0f283a12a88a394dff526ab7291cbb307ceabfc"
     "e0b1dfd5cd9508096d5b2b8b6df5d671ef6377c0921cb23c270a70e2598e"
     "6ff89d19f105acc2d3f0cb35f29280e1386b6f64c4ef22e1e1f20d0ce8cf"
     "fb2249bd9a21370203010001";
 const char* const kPrivateKeyPkcs8DerHex =
     "30820275020100300d06092a864886f70d01010105000482025f3082025b"
     "02010002818100a56e4a0e701017589a5187dc7ea841d156f2ec0e36ad52"
@@ skipping 102 matching lines @@
 
     if (status.IsError())
       EXPECT_EQ(Status::ErrorUnsupported().ToString(), status.ToString());
     return status.IsSuccess();
 
   }
 
   Status AesGcmEncrypt(const blink::WebCryptoKey& key,
                        const std::vector<uint8>& iv,
                        const std::vector<uint8>& additional_data,
-                       unsigned tag_length_bits,
+                       unsigned int tag_length_bits,
                        const std::vector<uint8>& plain_text,
                        std::vector<uint8>* cipher_text,
                        std::vector<uint8>* authentication_tag) {
     blink::WebCryptoAlgorithm algorithm = CreateAesGcmAlgorithm(
         iv, additional_data, tag_length_bits);
 
     blink::WebArrayBuffer output;
     Status status = EncryptInternal(algorithm, key, plain_text, &output);
     if (status.IsError())
       return status;
@@ skipping 11 matching lines @@
     authentication_tag->assign(
         static_cast<uint8*>(output.data()) + cipher_text->size(),
         static_cast<uint8*>(output.data()) + output.byteLength());
 
     return Status::Success();
   }
 
   Status AesGcmDecrypt(const blink::WebCryptoKey& key,
                        const std::vector<uint8>& iv,
                        const std::vector<uint8>& additional_data,
-                       unsigned tag_length_bits,
+                       unsigned int tag_length_bits,
                        const std::vector<uint8>& cipher_text,
                        const std::vector<uint8>& authentication_tag,
                        blink::WebArrayBuffer* plain_text) {
     blink::WebCryptoAlgorithm algorithm = CreateAesGcmAlgorithm(
         iv, additional_data, tag_length_bits);
 
     // Join cipher text and authentication tag.
     std::vector<uint8> cipher_text_with_tag;
     cipher_text_with_tag.reserve(
         cipher_text.size() + authentication_tag.size());
@@ skipping 65 matching lines @@
       const std::vector<uint8>& data,
       blink::WebArrayBuffer* buffer) {
     return crypto_.SignInternal(
         algorithm, key, webcrypto::Uint8VectorStart(data), data.size(), buffer);
   }
 
   Status VerifySignatureInternal(
       const blink::WebCryptoAlgorithm& algorithm,
       const blink::WebCryptoKey& key,
       const unsigned char* signature,
-      unsigned signature_size,
+      unsigned int signature_size,
       const std::vector<uint8>& data,
       bool* signature_match) {
     return crypto_.VerifySignatureInternal(algorithm,
                                            key,
                                            signature,
                                            signature_size,
                                            webcrypto::Uint8VectorStart(data),
                                            data.size(),
                                            signature_match);
   }
@@ skipping 11 matching lines @@
         signature.size(),
         webcrypto::Uint8VectorStart(data),
         data.size(),
         signature_match);
   }
 
   Status EncryptInternal(
       const blink::WebCryptoAlgorithm& algorithm,
       const blink::WebCryptoKey& key,
       const unsigned char* data,
-      unsigned data_size,
+      unsigned int data_size,
       blink::WebArrayBuffer* buffer) {
     return crypto_.EncryptInternal(algorithm, key, data, data_size, buffer);
   }
 
   Status EncryptInternal(
       const blink::WebCryptoAlgorithm& algorithm,
       const blink::WebCryptoKey& key,
       const std::vector<uint8>& data,
       blink::WebArrayBuffer* buffer) {
     return crypto_.EncryptInternal(
         algorithm, key, webcrypto::Uint8VectorStart(data), data.size(), buffer);
   }
 
   Status DecryptInternal(
       const blink::WebCryptoAlgorithm& algorithm,
       const blink::WebCryptoKey& key,
       const unsigned char* data,
-      unsigned data_size,
+      unsigned int data_size,
       blink::WebArrayBuffer* buffer) {
     return crypto_.DecryptInternal(algorithm, key, data, data_size, buffer);
   }
 
   Status DecryptInternal(
       const blink::WebCryptoAlgorithm& algorithm,
       const blink::WebCryptoKey& key,
       const std::vector<uint8>& data,
       blink::WebArrayBuffer* buffer) {
     return crypto_.DecryptInternal(
@@ skipping 345 matching lines @@
 
   // Give an input that is too large (would cause integer overflow when
   // narrowing to an int).
   {
     std::vector<uint8> iv(16);
 
     // Pretend the input is large. Don't pass data pointer as NULL in case that
     // is special cased; the implementation shouldn't actually dereference the
     // data.
     const unsigned char* input = &iv[0];
-    unsigned input_len = INT_MAX - 3;
+    unsigned int input_len = INT_MAX - 3;
 
     EXPECT_STATUS(Status::ErrorDataTooLarge(), EncryptInternal(
         webcrypto::CreateAesCbcAlgorithm(iv), key, input, input_len, &output));
     EXPECT_STATUS(Status::ErrorDataTooLarge(), DecryptInternal(
         webcrypto::CreateAesCbcAlgorithm(iv), key, input, input_len, &output));
   }
 
   // Fail importing the key (too few bytes specified)
   {
     std::vector<uint8> key_raw(1);
@@ skipping 131 matching lines @@
     // Test decryption.
     std::vector<uint8> cipher_text = HexStringToBytes(test.cipher_text);
     EXPECT_STATUS(
         Status::Success(),
         DecryptInternal(webcrypto::CreateAesCbcAlgorithm(iv),
                         key,
                         cipher_text,
                         &output));
     ExpectArrayBufferMatchesHex(test.plain_text, output);
 
-    const unsigned kAesCbcBlockSize = 16;
+    const unsigned int kAesCbcBlockSize = 16;
 
     // Decrypt with a padding error by stripping the last block. This also ends
     // up testing decryption over empty cipher text.
     if (cipher_text.size() >= kAesCbcBlockSize) {
       EXPECT_STATUS(
           Status::Error(),
           DecryptInternal(webcrypto::CreateAesCbcAlgorithm(iv),
                           key,
                           &cipher_text[0],
                           cipher_text.size() - kAesCbcBlockSize,
@@ skipping 575 matching lines @@
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       true,
       blink::WebCryptoKeyUsageSign,
       &key));
 }
 
 TEST_F(WebCryptoImplTest, MAYBE(GenerateKeyPairRsa)) {
   // Note: using unrealistic short key lengths here to avoid bogging down tests.
 
   // Successful WebCryptoAlgorithmIdRsaEsPkcs1v1_5 key generation.
-  const unsigned modulus_length = 256;
+  const unsigned int modulus_length = 256;
   const std::vector<uint8> public_exponent = HexStringToBytes("010001");
   blink::WebCryptoAlgorithm algorithm = webcrypto::CreateRsaKeyGenAlgorithm(
       blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
       modulus_length,
       public_exponent);
   bool extractable = false;
   const blink::WebCryptoKeyUsageMask usage_mask = 0;
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   EXPECT_STATUS_SUCCESS(GenerateKeyPairInternal(
       algorithm, extractable, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_EQ(true, public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Fail with bad modulus.
   algorithm = webcrypto::CreateRsaKeyGenAlgorithm(
       blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, 0, public_exponent);
   EXPECT_STATUS(Status::ErrorGenerateRsaZeroModulus(), GenerateKeyPairInternal(
       algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: larger than unsigned long.
-  unsigned exponent_length = sizeof(unsigned long) + 1;  // NOLINT
+  unsigned int exponent_length = sizeof(unsigned long) + 1;  // NOLINT
   const std::vector<uint8> long_exponent(exponent_length, 0x01);
   algorithm = webcrypto::CreateRsaKeyGenAlgorithm(
       blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
       modulus_length,
       long_exponent);
   EXPECT_STATUS(Status::ErrorGenerateKeyPublicExponent(),
       GenerateKeyPairInternal(algorithm, extractable, usage_mask, &public_key,
           &private_key));
 
   // Fail with bad exponent: empty.
@@ skipping 85 matching lines @@
       kPublicKeySpkiDerHex,
       kPrivateKeyPkcs8DerHex,
       algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt,
       &public_key,
       &private_key);
 
   // Make a maximum-length data message. RSAES can operate on messages up to
   // length of k - 11 bytes, where k is the octet length of the RSA modulus.
-  const unsigned kMaxMsgSizeBytes = kModulusLength / 8 - 11;
+  const unsigned int kMaxMsgSizeBytes = kModulusLength / 8 - 11;
   // There are two hex chars for each byte.
-  const unsigned kMsgHexSize = kMaxMsgSizeBytes * 2;
+  const unsigned int kMsgHexSize = kMaxMsgSizeBytes * 2;
   char max_data_hex[kMsgHexSize+1];
   std::fill(&max_data_hex[0], &max_data_hex[0] + kMsgHexSize, 'a');
   max_data_hex[kMsgHexSize] = '\0';
 
   // Verify encrypt / decrypt round trip on a few messages. Note that RSA
   // encryption does not support empty input.
   algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
   const char* const kTestDataHex[] = {
       "ff",
@@ skipping 155 matching lines @@
   const std::vector<uint8> message_hex(HexStringToBytes(message_hex_str));
   EXPECT_STATUS(Status::ErrorUnexpectedKeyType(),
       EncryptInternal(algorithm, private_key, message_hex, &encrypted_data));
 
   // Fail encrypt with empty message.
   EXPECT_STATUS(Status::Error(), EncryptInternal(
       algorithm, public_key, std::vector<uint8>(), &encrypted_data));
 
   // Fail encrypt with message too large. RSAES can operate on messages up to
   // length of k - 11 bytes, where k is the octet length of the RSA modulus.
-  const unsigned kMaxMsgSizeBytes = kModulusLength / 8 - 11;
+  const unsigned int kMaxMsgSizeBytes = kModulusLength / 8 - 11;
   EXPECT_STATUS(
       Status::ErrorDataTooLarge(),
       EncryptInternal(algorithm,
                       public_key,
                       std::vector<uint8>(kMaxMsgSizeBytes + 1, '0'),
                       &encrypted_data));
 
   // Generate encrypted data.
   EXPECT_STATUS(Status::Success(),
       EncryptInternal(algorithm, public_key, message_hex, &encrypted_data));
@@ skipping 79 matching lines @@
   EXPECT_STATUS_SUCCESS(VerifySignatureInternal(
       algorithm,
       public_key,
       webcrypto::Uint8VectorStart(corrupt_sig),
       corrupt_sig.size(),
       data,
       &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure signatures that are greater than the modulus size fail.
-  const unsigned long_message_size_bytes = 1024;
+  const unsigned int long_message_size_bytes = 1024;
   DCHECK_GT(long_message_size_bytes, kModulusLength/8);
   const unsigned char kLongSignature[long_message_size_bytes] = { 0 };
   EXPECT_STATUS_SUCCESS(VerifySignatureInternal(
       algorithm,
       public_key,
       kLongSignature,
       sizeof(kLongSignature),
       data,
       &signature_match));
   EXPECT_FALSE(signature_match);
@@ skipping 505 matching lines @@
         blink::WebCryptoKeyFormatRaw, key, &raw_key));
     ExpectArrayBufferMatchesHex(test.key, raw_key);
 
     const std::vector<uint8> test_iv = HexStringToBytes(test.iv);
     const std::vector<uint8> test_additional_data =
         HexStringToBytes(test.additional_data);
     const std::vector<uint8> test_plain_text =
         HexStringToBytes(test.plain_text);
     const std::vector<uint8> test_authentication_tag =
         HexStringToBytes(test.authentication_tag);
-    const unsigned test_tag_size_bits = test_authentication_tag.size() * 8;
+    const unsigned int test_tag_size_bits = test_authentication_tag.size() * 8;
     const std::vector<uint8> test_cipher_text =
         HexStringToBytes(test.cipher_text);
 
     // Test encryption.
     std::vector<uint8> cipher_text;
     std::vector<uint8> authentication_tag;
     EXPECT_STATUS_SUCCESS(AesGcmEncrypt(key, test_iv, test_additional_data,
                                         test_tag_size_bits, test_plain_text,
                                         &cipher_text, &authentication_tag));
 
@@ skipping 22 matching lines @@
                       test_authentication_tag, &plain_text));
     EXPECT_STATUS(Status::Error(),
         AesGcmDecrypt(key, test_iv, test_additional_data,
                       test_tag_size_bits, test_cipher_text,
                       Corrupted(test_authentication_tag),
                       &plain_text));
 
     // Try different incorrect tag lengths
     uint8 kAlternateTagLengths[] = {8, 96, 120, 128, 160, 255};
     for (size_t tag_i = 0; tag_i < arraysize(kAlternateTagLengths); ++tag_i) {
-      unsigned wrong_tag_size_bits = kAlternateTagLengths[tag_i];
+      unsigned int wrong_tag_size_bits = kAlternateTagLengths[tag_i];
       if (test_tag_size_bits == wrong_tag_size_bits)
         continue;
       EXPECT_STATUS_ERROR(AesGcmDecrypt(key, test_iv, test_additional_data,
                                         wrong_tag_size_bits, test_cipher_text,
                                         test_authentication_tag, &plain_text));
     }
   }
 }
 
 }  // namespace content