Use size_t as the type of key_length and digest_length arguments of HMAC.

crypto/hmac_win.cc

 // Copyright (c) 2012 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 "crypto/hmac.h"
 
 #include <windows.h>
 #include <wincrypt.h>
 
 #include <algorithm>
@@ skipping 91 matching lines @@
   // For HMAC-SHA-256 only.
   std::vector<unsigned char> raw_key_;
 };
 
 HMAC::HMAC(HashAlgorithm hash_alg)
     : hash_alg_(hash_alg), plat_(new HMACPlatformData()) {
   // Only SHA-1 and SHA-256 hash algorithms are supported now.
   DCHECK(hash_alg_ == SHA1 || hash_alg_ == SHA256);
 }
 
-bool HMAC::Init(const unsigned char* key, int key_length) {
+bool HMAC::Init(const unsigned char* key, size_t key_length) {
   if (plat_->provider_ || plat_->key_ || !plat_->raw_key_.empty()) {
     // Init must not be called more than once on the same HMAC object.
     NOTREACHED();
     return false;
   }
 
   if (hash_alg_ == SHA256) {
     plat_->raw_key_.assign(key, key + key_length);
     return true;
   }
@@ skipping 17 matching lines @@
     BYTE key_data[1];
   };
   size_t key_blob_size = std::max(offsetof(KeyBlob, key_data) + key_length,
                                   sizeof(KeyBlob));
   std::vector<BYTE> key_blob_storage = std::vector<BYTE>(key_blob_size);
   KeyBlob* key_blob = reinterpret_cast<KeyBlob*>(&key_blob_storage[0]);
   key_blob->header.bType = PLAINTEXTKEYBLOB;
   key_blob->header.bVersion = CUR_BLOB_VERSION;
   key_blob->header.reserved = 0;
   key_blob->header.aiKeyAlg = CALG_RC2;
-  key_blob->key_size = key_length;
+  key_blob->key_size = static_cast<DWORD>(key_length);
   memcpy(key_blob->key_data, key, key_length);
 
   if (!CryptImportKey(plat_->provider_, &key_blob_storage[0],
                       (DWORD)key_blob_storage.size(), 0,
                       CRYPT_IPSEC_HMAC_KEY, plat_->key_.receive())) {
     NOTREACHED();
     return false;
   }
 
   // Destroy the copy of the key.
   SecureZeroMemory(key_blob->key_data, key_length);
 
   return true;
 }
 
 HMAC::~HMAC() {
 }
 
 bool HMAC::Sign(const base::StringPiece& data,
                 unsigned char* digest,
-                int digest_length) const {
+                size_t digest_length) const {
   if (hash_alg_ == SHA256) {
     if (plat_->raw_key_.empty())
       return false;
     ComputeHMACSHA256(&plat_->raw_key_[0], plat_->raw_key_.size(),
                       reinterpret_cast<const unsigned char*>(data.data()),
                       data.size(), digest, digest_length);
     return true;
   }
 
   if (!plat_->provider_ || !plat_->key_)
@@ skipping 13 matching lines @@
   memset(&hmac_info, 0, sizeof(hmac_info));
   hmac_info.HashAlgid = CALG_SHA1;
   if (!CryptSetHashParam(hash, HP_HMAC_INFO,
                          reinterpret_cast<BYTE*>(&hmac_info), 0))
     return false;
 
   if (!CryptHashData(hash, reinterpret_cast<const BYTE*>(data.data()),
                      static_cast<DWORD>(data.size()), 0))
     return false;
 
-  DWORD sha1_size = digest_length;
+  DWORD sha1_size = static_cast<DWORD>(digest_length);
   return !!CryptGetHashParam(hash, HP_HASHVAL, digest, &sha1_size, 0);
 }
 
 }  // namespace crypto