[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);

[stuartmorgan, 2013/09/30 22:39:12]

You added a new param, but set it to true in every unit test call, which means
there's no clear unit test coverage of the new path you added.

[Raghu Simha, 2013/10/02 02:09:50]

I've added a new test for this called TestFillPasswordFormFromKeychainItem.

 
     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<MacKeychainPasswordFormAdapter::ItemFormPair> item_form_pairs =
+        internal_keychain_helpers::GetAllKeychainItemAttributesAsPasswordForms(
+            &keychain_items, *keychain_);
+    matching_items =
+        keychain_adapter.ExtractPasswordsMergeableWithForm(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 449 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);
   }
 }