clang/win: Let some chromium_code targets build with -Wextra.

crypto/symmetric_key_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/symmetric_key.h"
 
 #include <vector>
 
 // TODO(wtc): replace scoped_array by std::vector.
 #include "base/memory/scoped_ptr.h"
@@ skipping 33 matching lines @@
 // key created for the specified |provider|. |alg| contains the algorithm of
 // the key being imported.
 // If |key_data| is intended to be used as an HMAC key, then |alg| should be
 // CALG_HMAC.
 // If successful, returns true and stores the imported key in |*key|.
 // TODO(wtc): use this function in hmac_win.cc.
 bool ImportRawKey(HCRYPTPROV provider,
                   ALG_ID alg,
                   const void* key_data, size_t key_size,
                   ScopedHCRYPTKEY* key) {
-  DCHECK_GT(key_size, 0);
+  DCHECK_GT(key_size, 0u);
 
   DWORD actual_size =
       static_cast<DWORD>(sizeof(PlaintextBlobHeader) + key_size);
   std::vector<BYTE> tmp_data(actual_size);
   BYTE* actual_key = &tmp_data[0];
   memcpy(actual_key + sizeof(PlaintextBlobHeader), key_data, key_size);
   PlaintextBlobHeader* key_header =
       reinterpret_cast<PlaintextBlobHeader*>(actual_key);
   memset(key_header, 0, sizeof(PlaintextBlobHeader));
 
@@ skipping 242 matching lines @@
 SymmetricKey::~SymmetricKey() {
   // TODO(wtc): create a "secure" string type that zeroes itself in the
   // destructor.
   if (!raw_key_.empty())
     SecureZeroMemory(const_cast<char *>(raw_key_.data()), raw_key_.size());
 }
 
 // static
 SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm,
                                               size_t key_size_in_bits) {
-  DCHECK_GE(key_size_in_bits, 8);
+  DCHECK_GE(key_size_in_bits, 8u);
 
   ScopedHCRYPTPROV provider;
   ScopedHCRYPTKEY key;
 
   bool ok = false;
   scoped_ptr<BYTE[]> raw_key;
 
   switch (algorithm) {
     case AES:
       ok = GenerateAESKey(key_size_in_bits, &provider, &key);
@@ skipping 77 matching lines @@
 
   DWORD hLen = 0;
   DWORD param_size = sizeof(hLen);
   ok = CryptGetHashParam(prf, HP_HASHSIZE,
                          reinterpret_cast<BYTE*>(&hLen), &param_size, 0);
   if (!ok || hLen == 0)
     return NULL;
 
   // 1. If dkLen > (2^32 - 1) * hLen, output "derived key too long" and stop.
   size_t dkLen = key_size_in_bits / 8;
-  DCHECK_GT(dkLen, 0);
+  DCHECK_GT(dkLen, 0u);
 
   if ((dkLen / hLen) > 0xFFFFFFFF) {
     DLOG(ERROR) << "Derived key too long.";
     return NULL;
   }
 
   // 2. Let l be the number of hLen-octet blocks in the derived key,
   //    rounding up, and let r be the number of octets in the last
   //    block:
   size_t L = (dkLen + hLen - 1) / hLen;
-  DCHECK_GT(L, 0);
+  DCHECK_GT(L, 0u);
 
   size_t total_generated_size = L * hLen;
   std::vector<BYTE> generated_key(total_generated_size);
   BYTE* block_offset = &generated_key[0];
 
   // 3. For each block of the derived key apply the function F defined below
   //    to the password P, the salt S, the iteration count c, and the block
   //    index to compute the block:
   //    T_1 = F (P, S, c, 1)
   //    T_2 = F (P, S, c, 2)
@@ skipping 90 matching lines @@
                            HCRYPTKEY key,
                            const void* key_data, size_t key_size_in_bytes)
     : provider_(provider), key_(key) {
   if (key_data) {
     raw_key_.assign(reinterpret_cast<const char*>(key_data),
                     key_size_in_bytes);
   }
 }
 
 }  // namespace crypto