Rename MacKeychain to AppleKeychain

chrome/browser/password_manager/password_store_mac_unittest.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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_store_consumer.h"
 #include "chrome/browser/password_manager/password_store_mac.h"
 #include "chrome/browser/password_manager/password_store_mac_internal.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/test/test_browser_thread.h"
-#include "crypto/mock_keychain_mac.h"
+#include "crypto/mock_apple_keychain.h"
 
 using content::BrowserThread;
-using crypto::MockKeychain;
+using crypto::MockAppleKeychain;
 using webkit::forms::PasswordForm;
 using testing::_;
 using testing::DoAll;
 using testing::WithArg;
 
 namespace {
 
 class MockPasswordStoreConsumer : public PasswordStoreConsumer {
 public:
   MOCK_METHOD2(OnPasswordStoreRequestDone,
@@ skipping 10 matching lines @@
   MessageLoop::current()->Quit();
 }
 
 }  // namespace
 
 #pragma mark -
 
 class PasswordStoreMacInternalsTest : public testing::Test {
  public:
   virtual void SetUp() {
-    MockKeychain::KeychainTestData test_data[] = {
+    MockAppleKeychain::KeychainTestData test_data[] = {
       // Basic HTML form.
       { kSecAuthenticationTypeHTMLForm, "some.domain.com",
         kSecProtocolTypeHTTP, NULL, 0, NULL, "20020601171500Z",
         "joe_user", "sekrit", false },
       // HTML form with path.
       { kSecAuthenticationTypeHTMLForm, "some.domain.com",
         kSecProtocolTypeHTTP, "/insecure.html", 0, NULL, "19991231235959Z",
         "joe_user", "sekrit", false },
       // Secure HTML form with path.
       { kSecAuthenticationTypeHTMLForm, "some.domain.com",
@@ skipping 19 matching lines @@
       // HTTP auth digest, secure.
       { kSecAuthenticationTypeHTTPDigest, "some.domain.com",
         kSecProtocolTypeHTTPS, NULL, 0, "high_security", "19980330100000Z",
         "digest_auth_user", "digest", false },
       // An FTP password with an invalid date, for edge-case testing.
       { kSecAuthenticationTypeDefault, "a.server.com",
         kSecProtocolTypeFTP, NULL, 0, NULL, "20010203040",
         "abc", "123", false },
     };
 
-    keychain_ = new MockKeychain();
+    keychain_ = new MockAppleKeychain();
 
     for (unsigned int i = 0; i < arraysize(test_data); ++i) {
       keychain_->AddTestItem(test_data[i]);
     }
   }
 
   virtual void TearDown() {
     ExpectCreatesAndFreesBalanced();
     ExpectCreatorCodesSet();
     delete keychain_;
   }
 
  protected:
   // Causes a test failure unless everything returned from keychain_'s
   // ItemCopyAttributesAndData, SearchCreateFromAttributes, and SearchCopyNext
   // was correctly freed.
   void ExpectCreatesAndFreesBalanced() {
     EXPECT_EQ(0, keychain_->UnfreedSearchCount());
     EXPECT_EQ(0, keychain_->UnfreedKeychainItemCount());
     EXPECT_EQ(0, keychain_->UnfreedAttributeDataCount());
   }
 
   // Causes a test failure unless any Keychain items added during the test have
   // their creator code set.
   void ExpectCreatorCodesSet() {
     EXPECT_TRUE(keychain_->CreatorCodesSetForAddedItems());
   }
 
-  MockKeychain* keychain_;
+  MockAppleKeychain* keychain_;
 };
 
 #pragma mark -
 
 // Struct used for creation of PasswordForms from static arrays of data.
 struct PasswordFormData {
   const PasswordForm::Scheme scheme;
   const char* signon_realm;
   const char* origin;
   const char* action;
@@ skipping 133 matching lines @@
       "https://some.domain.com/", L"digest_auth_user", L"digest", true,
       1998,  3, 30, 10,  0,  0 },
     // This one gives us an invalid date, which we will treat as a "NULL" date
     // which is 1601.
     { PasswordForm::SCHEME_OTHER, "http://a.server.com/",
       "http://a.server.com/", L"abc", L"123", false,
       1601,  1,  1,  0,  0,  0 },
   };
 
   for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(expected); ++i) {
-    // Create our fake KeychainItemRef; see MockKeychain docs.
+    // Create our fake KeychainItemRef; see MockAppleKeychain docs.
     SecKeychainItemRef keychain_item =
         reinterpret_cast<SecKeychainItemRef>(i + 1);
     PasswordForm form;
     bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
         *keychain_, keychain_item, &form);
 
     EXPECT_TRUE(parsed) << "In iteration " << i;
 
     EXPECT_EQ(expected[i].scheme, form.scheme) << "In iteration " << i;
     EXPECT_EQ(GURL(expected[i].origin), form.origin) << "In iteration " << i;
@@ skipping 219 matching lines @@
         "http://a.site.com:2222/", NULL, NULL, NULL, NULL,
         L"username", L"password", false, false, 0 }, true },
     { { PasswordForm::SCHEME_DIGEST, "https://digest.site.com/differentrealm",
         "https://digest.site.com/secure.html", NULL, NULL, NULL, NULL,
         L"testname", L"testpass", false, false, 0 }, true },
     // Make sure that garbage forms are rejected.
     { { PasswordForm::SCHEME_HTML, "gobbledygook",
         "gobbledygook", NULL, NULL, NULL, NULL,
         L"anonymous", L"knock-knock", false, false, 0 }, false },
     // Test that failing to update a duplicate (forced using the magic failure
-    // password; see MockKeychain::ItemModifyAttributesAndData) is reported.
+    // password; see MockAppleKeychain::ItemModifyAttributesAndData) is
+    // reported.
     { { PasswordForm::SCHEME_HTML, "http://some.domain.com",
         "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
         L"joe_user", L"fail_me", false, false, 0 }, false },
   };
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     scoped_ptr<PasswordForm> in_form(
@@ skipping 371 matching lines @@
 class PasswordStoreMacTest : public testing::Test {
  public:
   PasswordStoreMacTest() : ui_thread_(BrowserThread::UI, &message_loop_) {}
 
   virtual void SetUp() {
     login_db_ = new LoginDatabase();
     ASSERT_TRUE(db_dir_.CreateUniqueTempDir());
     FilePath db_file = db_dir_.path().AppendASCII("login.db");
     ASSERT_TRUE(login_db_->Init(db_file));
 
-    keychain_ = new MockKeychain();
+    keychain_ = new MockAppleKeychain();
 
     store_ = new PasswordStoreMac(keychain_, login_db_);
     ASSERT_TRUE(store_->Init());
   }
 
   virtual void TearDown() {
     store_->ShutdownOnUIThread();
     MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     MessageLoop::current()->Run();
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
 
-  MockKeychain* keychain_;  // Owned by store_.
+  MockAppleKeychain* keychain_;  // Owned by store_.
   LoginDatabase* login_db_;  // Owned by store_.
   scoped_refptr<PasswordStoreMac> store_;
   ScopedTempDir db_dir_;
 };
 
 TEST_F(PasswordStoreMacTest, TestStoreUpdate) {
   // Insert a password into both the database and the keychain.
   // This is done manually, rather than through store_->AddLogin, because the
   // Mock Keychain isn't smart enough to be able to support update generically,
   // so some.domain.com triggers special handling to test it that make inserting
   // fail.
   PasswordFormData joint_data = {
     PasswordForm::SCHEME_HTML, "http://some.domain.com/",
     "http://some.domain.com/insecure.html", "login.cgi",
     L"username", L"password", L"submit", L"joe_user", L"sekrit", true, false, 1
   };
   scoped_ptr<PasswordForm> joint_form(CreatePasswordFormFromData(joint_data));
   login_db_->AddLogin(*joint_form);
-  MockKeychain::KeychainTestData joint_keychain_data = {
+  MockAppleKeychain::KeychainTestData joint_keychain_data = {
     kSecAuthenticationTypeHTMLForm, "some.domain.com",
     kSecProtocolTypeHTTP, "/insecure.html", 0, NULL, "20020601171500Z",
     "joe_user", "sekrit", false };
   keychain_->AddTestItem(joint_keychain_data);
 
   // Insert a password into the keychain only.
-  MockKeychain::KeychainTestData keychain_only_data = {
+  MockAppleKeychain::KeychainTestData keychain_only_data = {
     kSecAuthenticationTypeHTMLForm, "keychain.only.com",
     kSecProtocolTypeHTTP, NULL, 0, NULL, "20020601171500Z",
     "keychain", "only", false
   };
   keychain_->AddTestItem(keychain_only_data);
 
   struct UpdateData {
     PasswordFormData form_data;
     const char* password;  // NULL indicates no entry should be present.
   };
@@ skipping 56 matching lines @@
       EXPECT_EQ(0U, matching_items.size()) << "iteration " << i;
     }
     STLDeleteElements(&matching_items);
 
     login_db_->GetLogins(*query_form, &matching_items);
     EXPECT_EQ(updates[i].password ? 1U : 0U, matching_items.size())
         << "iteration " << i;
     STLDeleteElements(&matching_items);
   }
 }