Remove a bunch of low-level keychain helper tests that are now redundant with...

chrome/browser/password_manager/password_store_mac_unittest.cc

 // Copyright (c) 2009 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/gtest/include/gtest/gtest.h"
 
 #include "base/basictypes.h"
+#include "base/stl_util-inl.h"
 #include "chrome/browser/keychain_mock_mac.h"
 #include "chrome/browser/password_manager/password_store_mac.h"
 #include "chrome/browser/password_manager/password_store_mac_internal.h"
 
 using webkit_glue::PasswordForm;
 
 class PasswordStoreMacTest : public testing::Test {
  public:
   virtual void SetUp() {
     MockKeychain::KeychainTestData test_data[] = {
@@ skipping 23 matching lines @@
         "Password Not Stored", " ", false },
       // HTTP auth basic, with port and path.
       { kSecAuthenticationTypeHTTPBasic, "some.domain.com",
         kSecProtocolTypeHTTP, "/insecure.html", 4567, "low_security",
         "19980330100000Z",
         "basic_auth_user", "basic", false },
       // 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 },
     };
 
     // Save one slot for use by AddInternetPassword.
     unsigned int capacity = arraysize(test_data) + 1;
     keychain_ = new MockKeychain(capacity);
 
     for (unsigned int i = 0; i < arraysize(test_data); ++i) {
       keychain_->AddTestItem(test_data[i]);
     }
   }
@@ skipping 109 matching lines @@
     } else {
       EXPECT_TRUE(form->blacklisted_by_user) << test_label;
     }
     EXPECT_EQ(expectation->preferred, form->preferred)  << test_label;
     EXPECT_EQ(expectation->ssl_valid, form->ssl_valid) << test_label;
     EXPECT_DOUBLE_EQ(expectation->creation_time,
                      form->date_created.ToDoubleT()) << test_label;
   }
 }
 
-// Frees all the Keychain items in |items|, and clears the vector.
-static void FreeKeychainItems(const MacKeychain& keychain,
-                              std::vector<SecKeychainItemRef>* items) {
-  CHECK(items);
-  for (std::vector<SecKeychainItemRef>::iterator i = items->begin();
-       i != items->end(); ++i) {
-    keychain.Free(*i);
-  }
-  items->clear();
-}
-
-// Deletes all the PasswordForms in |forms|, and clears the vector.
-static void DeletePasswordForms(std::vector<PasswordForm*>* forms) {
-  CHECK(forms);
-  for (std::vector<PasswordForm*>::iterator i = forms->begin();
-       i != forms->end(); ++i) {
-    delete *i;
-  }
-  forms->clear();
-}
-
 #pragma mark -
 
-TEST_F(PasswordStoreMacTest, TestSignonRealmParsing) {
-  typedef struct {
-    const char* signon_realm;
-    const bool expected_parsed;
-    const char* expected_server;
-    const bool expected_is_secure;
-    const int expected_port;
-    const char* expected_security_domain;
-  } TestData;
-
-  TestData test_data[] = {
-    // HTML form signon realms.
-    { "http://www.domain.com/",
-        true, "www.domain.com", false, 0, "" },
-    { "https://foo.org:9999/",
-        true, "foo.org", true, 9999, "" },
-    // HTTP auth signon realms.
-    { "http://httpauth.com:8080/lowsecurity",
-        true, "httpauth.com", false, 8080, "lowsecurity" },
-    { "https://httpauth.com/highsecurity",
-        true, "httpauth.com", true, 0 , "highsecurity" },
-    // Bogus realms
-    { "blahblahblah",
-        false, false, "", 0, "" },
-    { "foo/bar/baz",
-        false, false, "", 0, "" },
-  };
-
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
-    std::string server;
-    std::string security_domain;
-    bool is_secure = false;
-    int port = -1;
-    bool parsed = internal_keychain_helpers::ExtractSignonRealmComponents(
-        std::string(test_data[i].signon_realm), &server, &port, &is_secure,
-        &security_domain);
-    EXPECT_EQ(test_data[i].expected_parsed, parsed) << "In iteration " << i;
-
-    if (!parsed) {
-      continue;  // If parse failed, out params are undefined.
-    }
-    EXPECT_EQ(std::string(test_data[i].expected_server), server)
-        << "In iteration " << i;
-    EXPECT_EQ(std::string(test_data[i].expected_security_domain),
-              security_domain)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_is_secure, is_secure)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_port, port) << "In iteration " << i;
-  }
-
-  // NULLs are allowed for out params.
-  bool parsed = internal_keychain_helpers::ExtractSignonRealmComponents(
-      std::string("http://foo.bar.com:1234/baz"), NULL, NULL, NULL, NULL);
-  EXPECT_TRUE(parsed);
-}
-
-TEST_F(PasswordStoreMacTest, TestURLConstruction) {
-  std::string host("exampledomain.com");
-  std::string path("/path/to/page.html");
-
-  GURL full_url = internal_keychain_helpers::URLFromComponents(false, host,
-                                                               1234, path);
-  EXPECT_TRUE(full_url.is_valid());
-  EXPECT_EQ(GURL("http://exampledomain.com:1234/path/to/page.html"), full_url);
-
-  GURL simple_secure_url = internal_keychain_helpers::URLFromComponents(
-      true, host, 0, std::string(""));
-  EXPECT_TRUE(simple_secure_url.is_valid());
-  EXPECT_EQ(GURL("https://exampledomain.com/"), simple_secure_url);
-}
-
-TEST_F(PasswordStoreMacTest, TestKeychainTime) {
-  typedef struct {
-    const char* time_string;
-    const bool expected_parsed;
-    const int expected_year;
-    const int expected_month;
-    const int expected_day;
-    const int expected_hour;
-    const int expected_minute;
-    const int expected_second;
-  } TestData;
-
-  TestData test_data[] = {
-    // HTML form signon realms.
-    { "19980330100000Z", true,  1998,  3, 30, 10,  0,  0 },
-    { "19991231235959Z", true,  1999, 12, 31, 23, 59, 59 },
-    { "20000101000000Z", true,  2000,  1,  1,  0,  0,  0 },
-    { "20011112012843Z", true,  2001, 11, 12,  1, 28, 43 },
-    { "20020601171530Z", true,  2002,  6,  1, 17, 15, 30 },
-    { "20100908070605Z", true,  2010,  9,  8,  7,  6,  5 },
-    { "20010203040",     false, 0, 0, 0, 0, 0, 0 },
-  };
-
-  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
-    base::Time time;
-    bool parsed = internal_keychain_helpers::TimeFromKeychainTimeString(
-        test_data[i].time_string, strlen(test_data[i].time_string), &time);
-    EXPECT_EQ(test_data[i].expected_parsed, parsed) << "In iteration " << i;
-    if (!parsed) {
-      continue;
-    }
-
-    base::Time::Exploded exploded_time;
-    time.UTCExplode(&exploded_time);
-    EXPECT_EQ(test_data[i].expected_year, exploded_time.year)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_month, exploded_time.month)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_day, exploded_time.day_of_month)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_hour, exploded_time.hour)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_minute, exploded_time.minute)
-        << "In iteration " << i;
-    EXPECT_EQ(test_data[i].expected_second, exploded_time.second)
-        << "In iteration " << i;
-  }
-}
-
-TEST_F(PasswordStoreMacTest, TestAuthTypeSchemeTranslation) {
-  // Our defined types should round-trip correctly.
-  SecAuthenticationType auth_types[] = { kSecAuthenticationTypeHTMLForm,
-                                         kSecAuthenticationTypeHTTPBasic,
-                                         kSecAuthenticationTypeHTTPDigest };
-  const int auth_count = sizeof(auth_types) / sizeof(SecAuthenticationType);
-  for (int i = 0; i < auth_count; ++i) {
-    SecAuthenticationType round_tripped_auth_type =
-        internal_keychain_helpers::AuthTypeForScheme(
-            internal_keychain_helpers::SchemeForAuthType(auth_types[i]));
-    EXPECT_EQ(auth_types[i], round_tripped_auth_type);
-  }
-  // Anything else should become SCHEME_OTHER and come back as Default.
-  PasswordForm::Scheme scheme_for_other_auth_type =
-      internal_keychain_helpers::SchemeForAuthType(kSecAuthenticationTypeNTLM);
-  SecAuthenticationType round_tripped_other_auth_type =
-      internal_keychain_helpers::AuthTypeForScheme(scheme_for_other_auth_type);
-  EXPECT_EQ(PasswordForm::SCHEME_OTHER, scheme_for_other_auth_type);
-  EXPECT_EQ(kSecAuthenticationTypeDefault, round_tripped_other_auth_type);
-}
-
 TEST_F(PasswordStoreMacTest, TestKeychainToFormTranslation) {
   typedef struct {
     const PasswordForm::Scheme scheme;
     const char* signon_realm;
     const char* origin;
     const wchar_t* username;  // Set to NULL to check for a blacklist entry.
     const wchar_t* password;
     const bool ssl_valid;
     const int creation_year;
     const int creation_month;
@@ skipping 21 matching lines @@
       2000,  1,  1,  0,  0,  0 },
     { PasswordForm::SCHEME_HTML, "https://dont.remember.com/",
       "https://dont.remember.com/", NULL, NULL, true,
       2000,  1,  1,  0,  0,  0 },
     { PasswordForm::SCHEME_BASIC, "http://some.domain.com:4567/low_security",
       "http://some.domain.com:4567/insecure.html", L"basic_auth_user", L"basic",
       false, 1998, 03, 30, 10, 00, 00 },
     { PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
       "https://some.domain.com/", L"digest_auth_user", L"digest", true,
       1998,  3, 30, 10,  0,  0 },
+    { PasswordForm::SCHEME_OTHER, "http://a.server.com/",
+      "http://a.server.com/", L"abc", L"123", false,
+      1970,  1,  1,  0,  0,  0 },
   };
 
   for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(expected); ++i) {
     // Create our fake KeychainItemRef; see MockKeychain docs.
     SecKeychainItemRef keychain_item =
         reinterpret_cast<SecKeychainItemRef>(i + 1);
     PasswordForm form;
     bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
         *keychain_, keychain_item, &form);
 
@@ skipping 33 matching lines @@
     // Use an invalid ref, to make sure errors are reported.
     SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(99);
     PasswordForm form;
     bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
         *keychain_, keychain_item, &form);
     EXPECT_FALSE(parsed);
   }
 }
 
 TEST_F(PasswordStoreMacTest, TestKeychainSearch) {
-  {  // An HTML form we've seen.
-    std::vector<SecKeychainItemRef> matching_items;
-    internal_keychain_helpers::FindMatchingKeychainItems(
-        *keychain_, std::string("http://some.domain.com/"),
-        PasswordForm::SCHEME_HTML, &matching_items);
-    EXPECT_EQ(static_cast<size_t>(2), matching_items.size());
-    FreeKeychainItems(*keychain_, &matching_items);
-  }
+  struct TestDataAndExpectation {
+    const PasswordFormData data;
+    const size_t expected_matches;
+  };
+  // Most fields are left blank because we don't care about them for searching.
+  TestDataAndExpectation test_data[] = {
+    // An HTML form we've seen.
+    { { PasswordForm::SCHEME_HTML, "http://some.domain.com/",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 2 },
+    // An HTML form we haven't seen
+    { { PasswordForm::SCHEME_HTML, "http://www.unseendomain.com/",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 0 },
+    // Basic auth that should match.
+    { { PasswordForm::SCHEME_BASIC, "http://some.domain.com:4567/low_security",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 1 },
+    // Basic auth with the wrong port.
+    { { PasswordForm::SCHEME_BASIC, "http://some.domain.com:1111/low_security",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 0 },
+    // Digest auth we've saved under https, visited with http.
+    { { PasswordForm::SCHEME_DIGEST, "http://some.domain.com/high_security",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 0 },
+    // Digest auth that should match.
+    { { PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, true, 0 }, 1 },
+    // Digest auth with the wrong domain.
+    { { PasswordForm::SCHEME_DIGEST, "https://some.domain.com/other_domain",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, true, 0 }, 0 },
+    // Garbage forms should have no matches.
+    { { PasswordForm::SCHEME_HTML, "foo/bar/baz",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 0 },
+  };
 
-  {  // An HTML form we haven't seen
-    std::vector<SecKeychainItemRef> matching_items;
-    internal_keychain_helpers::FindMatchingKeychainItems(
-        *keychain_, std::string("http://www.unseendomain.com/"),
-        PasswordForm::SCHEME_HTML, &matching_items);
-    EXPECT_EQ(static_cast<size_t>(0), matching_items.size());
-    FreeKeychainItems(*keychain_, &matching_items);
-  }
-
-  {  // Basic auth that should match.
-    std::vector<SecKeychainItemRef> matching_items;
-    internal_keychain_helpers::FindMatchingKeychainItems(
-        *keychain_, std::string("http://some.domain.com:4567/low_security"),
-        PasswordForm::SCHEME_BASIC, &matching_items);
-    EXPECT_EQ(static_cast<size_t>(1), matching_items.size());
-    FreeKeychainItems(*keychain_, &matching_items);
-  }
-
-  {  // Basic auth with the wrong port.
-    std::vector<SecKeychainItemRef> matching_items;
-    internal_keychain_helpers::FindMatchingKeychainItems(
-        *keychain_, std::string("http://some.domain.com:1111/low_security"),
-        PasswordForm::SCHEME_BASIC, &matching_items);
-    EXPECT_EQ(static_cast<size_t>(0), matching_items.size());
-    FreeKeychainItems(*keychain_, &matching_items);
-  }
-
-  {  // Digest auth we've saved under https, visited with http.
-    std::vector<SecKeychainItemRef> matching_items;
-    internal_keychain_helpers::FindMatchingKeychainItems(
-        *keychain_, std::string("http://some.domain.com/high_security"),
-        PasswordForm::SCHEME_DIGEST, &matching_items);
-    EXPECT_EQ(static_cast<size_t>(0), matching_items.size());
-    FreeKeychainItems(*keychain_, &matching_items);
-  }
-
-  {  // Digest auth that should match.
-    std::vector<SecKeychainItemRef> matching_items;
-    internal_keychain_helpers::FindMatchingKeychainItems(
-        *keychain_, std::string("https://some.domain.com/high_security"),
-        PasswordForm::SCHEME_DIGEST, &matching_items);
-    EXPECT_EQ(static_cast<size_t>(1), matching_items.size());
-    FreeKeychainItems(*keychain_, &matching_items);
+  MacKeychainPasswordFormAdapter keychainAdapter(keychain_);
+  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+    scoped_ptr<PasswordForm> query_form(
+        CreatePasswordFormFromData(test_data[i].data));
+    std::vector<PasswordForm*> matching_items =
+        keychainAdapter.PasswordsMatchingForm(*query_form);
+    EXPECT_EQ(test_data[i].expected_matches, matching_items.size());
+    STLDeleteElements(&matching_items);
   }
 }
 
 TEST_F(PasswordStoreMacTest, TestKeychainExactSearch) {
   // Test a web form entry (SCHEME_HTML).
   {
     PasswordForm search_form;
     search_form.signon_realm = std::string("http://some.domain.com/");
     search_form.origin = GURL("http://some.domain.com/insecure.html");
     search_form.action = GURL("http://some.domain.com/submit.cgi");
     search_form.username_element = std::wstring(L"username");
     search_form.username_value = std::wstring(L"joe_user");
     search_form.password_element = std::wstring(L"password");
     search_form.preferred = true;
     SecKeychainItemRef match;
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                search_form);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            search_form);
     EXPECT_EQ(reinterpret_cast<SecKeychainItemRef>(2), match);
     keychain_->Free(match);
 
     // Make sure that the matching isn't looser than it should be.
     PasswordForm wrong_username(search_form);
     wrong_username.username_value = std::wstring(L"wrong_user");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_username);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_username);
     EXPECT_EQ(NULL, match);
 
     PasswordForm wrong_path(search_form);
     wrong_path.origin = GURL("http://some.domain.com/elsewhere.html");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_path);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_path);
     EXPECT_EQ(NULL, match);
 
     PasswordForm wrong_scheme(search_form);
     wrong_scheme.scheme = PasswordForm::SCHEME_BASIC;
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_scheme);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_scheme);
     EXPECT_EQ(NULL, match);
 
     // With no path, we should match the pathless Keychain entry.
     PasswordForm no_path(search_form);
     no_path.origin = GURL("http://some.domain.com/");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                no_path);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            no_path);
     EXPECT_EQ(reinterpret_cast<SecKeychainItemRef>(1), match);
     keychain_->Free(match);
 
     // We don't store blacklist entries in the keychain, and we want to ignore
     // those stored by other browsers.
     PasswordForm blacklist(search_form);
     blacklist.blacklisted_by_user = true;
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                blacklist);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            blacklist);
     EXPECT_EQ(NULL, match);
   }
 
   // Test an http auth entry (SCHEME_BASIC, but SCHEME_DIGEST works is searched
   // the same way, so this gives sufficient coverage of both).
   {
     PasswordForm search_form;
     search_form.signon_realm =
         std::string("http://some.domain.com:4567/low_security");
     search_form.origin = GURL("http://some.domain.com:4567/insecure.html");
     search_form.username_value = std::wstring(L"basic_auth_user");
     search_form.scheme = PasswordForm::SCHEME_BASIC;
     SecKeychainItemRef match;
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                search_form);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            search_form);
     EXPECT_EQ(reinterpret_cast<SecKeychainItemRef>(7), match);
     keychain_->Free(match);
 
     // Make sure that the matching isn't looser than it should be.
     PasswordForm wrong_username(search_form);
     wrong_username.username_value = std::wstring(L"wrong_user");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_username);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_username);
     EXPECT_EQ(NULL, match);
 
     PasswordForm wrong_path(search_form);
     wrong_path.origin = GURL("http://some.domain.com:4567/elsewhere.html");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_path);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_path);
     EXPECT_EQ(NULL, match);
 
     PasswordForm wrong_scheme(search_form);
     wrong_scheme.scheme = PasswordForm::SCHEME_DIGEST;
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_scheme);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_scheme);
     EXPECT_EQ(NULL, match);
 
     PasswordForm wrong_port(search_form);
     wrong_port.signon_realm =
         std::string("http://some.domain.com:1234/low_security");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_port);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_port);
     EXPECT_EQ(NULL, match);
 
     PasswordForm wrong_realm(search_form);
     wrong_realm.signon_realm =
         std::string("http://some.domain.com:4567/incorrect");
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                wrong_realm);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            wrong_realm);
     EXPECT_EQ(NULL, match);
 
     // We don't store blacklist entries in the keychain, and we want to ignore
     // those stored by other browsers.
     PasswordForm blacklist(search_form);
     blacklist.blacklisted_by_user = true;
-    match = internal_keychain_helpers::FindMatchingKeychainItem(*keychain_,
-                                                                blacklist);
+    match = internal_keychain_helpers::MatchingKeychainItem(*keychain_,
+                                                            blacklist);
     EXPECT_EQ(NULL, match);
   }
 }
 
-TEST_F(PasswordStoreMacTest, TestKeychainModify) {
-  SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(1);
-  EXPECT_TRUE(internal_keychain_helpers::SetKeychainItemPassword(
-      *keychain_, keychain_item, std::string("allnewpassword")));
-  PasswordForm form;
-  internal_keychain_helpers::FillPasswordFormFromKeychainItem(*keychain_,
-                                                              keychain_item,
-                                                              &form);
-  EXPECT_EQ(L"allnewpassword", form.password_value);
-
-  // Check that invalid items fail to update
-  SecKeychainItemRef invalid_item = reinterpret_cast<SecKeychainItemRef>(1000);
-  EXPECT_FALSE(internal_keychain_helpers::SetKeychainItemPassword(
-      *keychain_, invalid_item, std::string("allnewpassword")));
-
-  // Check that other errors are reported (using the magic failure value).
-  EXPECT_FALSE(internal_keychain_helpers::SetKeychainItemPassword(
-      *keychain_, keychain_item, std::string("fail_me")));
-}
-
 TEST_F(PasswordStoreMacTest, TestKeychainAdd) {
   struct TestDataAndExpectation {
     PasswordFormData data;
     bool should_succeed;
   };
   TestDataAndExpectation test_data[] = {
     // Test a variety of scheme/port/protocol/path variations.
     { { PasswordForm::SCHEME_HTML, "http://web.site.com/",
         "http://web.site.com/path/to/page.html", NULL, NULL, NULL, NULL,
         L"anonymous", L"knock-knock", false, false, 0 }, true },
@@ skipping 10 matching lines @@
     { { 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.
     { { 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 keychainAdapter(keychain_);
+
   for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     PasswordForm* in_form = CreatePasswordFormFromData(test_data[i].data);
-    bool add_succeeded =
-        internal_keychain_helpers::AddKeychainEntryForForm(*keychain_,
-                                                           *in_form);
+    bool add_succeeded = keychainAdapter.AddLogin(*in_form);
     EXPECT_EQ(test_data[i].should_succeed, add_succeeded);
     if (add_succeeded) {
       SecKeychainItemRef matching_item;
-      matching_item = internal_keychain_helpers::FindMatchingKeychainItem(
+      matching_item = internal_keychain_helpers::MatchingKeychainItem(
           *keychain_, *in_form);
       EXPECT_TRUE(matching_item != NULL);
       PasswordForm out_form;
       internal_keychain_helpers::FillPasswordFormFromKeychainItem(
           *keychain_, matching_item, &out_form);
       EXPECT_EQ(out_form.scheme, in_form->scheme);
       EXPECT_EQ(out_form.signon_realm, in_form->signon_realm);
       EXPECT_EQ(out_form.origin, in_form->origin);
       EXPECT_EQ(out_form.username_value, in_form->username_value);
       EXPECT_EQ(out_form.password_value, in_form->password_value);
       keychain_->Free(matching_item);
     }
     delete in_form;
   }
 
   // Test that adding duplicate item updates the existing item.
   {
     PasswordFormData data = {
       PasswordForm::SCHEME_HTML, "http://some.domain.com",
       "http://some.domain.com/insecure.html", NULL,
       NULL, NULL, NULL, L"joe_user", L"updated_password", false, false, 0
     };
     PasswordForm* update_form = CreatePasswordFormFromData(data);
-    EXPECT_TRUE(internal_keychain_helpers::AddKeychainEntryForForm(
-        *keychain_, *update_form));
+    EXPECT_TRUE(keychainAdapter.AddLogin(*update_form));
     SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(2);
     PasswordForm stored_form;
     internal_keychain_helpers::FillPasswordFormFromKeychainItem(*keychain_,
                                                                 keychain_item,
                                                                 &stored_form);
     EXPECT_EQ(update_form->password_value, stored_form.password_value);
     delete update_form;
   }
 }
 
@@ skipping 211 matching lines @@
     internal_keychain_helpers::MergePasswordForms(&keychain_forms,
                                                   &database_forms,
                                                   &merged_forms);
 
     CHECK_FORMS(keychain_forms, test_data[KEYCHAIN_OUTPUT][test_case],
                 test_case);
     CHECK_FORMS(database_forms, test_data[DATABASE_OUTPUT][test_case],
                 test_case);
     CHECK_FORMS(merged_forms, test_data[MERGE_OUTPUT][test_case], test_case);
 
-    DeletePasswordForms(&keychain_forms);
-    DeletePasswordForms(&database_forms);
-    DeletePasswordForms(&merged_forms);
+    STLDeleteElements(&keychain_forms);
+    STLDeleteElements(&database_forms);
+    STLDeleteElements(&merged_forms);
   }
 }