Move *keychain_mac* files to crypto/

chrome/browser/mock_keychain_mac.cc

Index: chrome/browser/mock_keychain_mac.cc
diff --git a/chrome/browser/mock_keychain_mac.cc b/chrome/browser/mock_keychain_mac.cc
deleted file mode 100644
index 59d2b5835b51582cf4597e13874fd2f1cbda51cb..0000000000000000000000000000000000000000
--- a/chrome/browser/mock_keychain_mac.cc
+++ /dev/null
@@ -1,525 +0,0 @@
-// 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 "chrome/browser/mock_keychain_mac.h"
-
-MockKeychain::MockKeychain()
-    : next_item_key_(0),
-      search_copy_count_(0),
-      keychain_item_copy_count_(0),
-      attribute_data_copy_count_(0),
-      find_generic_result_(noErr),
-      called_add_generic_(false),
-      password_data_count_(0) {}
-
-void MockKeychain::InitializeKeychainData(unsigned int key) const {
-  UInt32 tags[] = { kSecAccountItemAttr,
-                    kSecServerItemAttr,
-                    kSecPortItemAttr,
-                    kSecPathItemAttr,
-                    kSecProtocolItemAttr,
-                    kSecAuthenticationTypeItemAttr,
-                    kSecSecurityDomainItemAttr,
-                    kSecCreationDateItemAttr,
-                    kSecNegativeItemAttr,
-                    kSecCreatorItemAttr };
-  keychain_attr_list_[key] = SecKeychainAttributeList();
-  keychain_data_[key] = KeychainPasswordData();
-  keychain_attr_list_[key].count = arraysize(tags);
-  keychain_attr_list_[key].attr = static_cast<SecKeychainAttribute*>(
-      calloc(keychain_attr_list_[key].count, sizeof(SecKeychainAttribute)));
-  for (unsigned int i = 0; i < keychain_attr_list_[key].count; ++i) {
-    keychain_attr_list_[key].attr[i].tag = tags[i];
-    size_t data_size = 0;
-    switch (tags[i]) {
-      case kSecPortItemAttr:
-        data_size = sizeof(UInt32);
-        break;
-      case kSecProtocolItemAttr:
-        data_size = sizeof(SecProtocolType);
-        break;
-      case kSecAuthenticationTypeItemAttr:
-        data_size = sizeof(SecAuthenticationType);
-        break;
-      case kSecNegativeItemAttr:
-        data_size = sizeof(Boolean);
-        break;
-      case kSecCreatorItemAttr:
-        data_size = sizeof(OSType);
-        break;
-    }
-    if (data_size > 0) {
-      keychain_attr_list_[key].attr[i].length = data_size;
-      keychain_attr_list_[key].attr[i].data = calloc(1, data_size);
-    }
-  }
-}
-
-MockKeychain::~MockKeychain() {
-  for (std::map<unsigned int, SecKeychainAttributeList>::iterator it =
-       keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) {
-    for (unsigned int i = 0; i < it->second.count; ++i) {
-      if (it->second.attr[i].data) {
-        free(it->second.attr[i].data);
-      }
-    }
-    free(it->second.attr);
-    if (keychain_data_[it->first].data) {
-      free(keychain_data_[it->first].data);
-    }
-  }
-  keychain_attr_list_.clear();
-  keychain_data_.clear();
-}
-
-SecKeychainAttribute* MockKeychain::AttributeWithTag(
-    const SecKeychainAttributeList& attribute_list, UInt32 tag) {
-  int attribute_index = -1;
-  for (unsigned int i = 0; i < attribute_list.count; ++i) {
-    if (attribute_list.attr[i].tag == tag) {
-      attribute_index = i;
-      break;
-    }
-  }
-  if (attribute_index == -1) {
-    NOTREACHED() << "Unsupported attribute: " << tag;
-    return NULL;
-  }
-  return &(attribute_list.attr[attribute_index]);
-}
-
-void MockKeychain::SetTestDataBytes(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) {
-  SetTestDataBytes(item, tag, value, value ? strlen(value) : 0);
-}
-
-void MockKeychain::SetTestDataPort(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) {
-  SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
-                                                     kSecProtocolItemAttr);
-  SecProtocolType* data = static_cast<SecProtocolType*>(attribute->data);
-  *data = value;
-}
-
-void MockKeychain::SetTestDataAuthType(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) {
-  SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
-                                                     kSecNegativeItemAttr);
-  Boolean* data = static_cast<Boolean*>(attribute->data);
-  *data = value;
-}
-
-void MockKeychain::SetTestDataCreator(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,
-                                            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) {
-  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;
-  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;
-  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;
-
-  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);
-  keychain_data_.erase(key);
-  added_via_api_.erase(key);
-  return noErr;
-}
-
-OSStatus MockKeychain::SearchCreateFromAttributes(
-    CFTypeRef keychainOrArray, SecItemClass itemClass,
-    const SecKeychainAttributeList *attrList,
-    SecKeychainSearchRef *searchRef) const {
-  // Figure out which of our mock items matches, and set up the array we'll use
-  // to generate results out of SearchCopyNext.
-  remaining_search_results_.clear();
-  for (std::map<unsigned int, SecKeychainAttributeList>::const_iterator it =
-       keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) {
-    bool mock_item_matches = true;
-    for (UInt32 search_attr = 0; search_attr < attrList->count; ++search_attr) {
-      SecKeychainAttribute* mock_attribute =
-          AttributeWithTag(it->second, attrList->attr[search_attr].tag);
-      if (mock_attribute->length != attrList->attr[search_attr].length ||
-          memcmp(mock_attribute->data, attrList->attr[search_attr].data,
-                 attrList->attr[search_attr].length) != 0) {
-        mock_item_matches = false;
-        break;
-      }
-    }
-    if (mock_item_matches) {
-      remaining_search_results_.push_back(it->first);
-    }
-  }
-
-  DCHECK(searchRef);
-  *searchRef = reinterpret_cast<SecKeychainSearchRef>(kDummySearchRef);
-  ++search_copy_count_;
-  return noErr;
-}
-
-bool MockKeychain::AlreadyContainsInternetPassword(
-    UInt32 serverNameLength, const char *serverName,
-    UInt32 securityDomainLength, const char *securityDomain,
-    UInt32 accountNameLength, const char *accountName,
-    UInt32 pathLength, const char *path,
-    UInt16 port, SecProtocolType protocol,
-    SecAuthenticationType authenticationType) const {
-  for (std::map<unsigned int, SecKeychainAttributeList>::const_iterator it =
-       keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) {
-    SecKeychainAttribute* attribute;
-    attribute = AttributeWithTag(it->second, kSecServerItemAttr);
-    if ((attribute->length != serverNameLength) ||
-        (attribute->data == NULL && *serverName != '\0') ||
-        (attribute->data != NULL && *serverName == '\0') ||
-        strncmp(serverName,
-                (const char*) attribute->data,
-                serverNameLength) != 0) {
-      continue;
-    }
-    attribute = AttributeWithTag(it->second, kSecSecurityDomainItemAttr);
-    if ((attribute->length != securityDomainLength) ||
-        (attribute->data == NULL && *securityDomain != '\0') ||
-        (attribute->data != NULL && *securityDomain == '\0') ||
-        strncmp(securityDomain,
-                (const char*) attribute->data,
-                securityDomainLength) != 0) {
-      continue;
-    }
-    attribute = AttributeWithTag(it->second, kSecAccountItemAttr);
-    if ((attribute->length != accountNameLength) ||
-        (attribute->data == NULL && *accountName != '\0') ||
-        (attribute->data != NULL && *accountName == '\0') ||
-        strncmp(accountName,
-                (const char*) attribute->data,
-                accountNameLength) != 0) {
-      continue;
-    }
-    attribute = AttributeWithTag(it->second, kSecPathItemAttr);
-    if ((attribute->length != pathLength) ||
-        (attribute->data == NULL && *path != '\0') ||
-        (attribute->data != NULL && *path == '\0') ||
-        strncmp(path,
-                (const char*) attribute->data,
-                pathLength) != 0) {
-      continue;
-    }
-    attribute = AttributeWithTag(it->second, kSecPortItemAttr);
-    if ((attribute->data == NULL) ||
-        (port != *(static_cast<UInt32*>(attribute->data)))) {
-      continue;
-    }
-    attribute = AttributeWithTag(it->second, kSecProtocolItemAttr);
-    if ((attribute->data == NULL) ||
-        (protocol != *(static_cast<SecProtocolType*>(attribute->data)))) {
-      continue;
-    }
-    attribute = AttributeWithTag(it->second, kSecAuthenticationTypeItemAttr);
-    if ((attribute->data == NULL) ||
-        (authenticationType !=
-            *(static_cast<SecAuthenticationType*>(attribute->data)))) {
-      continue;
-    }
-    // The keychain already has this item, since all fields other than the
-    // password match.
-    return true;
-  }
-  return false;
-}
-
-OSStatus MockKeychain::AddInternetPassword(
-    SecKeychainRef keychain,
-    UInt32 serverNameLength, const char *serverName,
-    UInt32 securityDomainLength, const char *securityDomain,
-    UInt32 accountNameLength, const char *accountName,
-    UInt32 pathLength, const char *path,
-    UInt16 port, SecProtocolType protocol,
-    SecAuthenticationType authenticationType,
-    UInt32 passwordLength, const void *passwordData,
-    SecKeychainItemRef *itemRef) const {
-
-  // Check for the magic duplicate item trigger.
-  if (strcmp(serverName, "some.domain.com") == 0) {
-    return errSecDuplicateItem;
-  }
-
-  // If the account already exists in the keychain, we don't add it.
-  if (AlreadyContainsInternetPassword(serverNameLength, serverName,
-                                      securityDomainLength, securityDomain,
-                                      accountNameLength, accountName,
-                                      pathLength, path,
-                                      port, protocol,
-                                      authenticationType)) {
-    return errSecDuplicateItem;
-  }
-
-  // Pick the next unused slot.
-  unsigned int key = next_item_key_++;
-
-  // Initialize keychain data storage at the target location.
-  InitializeKeychainData(key);
-
-  MockKeychain* mutable_this = const_cast<MockKeychain*>(this);
-  mutable_this->SetTestDataBytes(key, kSecServerItemAttr, serverName,
-                                 serverNameLength);
-  mutable_this->SetTestDataBytes(key, kSecSecurityDomainItemAttr,
-                                 securityDomain, securityDomainLength);
-  mutable_this->SetTestDataBytes(key, kSecAccountItemAttr, accountName,
-                                 accountNameLength);
-  mutable_this->SetTestDataBytes(key, kSecPathItemAttr, path, pathLength);
-  mutable_this->SetTestDataPort(key, port);
-  mutable_this->SetTestDataProtocol(key, protocol);
-  mutable_this->SetTestDataAuthType(key, authenticationType);
-  mutable_this->SetTestDataPasswordBytes(key, passwordData,
-                                         passwordLength);
-  base::Time::Exploded exploded_time;
-  base::Time::Now().UTCExplode(&exploded_time);
-  char time_string[128];
-  snprintf(time_string, sizeof(time_string), "%04d%02d%02d%02d%02d%02dZ",
-           exploded_time.year, exploded_time.month, exploded_time.day_of_month,
-           exploded_time.hour, exploded_time.minute, exploded_time.second);
-  mutable_this->SetTestDataString(key, kSecCreationDateItemAttr, time_string);
-
-  added_via_api_.insert(key);
-
-  if (itemRef) {
-    *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1);
-    ++keychain_item_copy_count_;
-  }
-  return noErr;
-}
-
-OSStatus MockKeychain::SearchCopyNext(SecKeychainSearchRef searchRef,
-                                      SecKeychainItemRef *itemRef) const {
-  if (remaining_search_results_.empty()) {
-    return errSecItemNotFound;
-  }
-  unsigned int key = remaining_search_results_.front();
-  remaining_search_results_.erase(remaining_search_results_.begin());
-  *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1);
-  ++keychain_item_copy_count_;
-  return noErr;
-}
-
-OSStatus MockKeychain::FindGenericPassword(CFTypeRef keychainOrArray,
-                                           UInt32 serviceNameLength,
-                                           const char *serviceName,
-                                           UInt32 accountNameLength,
-                                           const char *accountName,
-                                           UInt32 *passwordLength,
-                                           void **passwordData,
-                                           SecKeychainItemRef *itemRef) const {
-  // When simulating |noErr| we return canned |passwordData| and
-  // |passwordLenght|.  Otherwise, just return given code.
-  if (find_generic_result_ == noErr) {
-    static char password[] = "my_password";
-
-    DCHECK(passwordData);
-    *passwordData = static_cast<void*>(password);
-    DCHECK(passwordLength);
-    *passwordLength = strlen(password);
-    password_data_count_++;
-  }
-
-  return find_generic_result_;
-}
-
-OSStatus MockKeychain::ItemFreeContent(SecKeychainAttributeList *attrList,
-                                       void *data) const {
-  // No-op.
-  password_data_count_--;
-  return noErr;
-}
-
-OSStatus MockKeychain::AddGenericPassword(SecKeychainRef keychain,
-                                          UInt32 serviceNameLength,
-                                          const char *serviceName,
-                                          UInt32 accountNameLength,
-                                          const char *accountName,
-                                          UInt32 passwordLength,
-                                          const void *passwordData,
-                                          SecKeychainItemRef *itemRef) const {
-  called_add_generic_ = true;
-
-  DCHECK(passwordLength > 0);
-  DCHECK(passwordData);
-  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) {
-    --search_copy_count_;
-  } else {
-    --keychain_item_copy_count_;
-  }
-}
-
-int MockKeychain::UnfreedSearchCount() const {
-  return search_copy_count_;
-}
-
-int MockKeychain::UnfreedKeychainItemCount() const {
-  return keychain_item_copy_count_;
-}
-
-int MockKeychain::UnfreedAttributeDataCount() const {
-  return attribute_data_copy_count_;
-}
-
-bool MockKeychain::CreatorCodesSetForAddedItems() const {
-  for (std::set<unsigned int>::const_iterator i = added_via_api_.begin();
-       i != added_via_api_.end(); ++i) {
-    SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[*i],
-                                                       kSecCreatorItemAttr);
-    OSType* data = static_cast<OSType*>(attribute->data);
-    if (*data == 0) {
-      return false;
-    }
-  }
-  return true;
-}
-
-void MockKeychain::AddTestItem(const KeychainTestData& item_data) {
-  unsigned int key = next_item_key_++;
-
-  InitializeKeychainData(key);
-  SetTestDataAuthType(key, item_data.auth_type);
-  SetTestDataString(key, kSecServerItemAttr, item_data.server);
-  SetTestDataProtocol(key, item_data.protocol);
-  SetTestDataString(key, kSecPathItemAttr, item_data.path);
-  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);
-}