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

content/renderer/webcrypto/webcrypto_impl.cc

 // Copyright (c) 2013 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 <functional>
 #include <map>
 #include "base/json/json_reader.h"
@@ skipping 161 matching lines @@
 }  // namespace
 
 WebCryptoImpl::WebCryptoImpl() {
   Init();
 }
 
 void WebCryptoImpl::encrypt(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = EncryptInternal(algorithm, key, data, data_size, &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
 void WebCryptoImpl::decrypt(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = DecryptInternal(algorithm, key, data, data_size, &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
 void WebCryptoImpl::digest(
     const blink::WebCryptoAlgorithm& algorithm,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = DigestInternal(algorithm, data, data_size, &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
@@ skipping 33 matching lines @@
       DCHECK_EQ(extractable, key.extractable());
       DCHECK_EQ(usage_mask, key.usages());
       result.completeWithKey(key);
     }
   }
 }
 
 void WebCryptoImpl::importKey(
     blink::WebCryptoKeyFormat format,
     const unsigned char* key_data,
-    unsigned key_data_size,
+    unsigned int key_data_size,
     const blink::WebCryptoAlgorithm& algorithm_or_null,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoResult result) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = Status::Error();
   if (format == blink::WebCryptoKeyFormatJwk) {
     status = ImportKeyJwk(key_data,
                           key_data_size,
                           algorithm_or_null,
@@ skipping 28 matching lines @@
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
 void WebCryptoImpl::sign(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = SignInternal(algorithm, key, data, data_size, &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
 void WebCryptoImpl::verifySignature(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* signature,
-    unsigned signature_size,
+    unsigned int signature_size,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   bool signature_match = false;
   Status status = VerifySignatureInternal(algorithm,
                                           key,
                                           signature,
                                           signature_size,
                                           data,
                                           data_size,
                                           &signature_match);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBoolean(signature_match);
 }
 
 Status WebCryptoImpl::ImportKeyJwk(
     const unsigned char* key_data,
-    unsigned key_data_size,
+    unsigned int key_data_size,
     const blink::WebCryptoAlgorithm& algorithm_or_null,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoKey* key) {
 
   // The goal of this method is to extract key material and meta data from the
   // incoming JWK, combine them with the input parameters, and ultimately import
   // a Web Crypto Key.
   //
   // JSON Web Key Format (JWK)
@@ skipping 275 matching lines @@
         key);
 
   } else {
     return Status::ErrorJwkUnrecognizedKty();
   }
 
   return Status::Success();
 }
 
 }  // namespace content