[sync] Significantly speed up password model association on mac

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/files/scoped_temp_dir.h"
 #include "base/path_service.h"
@@ skipping 262 matching lines @@
       "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 MockAppleKeychain docs.
     SecKeychainItemRef keychain_item =
         reinterpret_cast<SecKeychainItemRef>(i + 1);
     PasswordForm form;
     bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
-        *keychain_, keychain_item, &form);
+        *keychain_, keychain_item, &form, true);
 
     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;
     EXPECT_EQ(expected[i].ssl_valid, form.ssl_valid) << "In iteration " << i;
     EXPECT_EQ(std::string(expected[i].signon_realm), form.signon_realm)
         << "In iteration " << i;
     if (expected[i].username) {
       EXPECT_EQ(WideToUTF16(expected[i].username), form.username_value)
@@ skipping 18 matching lines @@
         << "In iteration " << i;
     EXPECT_EQ(expected[i].creation_second, exploded_time.second)
         << "In iteration " << i;
   }
 
   {
     // 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);
+        *keychain_, keychain_item, &form, true);
     EXPECT_FALSE(parsed);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainSearch) {
   struct TestDataAndExpectation {
     const PasswordFormData data;
     const size_t expected_fill_matches;
     const size_t expected_merge_matches;
   };
@@ skipping 48 matching lines @@
 
     // Check matches treating the form as a fill target.
     std::vector<PasswordForm*> matching_items =
         keychain_adapter.PasswordsFillingForm(*query_form);
     EXPECT_EQ(test_data[i].expected_fill_matches, matching_items.size());
     STLDeleteElements(&matching_items);
 
     // Check matches treating the form as a merging target.
     EXPECT_EQ(test_data[i].expected_merge_matches > 0,
               keychain_adapter.HasPasswordsMergeableWithForm(*query_form));
-    matching_items = keychain_adapter.PasswordsMergeableWithForm(*query_form);
+    std::vector<SecKeychainItemRef> keychain_items;
+    std::vector<internal_keychain_helpers::ItemFormPair> item_form_pairs =
+        internal_keychain_helpers::
+            ExtractAllKeychainItemAttributesIntoPasswordForms(&keychain_items,
+                                                              *keychain_);
+    matching_items =
+        internal_keychain_helpers::ExtractPasswordsMergeableWithForm(
+            *keychain_, item_form_pairs, *query_form);
     EXPECT_EQ(test_data[i].expected_merge_matches, matching_items.size());
+    STLDeleteContainerPairSecondPointers(item_form_pairs.begin(),
+                                         item_form_pairs.end());
+    for (std::vector<SecKeychainItemRef>::iterator i = keychain_items.begin();
+         i != keychain_items.end(); ++i) {
+      keychain_->Free(*i);
+    }
     STLDeleteElements(&matching_items);
 
     // None of the pre-seeded items are owned by us, so none should match an
     // owned-passwords-only search.
     matching_items = owned_keychain_adapter.PasswordsFillingForm(*query_form);
     EXPECT_EQ(0U, matching_items.size());
     STLDeleteElements(&matching_items);
   }
 }
 
@@ skipping 148 matching lines @@
       "http://some.domain.com/insecure.html", NULL,
       NULL, NULL, NULL, L"joe_user", L"updated_password", false, false, 0
     };
     scoped_ptr<PasswordForm> update_form(CreatePasswordFormFromData(data));
     MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
     EXPECT_TRUE(keychain_adapter.AddPassword(*update_form));
     SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(2);
     PasswordForm stored_form;
     internal_keychain_helpers::FillPasswordFormFromKeychainItem(*keychain_,
                                                                 keychain_item,
-                                                                &stored_form);
+                                                                &stored_form,
+                                                                true);
     EXPECT_EQ(update_form->password_value, stored_form.password_value);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainRemove) {
   struct TestDataAndExpectation {
     PasswordFormData data;
     bool should_succeed;
   };
   TestDataAndExpectation test_data[] = {
@@ skipping 283 matching lines @@
   EXPECT_EQ(2U, database_forms.size());
   ASSERT_EQ(3U, merged_forms.size());
   EXPECT_EQ(ASCIIToUTF16("sekrit"), merged_forms[0]->password_value);
   EXPECT_EQ(ASCIIToUTF16("sekrit"), merged_forms[1]->password_value);
   EXPECT_TRUE(merged_forms[2]->blacklisted_by_user);
 
   STLDeleteElements(&database_forms);
   STLDeleteElements(&merged_forms);
 }
 
+TEST_F(PasswordStoreMacInternalsTest, TestBlacklistedFiltering) {
+  PasswordFormData db_data[] = {
+    { PasswordForm::SCHEME_HTML, "http://dont.remember.com/",
+      "http://dont.remember.com/",
+      "http://dont.remember.com/handlepage.cgi",
+      L"submit", L"username", L"password", L"joe_user", L"non_empty_password",
+      true, false, 1240000000 },
+    { PasswordForm::SCHEME_HTML, "https://dont.remember.com/",
+      "https://dont.remember.com/",
+      "https://dont.remember.com/handlepage_secure.cgi",
+      L"submit", L"username", L"password", L"joe_user", L"non_empty_password",
+      true, false, 1240000000 },
+  };
+  std::vector<PasswordForm*> database_forms;
+  for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(db_data); ++i) {
+    database_forms.push_back(CreatePasswordFormFromData(db_data[i]));
+  }
+  std::vector<PasswordForm*> merged_forms =
+      internal_keychain_helpers::GetPasswordsForForms(*keychain_,
+                                                      &database_forms);
+  EXPECT_EQ(2U, database_forms.size());
+  ASSERT_EQ(0U, merged_forms.size());
+
+  STLDeleteElements(&database_forms);
+  STLDeleteElements(&merged_forms);
+}
+
+TEST_F(PasswordStoreMacInternalsTest, TestFillPasswordFormFromKeychainItem) {
+  // When |extract_password_data| is false, the password field must be empty,
+  // and |blacklisted_by_user| must be false.
+  SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(1);
+  PasswordForm form_without_extracted_password;
+  bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
+      *keychain_,
+      keychain_item,
+      &form_without_extracted_password,
+      false);  // Do not extract password.
+  EXPECT_TRUE(parsed);
+  ASSERT_TRUE(form_without_extracted_password.password_value.empty());
+  ASSERT_FALSE(form_without_extracted_password.blacklisted_by_user);
+
+  // When |extract_password_data| is true and the keychain entry has a non-empty
+  // password, the password field must be non-empty, and the value of
+  // |blacklisted_by_user| must be false.
+  keychain_item = reinterpret_cast<SecKeychainItemRef>(1);
+  PasswordForm form_with_extracted_password;
+  parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
+      *keychain_,
+      keychain_item,
+      &form_with_extracted_password,
+      true);  // Extract password.
+  EXPECT_TRUE(parsed);
+  ASSERT_EQ(ASCIIToUTF16("sekrit"),
+            form_with_extracted_password.password_value);
+  ASSERT_FALSE(form_with_extracted_password.blacklisted_by_user);
+
+  // When |extract_password_data| is true and the keychain entry has an empty
+  // username and password (""), the password field must be empty, and the value
+  // of |blacklisted_by_user| must be true.
+  keychain_item = reinterpret_cast<SecKeychainItemRef>(4);
+  PasswordForm negative_form;
+  parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
+      *keychain_,
+      keychain_item,
+      &negative_form,
+      true);  // Extract password.
+  EXPECT_TRUE(parsed);
+  ASSERT_TRUE(negative_form.username_value.empty());
+  ASSERT_TRUE(negative_form.password_value.empty());
+  ASSERT_TRUE(negative_form.blacklisted_by_user);
+
+  // When |extract_password_data| is true and the keychain entry has an empty
+  // password (""), the password field must be empty (""), and the value of
+  // |blacklisted_by_user| must be true.
+  keychain_item = reinterpret_cast<SecKeychainItemRef>(5);
+  PasswordForm form_with_empty_password_a;
+  parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
+      *keychain_,
+      keychain_item,
+      &form_with_empty_password_a,
+      true);  // Extract password.
+  EXPECT_TRUE(parsed);
+  ASSERT_TRUE(form_with_empty_password_a.password_value.empty());
+  ASSERT_TRUE(form_with_empty_password_a.blacklisted_by_user);
+
+  // When |extract_password_data| is true and the keychain entry has a single
+  // space password (" "), the password field must be a single space (" "), and
+  // the value of |blacklisted_by_user| must be true.
+  keychain_item = reinterpret_cast<SecKeychainItemRef>(6);
+  PasswordForm form_with_empty_password_b;
+  parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
+      *keychain_,
+      keychain_item,
+      &form_with_empty_password_b,
+      true);  // Extract password.
+  EXPECT_TRUE(parsed);
+  ASSERT_EQ(ASCIIToUTF16(" "),
+            form_with_empty_password_b.password_value);
+  ASSERT_TRUE(form_with_empty_password_b.blacklisted_by_user);
+}
+
 TEST_F(PasswordStoreMacInternalsTest, TestPasswordGetAll) {
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   // Add a few passwords of various types so that we own some.
   PasswordFormData owned_password_data[] = {
     { 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 },
@@ skipping 146 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);
   }
 }