Fixing gcc 4.7 building problems.

crypto/ec_private_key_nss.cc

 // Copyright (c) 2011 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/ec_private_key.h"
 
 extern "C" {
 // Work around NSS missing SEC_BEGIN_PROTOS in secmodt.h.  This must come before
 // other NSS headers.
 #include <secmodt.h>
@@ skipping 110 matching lines @@
   *public_key = SECKEY_ExtractPublicKey(decoded_spki);
 
   if (!*public_key) {
     DLOG(ERROR) << "SECKEY_ExtractPublicKey: " << PORT_GetError();
     return false;
   }
 
   SECItem encoded_epki = {
     siBuffer,
     const_cast<unsigned char*>(encrypted_private_key_info),
-    encrypted_private_key_info_len
+    static_cast<unsigned int>(encrypted_private_key_info_len)

[brettw, 2012/05/29 19:30:46]

unsigned int -> unsigned (same elsewhere)

[Han, 2012/05/29 20:57:04]

Done.

   };
   SECKEYEncryptedPrivateKeyInfo epki;
   memset(&epki, 0, sizeof(epki));
 
   ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
 
   SECStatus rv = SEC_QuickDERDecodeItem(
       arena.get(),
       &epki,
       SEC_ASN1_GET(SECKEY_EncryptedPrivateKeyInfoTemplate),
       &encoded_epki);
   if (rv != SECSuccess) {
     DLOG(ERROR) << "SEC_QuickDERDecodeItem: " << PORT_GetError();
     SECKEY_DestroyPublicKey(*public_key);
     *public_key = NULL;
     return false;
   }
 
   SECItem password_item = {
     siBuffer,
     reinterpret_cast<unsigned char*>(const_cast<char*>(password.data())),
-    password.size()
+    static_cast<unsigned int>(password.size())
   };
 
   rv = ImportEncryptedECPrivateKeyInfoAndReturnKey(
       slot.get(),
       &epki,
       &password_item,
       NULL,  // nickname
       &(*public_key)->u.ec.publicValue,
       permanent,
       sensitive,
@@ skipping 14 matching lines @@
     const std::string& password,
     int iterations,
     std::vector<uint8>* output) {
   // We export as an EncryptedPrivateKeyInfo bundle instead of a plain PKCS #8
   // PrivateKeyInfo because PK11_ImportDERPrivateKeyInfoAndReturnKey doesn't
   // support EC keys.
   // https://bugzilla.mozilla.org/show_bug.cgi?id=327773
   SECItem password_item = {
     siBuffer,
     reinterpret_cast<unsigned char*>(const_cast<char*>(password.data())),
-    password.size()
+    static_cast<unsigned int>(password.size())
   };
 
   SECKEYEncryptedPrivateKeyInfo* encrypted = PK11_ExportEncryptedPrivKeyInfo(
       NULL, // Slot, optional.
       SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC,
       &password_item,
       key_,
       iterations,
       NULL); // wincx.
 
@@ skipping 58 matching lines @@
     return NULL;
   }
 
   // SECKEYECParams is a SECItem containing the DER encoded ASN.1 ECParameters
   // value.  For a named curve, that is just the OBJECT IDENTIFIER of the curve.
   // In addition to the oid data, the encoding requires one byte for the ASN.1
   // tag and one byte for the length (assuming the length is <= 127).
   DCHECK_LE(oid_data->oid.len, 127U);
   std::vector<unsigned char> parameters_buf(2 + oid_data->oid.len);
   SECKEYECParams ec_parameters = {
-    siDEROID, &parameters_buf[0], parameters_buf.size()
+    siDEROID, &parameters_buf[0],
+    static_cast<unsigned int>(parameters_buf.size())
   };
 
   ec_parameters.data[0] = SEC_ASN1_OBJECT_ID;
   ec_parameters.data[1] = oid_data->oid.len;
   memcpy(ec_parameters.data + 2, oid_data->oid.data, oid_data->oid.len);
 
   result->key_ = PK11_GenerateKeyPair(slot.get(),
                                       CKM_EC_KEY_PAIR_GEN,
                                       &ec_parameters,
                                       &result->public_key_,
@@ skipping 15 matching lines @@
     const std::vector<uint8>& subject_public_key_info,
     bool permanent,
     bool sensitive) {
   EnsureNSSInit();
 
   scoped_ptr<ECPrivateKey> result(new ECPrivateKey);
 
   SECItem encoded_spki = {
     siBuffer,
     const_cast<unsigned char*>(&subject_public_key_info[0]),
-    subject_public_key_info.size()
+    static_cast<unsigned int>(subject_public_key_info.size())
   };
   CERTSubjectPublicKeyInfo* decoded_spki = SECKEY_DecodeDERSubjectPublicKeyInfo(
       &encoded_spki);
   if (!decoded_spki) {
     DLOG(ERROR) << "SECKEY_DecodeDERSubjectPublicKeyInfo: " << PORT_GetError();
     return NULL;
   }
 
   bool success = ECPrivateKey::ImportFromEncryptedPrivateKeyInfo(
       password,
       &encrypted_private_key_info[0],
       encrypted_private_key_info.size(),
       decoded_spki,
       permanent,
       sensitive,
       &result->key_,
       &result->public_key_);
 
   SECKEY_DestroySubjectPublicKeyInfo(decoded_spki);
 
   if (success)
     return result.release();
 
   return NULL;
 }
 
 }  // namespace crypto