Rename MacKeychain to AppleKeychain

chrome/browser/password_manager/password_store_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 "chrome/browser/password_manager/password_store_mac.h"
 #include "chrome/browser/password_manager/password_store_mac_internal.h"
 
 #include <CoreServices/CoreServices.h>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/password_manager/login_database.h"
 #include "chrome/browser/password_manager/password_store_change.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
-#include "crypto/keychain_mac.h"
+#include "crypto/apple_keychain.h"
 
-using crypto::MacKeychain;
+using crypto::AppleKeychain;
 using webkit::forms::PasswordForm;
 
 // Utility class to handle the details of constructing and running a keychain
 // search from a set of attributes.
 class KeychainSearch {
  public:
-  explicit KeychainSearch(const MacKeychain& keychain);
+  explicit KeychainSearch(const AppleKeychain& keychain);
   ~KeychainSearch();
 
   // Sets up a keycahin search based on an non "null" (NULL for char*,
   // The appropriate "Any" entry for other types) arguments.
   //
   // IMPORTANT: Any paramaters passed in *must* remain valid for as long as the
   // KeychainSearch object, since the search uses them by reference.
   void Init(const char* server, const UInt32& port,
             const SecProtocolType& protocol,
             const SecAuthenticationType& auth_type, const char* security_domain,
             const char* path, const char* username, OSType creator);
 
   // Fills |items| with all Keychain items that match the Init'd search.
   // If the search fails for any reason, |items| will be unchanged.
   void FindMatchingItems(std::vector<SecKeychainItemRef>* matches);
 
  private:
-  const MacKeychain* keychain_;
+  const AppleKeychain* keychain_;
   SecKeychainAttributeList search_attributes_;
   SecKeychainSearchRef search_ref_;
 };
 
-KeychainSearch::KeychainSearch(const MacKeychain& keychain)
+KeychainSearch::KeychainSearch(const AppleKeychain& keychain)
     : keychain_(&keychain), search_ref_(NULL) {
   search_attributes_.count = 0;
   search_attributes_.attr = NULL;
 }
 
 KeychainSearch::~KeychainSearch() {
   if (search_attributes_.attr) {
     free(search_attributes_.attr);
   }
 }
@@ skipping 156 matching lines @@
 // Returns the PasswordForm Scheme corresponding to |auth_type|.
 PasswordForm::Scheme SchemeForAuthType(SecAuthenticationType auth_type) {
   switch (auth_type) {
     case kSecAuthenticationTypeHTMLForm:   return PasswordForm::SCHEME_HTML;
     case kSecAuthenticationTypeHTTPBasic:  return PasswordForm::SCHEME_BASIC;
     case kSecAuthenticationTypeHTTPDigest: return PasswordForm::SCHEME_DIGEST;
     default:                               return PasswordForm::SCHEME_OTHER;
   }
 }
 
-bool FillPasswordFormFromKeychainItem(const MacKeychain& keychain,
+bool FillPasswordFormFromKeychainItem(const AppleKeychain& keychain,
                                       const SecKeychainItemRef& keychain_item,
                                       PasswordForm* form) {
   DCHECK(form);
 
   SecKeychainAttributeInfo attrInfo;
   UInt32 tags[] = { kSecAccountItemAttr,
                     kSecServerItemAttr,
                     kSecPortItemAttr,
                     kSecPathItemAttr,
                     kSecProtocolItemAttr,
@@ skipping 192 matching lines @@
   // Add in the blacklist entries from the database.
   merged_forms->insert(merged_forms->end(),
                        database_blacklist_forms.begin(),
                        database_blacklist_forms.end());
 
   // Clear out all the Keychain entries we used.
   DeleteVectorElementsInSet(keychain_forms, used_keychain_forms);
 }
 
 std::vector<PasswordForm*> GetPasswordsForForms(
-    const MacKeychain& keychain, std::vector<PasswordForm*>* database_forms) {
+    const AppleKeychain& keychain,
+    std::vector<PasswordForm*>* database_forms) {
   MacKeychainPasswordFormAdapter keychain_adapter(&keychain);
 
   std::vector<PasswordForm*> merged_forms;
   for (std::vector<PasswordForm*>::iterator i = database_forms->begin();
        i != database_forms->end();) {
     std::vector<PasswordForm*> db_form_container(1, *i);
     std::vector<PasswordForm*> keychain_matches =
         keychain_adapter.PasswordsMergeableWithForm(**i);
     MergePasswordForms(&keychain_matches, &db_form_container, &merged_forms);
     if (db_form_container.empty()) {
       i = database_forms->erase(i);
     } else {
       ++i;
     }
     STLDeleteElements(&keychain_matches);
   }
   return merged_forms;
 }
 
 }  // namespace internal_keychain_helpers
 
 #pragma mark -
 
 MacKeychainPasswordFormAdapter::MacKeychainPasswordFormAdapter(
-    const MacKeychain* keychain)
+    const AppleKeychain* keychain)
     : keychain_(keychain), finds_only_owned_(false) {
 }
 
 std::vector<PasswordForm*>
     MacKeychainPasswordFormAdapter::PasswordsFillingForm(
         const PasswordForm& query_form) {
   std::vector<SecKeychainItemRef> keychain_items =
       MatchingKeychainItems(query_form.signon_realm, query_form.scheme,
                             NULL, NULL);
 
@@ skipping 244 matching lines @@
                                                            &attrList, 0, NULL);
   return result == noErr;
 }
 
 OSType MacKeychainPasswordFormAdapter::CreatorCodeForSearch() {
   return finds_only_owned_ ? base::mac::CreatorCodeForApplication() : 0;
 }
 
 #pragma mark -
 
-PasswordStoreMac::PasswordStoreMac(MacKeychain* keychain,
+PasswordStoreMac::PasswordStoreMac(AppleKeychain* keychain,
                                    LoginDatabase* login_db)
     : keychain_(keychain), login_metadata_db_(login_db) {
   DCHECK(keychain_.get());
   DCHECK(login_metadata_db_.get());
 }
 
 PasswordStoreMac::~PasswordStoreMac() {
   if (thread_.get()) {
     thread_->message_loop()->DeleteSoon(FROM_HERE,
                                         notification_service_.release());
@@ skipping 264 matching lines @@
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (std::vector<PasswordForm*>::const_iterator i = forms.begin();
        i != forms.end(); ++i) {
     owned_keychain_adapter.RemovePassword(**i);
   }
 }
 
 void PasswordStoreMac::CreateNotificationService() {
   notification_service_.reset(content::NotificationService::Create());
 }