Fix 64-bit Mac compilation errors in src/crypto.

crypto/mock_keychain_mac.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 "base/logging.h"
 #include "base/time.h"
 #include "crypto/mock_keychain_mac.h"
 
 namespace crypto {
 
@@ skipping 74 matching lines @@
       break;
     }
   }
   if (attribute_index == -1) {
     NOTREACHED() << "Unsupported attribute: " << tag;
     return NULL;
   }
   return &(attribute_list.attr[attribute_index]);
 }
 
-void MockKeychain::SetTestDataBytes(int item,
+void MockKeychain::SetTestDataBytes(unsigned int item,
                                     UInt32 tag,
                                     const void* data,
                                     size_t length) {
   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
                                                      tag);
   attribute->length = length;
   if (length > 0) {
     if (attribute->data)
       free(attribute->data);
     attribute->data = malloc(length);
     CHECK(attribute->data);
     memcpy(attribute->data, data, length);
   } else {
     attribute->data = NULL;
   }
 }
 
-void MockKeychain::SetTestDataString(int item, UInt32 tag, const char* value) {
+void MockKeychain::SetTestDataString(unsigned int item,
+                                     UInt32 tag,
+                                     const char* value) {
   SetTestDataBytes(item, tag, value, value ? strlen(value) : 0);
 }
 
-void MockKeychain::SetTestDataPort(int item, UInt32 value) {
+void MockKeychain::SetTestDataPort(unsigned int item, UInt32 value) {
   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
                                                      kSecPortItemAttr);
   UInt32* data = static_cast<UInt32*>(attribute->data);
   *data = value;
 }
 
-void MockKeychain::SetTestDataProtocol(int item, SecProtocolType value) {
+void MockKeychain::SetTestDataProtocol(unsigned int item, SecProtocolType value) {
   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
                                                      kSecProtocolItemAttr);
   SecProtocolType* data = static_cast<SecProtocolType*>(attribute->data);
   *data = value;
 }
 
-void MockKeychain::SetTestDataAuthType(int item, SecAuthenticationType value) {
+void MockKeychain::SetTestDataAuthType(unsigned int item, SecAuthenticationType value) {
   SecKeychainAttribute* attribute = AttributeWithTag(
       keychain_attr_list_[item], kSecAuthenticationTypeItemAttr);
   SecAuthenticationType* data = static_cast<SecAuthenticationType*>(
       attribute->data);
   *data = value;
 }
 
-void MockKeychain::SetTestDataNegativeItem(int item, Boolean value) {
+void MockKeychain::SetTestDataNegativeItem(unsigned int item, Boolean value) {
   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
                                                      kSecNegativeItemAttr);
   Boolean* data = static_cast<Boolean*>(attribute->data);
   *data = value;
 }
 
-void MockKeychain::SetTestDataCreator(int item, OSType value) {
+void MockKeychain::SetTestDataCreator(unsigned int item, OSType value) {
   SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
                                                      kSecCreatorItemAttr);
   OSType* data = static_cast<OSType*>(attribute->data);
   *data = value;
 }
 
-void MockKeychain::SetTestDataPasswordBytes(int item, const void* data,
+void MockKeychain::SetTestDataPasswordBytes(unsigned int item, const void* data,
                                             size_t length) {
   keychain_data_[item].length = length;
   if (length > 0) {
     if (keychain_data_[item].data)
       free(keychain_data_[item].data);
     keychain_data_[item].data = malloc(length);
     memcpy(keychain_data_[item].data, data, length);
   } else {
     keychain_data_[item].data = NULL;
   }
 }
 
-void MockKeychain::SetTestDataPasswordString(int item, const char* value) {
+void MockKeychain::SetTestDataPasswordString(unsigned int item,
+                                             const char* value) {
   SetTestDataPasswordBytes(item, value, value ? strlen(value) : 0);
 }
 
 OSStatus MockKeychain::ItemCopyAttributesAndData(
     SecKeychainItemRef itemRef,
     SecKeychainAttributeInfo* info,
     SecItemClass* itemClass,
     SecKeychainAttributeList** attrList,
     UInt32* length,
     void** outData) const {
   DCHECK(itemRef);
-  unsigned int key = reinterpret_cast<unsigned int>(itemRef) - 1;
+  unsigned int key = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(itemRef)) - 1;
   if (keychain_attr_list_.find(key) == keychain_attr_list_.end())
     return errSecInvalidItemRef;
 
   DCHECK(!itemClass);  // itemClass not implemented in the Mock.
   if (attrList)
     *attrList  = &(keychain_attr_list_[key]);
   if (outData) {
     *outData = keychain_data_[key].data;
     DCHECK(length);
     *length = keychain_data_[key].length;
   }
 
   ++attribute_data_copy_count_;
   return noErr;
 }
 
 OSStatus MockKeychain::ItemModifyAttributesAndData(
     SecKeychainItemRef itemRef,
     const SecKeychainAttributeList* attrList,
     UInt32 length,
     const void* data) const {
   DCHECK(itemRef);
   const char* fail_trigger = "fail_me";
   if (length == strlen(fail_trigger) &&
       memcmp(data, fail_trigger, length) == 0) {
     return errSecAuthFailed;
   }
 
-  unsigned int key = reinterpret_cast<unsigned int>(itemRef) - 1;
+  unsigned int key = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(itemRef)) - 1;
   if (keychain_attr_list_.find(key) == keychain_attr_list_.end())
     return errSecInvalidItemRef;
 
   MockKeychain* mutable_this = const_cast<MockKeychain*>(this);
   if (attrList) {
     for (UInt32 change_attr = 0; change_attr < attrList->count; ++change_attr) {
       if (attrList->attr[change_attr].tag == kSecCreatorItemAttr) {
         void* data = attrList->attr[change_attr].data;
         mutable_this->SetTestDataCreator(key, *(static_cast<OSType*>(data)));
       } else {
         NOTIMPLEMENTED();
       }
     }
   }
   if (data)
     mutable_this->SetTestDataPasswordBytes(key, data, length);
   return noErr;
 }
 
 OSStatus MockKeychain::ItemFreeAttributesAndData(
     SecKeychainAttributeList* attrList,
     void* data) const {
   --attribute_data_copy_count_;
   return noErr;
 }
 
 OSStatus MockKeychain::ItemDelete(SecKeychainItemRef itemRef) const {
-  unsigned int key = reinterpret_cast<unsigned int>(itemRef) - 1;
+  unsigned int key = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(itemRef)) - 1;
 
   for (unsigned int i = 0; i < keychain_attr_list_[key].count; ++i) {
     if (keychain_attr_list_[key].attr[i].data)
       free(keychain_attr_list_[key].attr[i].data);
   }
   free(keychain_attr_list_[key].attr);
   if (keychain_data_[key].data)
     free(keychain_data_[key].data);
 
   keychain_attr_list_.erase(key);
@@ skipping 230 matching lines @@
   add_generic_password_ =
       std::string(const_cast<char*>(static_cast<const char*>(passwordData)),
                   passwordLength);
   return noErr;
 }
 
 void MockKeychain::Free(CFTypeRef ref) const {
   if (!ref)
     return;
 
-  if (reinterpret_cast<int>(ref) == kDummySearchRef) {
+  if (static_cast<unsigned int>(reinterpret_cast<uintptr_t>(ref)) == kDummySearchRef) {
     --search_copy_count_;
   } else {
     --keychain_item_copy_count_;
   }
 }
 
 int MockKeychain::UnfreedSearchCount() const {
   return search_copy_count_;
 }
 
@@ skipping 28 matching lines @@
   SetTestDataPort(key, item_data.port);
   SetTestDataString(key, kSecSecurityDomainItemAttr,
                     item_data.security_domain);
   SetTestDataString(key, kSecCreationDateItemAttr, item_data.creation_date);
   SetTestDataString(key, kSecAccountItemAttr, item_data.username);
   SetTestDataPasswordString(key, item_data.password);
   SetTestDataNegativeItem(key, item_data.negative_item);
 }
 
 } // namespace crypto