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

content/renderer/webcrypto/webcrypto_impl_nss.cc

 // Copyright 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 <cryptohi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
@@ skipping 179 matching lines @@
       // Not a supported algorithm.
       return CKM_INVALID_MECHANISM;
   }
 }
 
 Status AesCbcEncryptDecrypt(
     CK_ATTRIBUTE_TYPE operation,
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdAesCbc, algorithm.id());
   DCHECK_EQ(algorithm.id(), key.algorithm().id());
   DCHECK_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   DCHECK(operation == CKA_ENCRYPT || operation == CKA_DECRYPT);
 
   SymKeyHandle* sym_key = reinterpret_cast<SymKeyHandle*>(key.handle());
 
   const blink::WebCryptoAesCbcParams* params = algorithm.aesCbcParams();
   if (params->iv().size() != AES_BLOCK_SIZE)
     return Status::ErrorIncorrectSizeAesCbcIv();
 
   SECItem iv_item;
   iv_item.type = siBuffer;
   iv_item.data = const_cast<unsigned char*>(params->iv().data());
   iv_item.len = params->iv().size();
 
   crypto::ScopedSECItem param(PK11_ParamFromIV(CKM_AES_CBC_PAD, &iv_item));
   if (!param)
     return Status::Error();
 
   crypto::ScopedPK11Context context(PK11_CreateContextBySymKey(
       CKM_AES_CBC_PAD, operation, sym_key->key(), param.get()));
 
   if (!context.get())
     return Status::Error();
 
   // Oddly PK11_CipherOp takes input and output lengths as "int" rather than
-  // "unsigned". Do some checks now to avoid integer overflowing.
+  // "unsigned int". Do some checks now to avoid integer overflowing.
   if (data_size >= INT_MAX - AES_BLOCK_SIZE) {
     // TODO(eroman): Handle this by chunking the input fed into NSS. Right now
     // it doesn't make much difference since the one-shot API would end up
     // blowing out the memory and crashing anyway.
     return Status::ErrorDataTooLarge();
   }
 
   // PK11_CipherOp does an invalid memory access when given empty decryption
   // input, or input which is not a multiple of the block size. See also
   // https://bugzilla.mozilla.com/show_bug.cgi?id=921687.
   if (operation == CKA_DECRYPT &&
       (data_size == 0 || (data_size % AES_BLOCK_SIZE != 0))) {
     return Status::Error();
   }
 
   // TODO(eroman): Refine the output buffer size. It can be computed exactly for
   //               encryption, and can be smaller for decryption.
-  unsigned output_max_len = data_size + AES_BLOCK_SIZE;
+  unsigned int output_max_len = data_size + AES_BLOCK_SIZE;
   CHECK_GT(output_max_len, data_size);
 
   *buffer = blink::WebArrayBuffer::create(output_max_len, 1);
 
   unsigned char* buffer_data = reinterpret_cast<unsigned char*>(buffer->data());
 
   int output_len;
   if (SECSuccess != PK11_CipherOp(context.get(),
                                   buffer_data,
                                   &output_len,
@@ skipping 16 matching lines @@
 }
 
 // Helper to either encrypt or decrypt for AES-GCM. The result of encryption is
 // the concatenation of the ciphertext and the authentication tag. Similarly,
 // this is the expectation for the input to decryption.
 Status AesGcmEncryptDecrypt(
     bool encrypt,
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdAesGcm, algorithm.id());
   DCHECK_EQ(algorithm.id(), key.algorithm().id());
   DCHECK_EQ(blink::WebCryptoKeyTypeSecret, key.type());
 
   if (!g_aes_gcm_support.Get().IsSupported())
     return Status::ErrorUnsupported();
 
   SymKeyHandle* sym_key = reinterpret_cast<SymKeyHandle*>(key.handle());
 
   const blink::WebCryptoAesGcmParams* params = algorithm.aesGcmParams();
   if (!params)
     return Status::ErrorUnexpected();
 
   // TODO(eroman): The spec doesn't define the default value. Assume 128 for now
   // since that is the maximum tag length:
   // http://www.w3.org/2012/webcrypto/track/issues/46
-  unsigned tag_length_bits = 128;
+  unsigned int tag_length_bits = 128;
   if (params->hasTagLengthBits())
     tag_length_bits = params->optionalTagLengthBits();
 
   if (tag_length_bits > 128 || (tag_length_bits % 8) != 0)
     return Status::ErrorInvalidAesGcmTagLength();
 
-  unsigned tag_length_bytes = tag_length_bits / 8;
+  unsigned int tag_length_bytes = tag_length_bits / 8;
 
   CK_GCM_PARAMS gcm_params = {0};
   gcm_params.pIv =
       const_cast<unsigned char*>(algorithm.aesGcmParams()->iv().data());
   gcm_params.ulIvLen = algorithm.aesGcmParams()->iv().size();
 
   gcm_params.pAAD =
       const_cast<unsigned char*>(params->optionalAdditionalData().data());
   gcm_params.ulAADLen = params->optionalAdditionalData().size();
 
   gcm_params.ulTagBits = tag_length_bits;
 
   SECItem param;
   param.type = siBuffer;
   param.data = reinterpret_cast<unsigned char*>(&gcm_params);
   param.len = sizeof(gcm_params);
 
-  unsigned buffer_size = 0;
+  unsigned int buffer_size = 0;
 
   // Calculate the output buffer size.
   if (encrypt) {
     // TODO(eroman): This is ugly, abstract away the safe integer arithmetic.
     if (data_size > (UINT_MAX - tag_length_bytes))
       return Status::ErrorDataTooLarge();
     buffer_size = data_size + tag_length_bytes;
   } else {
     // TODO(eroman): In theory the buffer allocated for the plain text should be
     // sized as |data_size - tag_length_bytes|.
@@ skipping 41 matching lines @@
     case blink::WebCryptoAlgorithmIdHmac:
       return WebCryptoHashToHMACMechanism(algorithm.hmacKeyParams()->hash());
     default:
       return CKM_INVALID_MECHANISM;
   }
 }
 
 // Converts a (big-endian) WebCrypto BigInteger, with or without leading zeros,
 // to unsigned long.
 bool BigIntegerToLong(const uint8* data,
-                      unsigned data_size,
+                      unsigned int data_size,
                       unsigned long* result) {
   // TODO(padolph): Is it correct to say that empty data is an error, or does it
   // mean value 0? See https://www.w3.org/Bugs/Public/show_bug.cgi?id=23655
   if (data_size == 0)
     return false;
 
   *result = 0;
   for (size_t i = 0; i < data_size; ++i) {
     size_t reverse_i = data_size - i - 1;
 
     if (reverse_i >= sizeof(unsigned long) && data[i])
       return false;  // Too large for a long.
 
     *result |= data[i] << 8 * reverse_i;
   }
   return true;
 }
 
 bool IsAlgorithmRsa(const blink::WebCryptoAlgorithm& algorithm) {
   return algorithm.id() == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5;
 }
 
 Status ImportKeyInternalRaw(
     const unsigned char* key_data,
-    unsigned key_data_size,
+    unsigned int key_data_size,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoKey* key) {
 
   DCHECK(!algorithm.isNull());
 
   blink::WebCryptoKeyType type;
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac:
@@ skipping 132 matching lines @@
       // TODO(padolph): Handle other key types.
       break;
     default:
       break;
   }
   return blink::WebCryptoAlgorithm::createNull();
 }
 
 Status ImportKeyInternalSpki(
     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) {
 
   DCHECK(key);
 
   if (!key_data_size)
     return Status::ErrorImportEmptyKeyData();
   DCHECK(key_data);
@@ skipping 50 matching lines @@
   DCHECK(spki_der->data);
   DCHECK(spki_der->len);
 
   *buffer = webcrypto::CreateArrayBuffer(spki_der->data, spki_der->len);
 
   return Status::Success();
 }
 
 Status ImportKeyInternalPkcs8(
     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) {
 
   DCHECK(key);
 
   if (!key_data_size)
     return Status::ErrorImportEmptyKeyData();
   DCHECK(key_data);
@@ skipping 36 matching lines @@
 }
 
 // -----------------------------------
 // Hmac
 // -----------------------------------
 
 Status SignHmac(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdHmac, algorithm.id());
 
   const blink::WebCryptoHmacParams* params = algorithm.hmacParams();
   if (!params)
     return Status::ErrorUnexpected();
 
   SymKeyHandle* sym_key = reinterpret_cast<SymKeyHandle*>(key.handle());
 
   DCHECK_EQ(PK11_GetMechanism(sym_key->key()),
@@ skipping 30 matching lines @@
   }
 
   DCHECK_EQ(buffer->byteLength(), signature_item.len);
   return Status::Success();
 }
 
 Status VerifyHmac(
     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,
     bool* signature_match) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdHmac, algorithm.id());
 
   blink::WebArrayBuffer result;
   Status status = SignHmac(algorithm, key, data, data_size, &result);
   if (status.IsError())
     return status;
 
   // Handling of truncated signatures is underspecified in the WebCrypto
   // spec, so here we fail verification if a truncated signature is being
   // verified.
   // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=23097
   *signature_match =
     result.byteLength() == signature_size &&
     crypto::SecureMemEqual(result.data(), signature, signature_size);
 
   return Status::Success();
 }
 
 // -----------------------------------
 // RsaEsPkcs1v1_5
 // -----------------------------------
 
 Status EncryptRsaEsPkcs1v1_5(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, algorithm.id());
 
   // RSAES encryption does not support empty input
   if (!data_size)
     return Status::Error();
   DCHECK(data);
 
   if (key.type() != blink::WebCryptoKeyTypePublic)
     return Status::ErrorUnexpectedKeyType();
 
   PublicKeyHandle* const public_key =
       reinterpret_cast<PublicKeyHandle*>(key.handle());
 
-  const unsigned encrypted_length_bytes =
+  const unsigned int encrypted_length_bytes =
       SECKEY_PublicKeyStrength(public_key->key());
 
   // RSAES can operate on messages up to a length of k - 11, where k is the
   // octet length of the RSA modulus.
   if (encrypted_length_bytes < 11 || encrypted_length_bytes - 11 < data_size)
     return Status::ErrorDataTooLarge();
 
   *buffer = blink::WebArrayBuffer::create(encrypted_length_bytes, 1);
   unsigned char* const buffer_data =
       reinterpret_cast<unsigned char*>(buffer->data());
 
   if (PK11_PubEncryptPKCS1(public_key->key(),
                            buffer_data,
                            const_cast<unsigned char*>(data),
                            data_size,
                            NULL) != SECSuccess) {
     return Status::Error();
   }
   return Status::Success();
 }
 
 Status DecryptRsaEsPkcs1v1_5(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5, algorithm.id());
 
   // RSAES decryption does not support empty input
   if (!data_size)
     return Status::Error();
   DCHECK(data);
 
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
 
   PrivateKeyHandle* const private_key =
       reinterpret_cast<PrivateKeyHandle*>(key.handle());
 
   const int modulus_length_bytes =
       PK11_GetPrivateModulusLen(private_key->key());
   if (modulus_length_bytes <= 0)
     return Status::ErrorUnexpected();
-  const unsigned max_output_length_bytes = modulus_length_bytes;
+  const unsigned int max_output_length_bytes = modulus_length_bytes;
 
   *buffer = blink::WebArrayBuffer::create(max_output_length_bytes, 1);
   unsigned char* const buffer_data =
       reinterpret_cast<unsigned char*>(buffer->data());
 
-  unsigned output_length_bytes = 0;
+  unsigned int output_length_bytes = 0;
   if (PK11_PrivDecryptPKCS1(private_key->key(),
                             buffer_data,
                             &output_length_bytes,
                             max_output_length_bytes,
                             const_cast<unsigned char*>(data),
                             data_size) != SECSuccess) {
     return Status::Error();
   }
   DCHECK_LE(output_length_bytes, max_output_length_bytes);
   webcrypto::ShrinkBuffer(buffer, output_length_bytes);
   return Status::Success();
 }
 
 // -----------------------------------
 // RsaSsaPkcs1v1_5
 // -----------------------------------
 
 Status SignRsaSsaPkcs1v1_5(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, algorithm.id());
 
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
 
   if (webcrypto::GetInnerHashAlgorithm(algorithm).isNull())
     return Status::ErrorUnexpected();
 
   PrivateKeyHandle* const private_key =
@@ skipping 35 matching lines @@
 
   *buffer = webcrypto::CreateArrayBuffer(signature_item->data,
                                          signature_item->len);
   return Status::Success();
 }
 
 Status VerifyRsaSsaPkcs1v1_5(
     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,
     bool* signature_match) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, algorithm.id());
 
   if (key.type() != blink::WebCryptoKeyTypePublic)
     return Status::ErrorUnexpectedKeyType();
 
   PublicKeyHandle* const public_key =
       reinterpret_cast<PublicKeyHandle*>(key.handle());
   DCHECK(public_key);
   DCHECK(public_key->key());
@@ skipping 116 matching lines @@
       extractable,
       algorithm,
       usage_mask);
 
   return Status::Success();
 }
 
 // Get the secret key length in bytes from generation parameters. This resolves
 // any defaults.
 Status GetGenerateSecretKeyLength(const blink::WebCryptoAlgorithm& algorithm,
-                                  unsigned* keylen_bytes) {
+                                  unsigned int* keylen_bytes) {
   *keylen_bytes = 0;
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw: {
       const blink::WebCryptoAesKeyGenParams* params =
           algorithm.aesKeyGenParams();
       DCHECK(params);
       // Ensure the key length is a multiple of 8 bits. Let NSS verify further
@@ skipping 26 matching lines @@
 }  // namespace
 
 void WebCryptoImpl::Init() {
   crypto::EnsureNSSInit();
 }
 
 Status WebCryptoImpl::EncryptInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
 
   DCHECK_EQ(algorithm.id(), key.algorithm().id());
   DCHECK(key.handle());
   DCHECK(buffer);
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
       return AesCbcEncryptDecrypt(
           CKA_ENCRYPT, algorithm, key, data, data_size, buffer);
     case blink::WebCryptoAlgorithmIdAesGcm:
       return AesGcmEncryptDecrypt(
           true, algorithm, key, data, data_size, buffer);
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
       return EncryptRsaEsPkcs1v1_5(algorithm, key, data, data_size, buffer);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::DecryptInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
 
   DCHECK_EQ(algorithm.id(), key.algorithm().id());
   DCHECK(key.handle());
   DCHECK(buffer);
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
       return AesCbcEncryptDecrypt(
           CKA_DECRYPT, algorithm, key, data, data_size, buffer);
     case blink::WebCryptoAlgorithmIdAesGcm:
       return AesGcmEncryptDecrypt(
           false, algorithm, key, data, data_size, buffer);
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
       return DecryptRsaEsPkcs1v1_5(algorithm, key, data, data_size, buffer);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::DigestInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
   HASH_HashType hash_type = WebCryptoAlgorithmToNSSHashType(algorithm);
   if (hash_type == HASH_AlgNULL)
     return Status::ErrorUnsupported();
 
   HASHContext* context = HASH_Create(hash_type);
   if (!context)
     return Status::Error();
 
   HASH_Begin(context);
 
   HASH_Update(context, data, data_size);
 
-  unsigned hash_result_length = HASH_ResultLenContext(context);
+  unsigned int hash_result_length = HASH_ResultLenContext(context);
   DCHECK_LE(hash_result_length, static_cast<size_t>(HASH_LENGTH_MAX));
 
   *buffer = blink::WebArrayBuffer::create(hash_result_length, 1);
 
   unsigned char* digest = reinterpret_cast<unsigned char*>(buffer->data());
 
-  unsigned result_length = 0;
+  unsigned int result_length = 0;
   HASH_End(context, digest, &result_length, hash_result_length);
 
   HASH_Destroy(context);
 
   if (result_length != hash_result_length)
     return Status::ErrorUnexpected();
   return Status::Success();
 }
 
 Status WebCryptoImpl::GenerateSecretKeyInternal(
@@ skipping 44 matching lines @@
       return GenerateRsaKeyPair(algorithm, extractable, usage_mask,
                                 public_key, private_key);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::ImportKeyInternal(
     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::WebCryptoKey* key) {
 
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
       // A 'raw'-formatted key import requires an input algorithm.
       if (algorithm_or_null.isNull())
         return Status::ErrorMissingAlgorithmImportRawKey();
@@ skipping 37 matching lines @@
       return Status::ErrorUnsupported();
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::SignInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
-    unsigned data_size,
+    unsigned int data_size,
     blink::WebArrayBuffer* buffer) {
 
   // Note: It is not an error to sign empty data.
 
   DCHECK(buffer);
   DCHECK_NE(0, key.usages() & blink::WebCryptoKeyUsageSign);
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac:
       return SignHmac(algorithm, key, data, data_size, buffer);
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
       return SignRsaSsaPkcs1v1_5(algorithm, key, data, data_size, buffer);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::VerifySignatureInternal(
     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,
     bool* signature_match) {
 
   if (!signature_size) {
     // None of the algorithms generate valid zero-length signatures so this
     // will necessarily fail verification. Early return to protect
     // implementations from dealing with a NULL signature pointer.
     *signature_match = false;
     return Status::Success();
   }
 
   DCHECK(signature);
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac:
       return VerifyHmac(algorithm, key, signature, signature_size,
                         data, data_size, signature_match);
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
       return VerifyRsaSsaPkcs1v1_5(algorithm, key, signature, signature_size,
                                    data, data_size, signature_match);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::ImportRsaPublicKeyInternal(
     const unsigned char* modulus_data,
-    unsigned modulus_size,
+    unsigned int modulus_size,
     const unsigned char* exponent_data,
-    unsigned exponent_size,
+    unsigned int exponent_size,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoKey* key) {
 
   if (!modulus_size)
     return Status::ErrorImportRsaEmptyModulus();
 
   if (!exponent_size)
     return Status::ErrorImportRsaEmptyExponent();
@@ skipping 38 matching lines @@
 
   *key = blink::WebCryptoKey::create(new PublicKeyHandle(pubkey.Pass()),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace content