PasswordForm -> FormDigest for GetLogins

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 "chrome/browser/password_manager/password_store_mac.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 1333 matching lines @@
       // The query operations will also do some housekeeping: they will remove
       // dangling credentials in the LoginDatabase without a matching Keychain
       // item when one is expected. If the logic that stores the Keychain item
       // is incorrect, this will wipe the newly added form before the second
       // query.
       store()->GetAutofillableLogins(&mock_consumer);
       base::RunLoop().Run();
       ::testing::Mock::VerifyAndClearExpectations(&mock_consumer);
       EXPECT_EQ(form, returned_form);
 
-      PasswordForm query_form = form;
-      query_form.password_value.clear();
-      query_form.username_value.clear();
+      PasswordStore::FormDigest query_form(form);
       EXPECT_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(SizeIs(1u)))
           .WillOnce(
               DoAll(SaveACopyOfFirstForm(&returned_form), QuitUIMessageLoop()));
       store()->GetLogins(query_form, &mock_consumer);
       base::RunLoop().Run();
       ::testing::Mock::VerifyAndClearExpectations(&mock_consumer);
       EXPECT_EQ(form, returned_form);
 
       store()->RemoveLogin(form);
     }
@@ skipping 131 matching lines @@
     if (updates[i].password) {
       EXPECT_GT(matching_items.size(), 0U) << "iteration " << i;
       if (matching_items.size() >= 1)
         EXPECT_EQ(ASCIIToUTF16(updates[i].password),
                   matching_items[0]->password_value)
             << "iteration " << i;
     } else {
       EXPECT_EQ(0U, matching_items.size()) << "iteration " << i;
     }
 
-    EXPECT_TRUE(login_db()->GetLogins(*query_form, &matching_items));
+    EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(*query_form),
+                                      &matching_items));
     EXPECT_EQ(updates[i].password ? 1U : 0U, matching_items.size())
         << "iteration " << i;
   }
 }
 
 TEST_F(PasswordStoreMacTest, TestDBKeychainAssociation) {
   // Tests that association between the keychain and login database parts of a
   // password added by fuzzy (PSL) matching works.
   // 1. Add a password for www.facebook.com
   // 2. Get a password for m.facebook.com. This fuzzy matches and returns the
@@ skipping 26 matching lines @@
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   owned_keychain_adapter.AddPassword(*www_form);
 
   // 2. Get a password for m.facebook.com.
   PasswordForm m_form(*www_form);
   m_form.signon_realm = "http://m.facebook.com";
   m_form.origin = GURL("http://m.facebook.com/index.html");
 
   MockPasswordStoreConsumer consumer;
-  store_->GetLogins(m_form, &consumer);
+  store_->GetLogins(PasswordStore::FormDigest(m_form), &consumer);
   PasswordForm returned_form;
   EXPECT_CALL(consumer, OnGetPasswordStoreResultsConstRef(SizeIs(1u)))
       .WillOnce(
           DoAll(SaveACopyOfFirstForm(&returned_form), QuitUIMessageLoop()));
   base::RunLoop().Run();
 
   // 3. Add the returned password for m.facebook.com.
   returned_form.signon_realm = "http://m.facebook.com";
   returned_form.origin = GURL("http://m.facebook.com/index.html");
   EXPECT_EQ(AddChangeForForm(returned_form),
             login_db()->AddLogin(returned_form));
   owned_keychain_adapter.AddPassword(m_form);
 
   // 4. Remove both passwords.
   store_->RemoveLogin(*www_form);
   store_->RemoveLogin(m_form);
   FinishAsyncProcessing();
 
   // No trace of www.facebook.com.
   ScopedVector<autofill::PasswordForm> matching_items =
       owned_keychain_adapter.PasswordsFillingForm(www_form->signon_realm,
                                                   www_form->scheme);
   EXPECT_EQ(0u, matching_items.size());
-  EXPECT_TRUE(login_db()->GetLogins(*www_form, &matching_items));
+  EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(*www_form),
+                                    &matching_items));
   EXPECT_EQ(0u, matching_items.size());
   // No trace of m.facebook.com.
   matching_items = owned_keychain_adapter.PasswordsFillingForm(
       m_form.signon_realm, m_form.scheme);
   EXPECT_EQ(0u, matching_items.size());
-  EXPECT_TRUE(login_db()->GetLogins(m_form, &matching_items));
+  EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(m_form),
+                                    &matching_items));
   EXPECT_EQ(0u, matching_items.size());
 }
 
 namespace {
 
 class PasswordsChangeObserver
     : public password_manager::PasswordStore::Observer {
  public:
   explicit PasswordsChangeObserver(PasswordStoreMac* store) : observer_(this) {
     observer_.Add(store);
@@ skipping 253 matching lines @@
                                      L"submit",
                                      L"not_joe_user",
                                      L"12345",
                                      true,
                                      1};
   www_form = CreatePasswordFormFromDataForTesting(www_form_data2);
   store_->AddLogin(*www_form);
   FinishAsyncProcessing();
 
   ScopedVector<PasswordForm> matching_items;
-  EXPECT_TRUE(login_db()->GetLogins(*www_form, &matching_items));
+  EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(*www_form),
+                                    &matching_items));
   EXPECT_EQ(1u, matching_items.size());
 
   store_->RemoveLoginsCreatedBetween(base::Time(), base::Time(),
                                      base::Closure());
   FinishAsyncProcessing();
 
   // Check the second facebook form is gone.
-  EXPECT_TRUE(login_db()->GetLogins(*www_form, &matching_items));
+  EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(*www_form),
+                                    &matching_items));
   EXPECT_EQ(0u, matching_items.size());
 
   // Check the first facebook form is still there.
   matching_items = owned_keychain_adapter.PasswordsFillingForm(
       www_form->signon_realm, www_form->scheme);
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(ASCIIToUTF16("joe_user"), matching_items[0]->username_value);
 
   // Check the third-party password is still there.
   owned_keychain_adapter.SetFindsOnlyOwnedItems(false);
@@ skipping 32 matching lines @@
   m_form.signon_realm = "http://m.facebook.com";
   m_form.origin = GURL("http://m.facebook.com/index.html");
 
   MockPasswordStoreConsumer consumer;
   ON_CALL(consumer, OnGetPasswordStoreResultsConstRef(_))
       .WillByDefault(QuitUIMessageLoop());
   EXPECT_CALL(mock_observer, OnLoginsChanged(_)).Times(0);
   // The PSL-matched form isn't returned because there is no actual password in
   // the keychain.
   EXPECT_CALL(consumer, OnGetPasswordStoreResultsConstRef(IsEmpty()));
-  store_->GetLogins(m_form, &consumer);
+  store_->GetLogins(PasswordStore::FormDigest(m_form), &consumer);
   base::RunLoop().Run();
   ScopedVector<autofill::PasswordForm> all_forms;
   EXPECT_TRUE(login_db()->GetAutofillableLogins(&all_forms));
   EXPECT_EQ(1u, all_forms.size());
   ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
 
   // 3. Get a password for www.facebook.com. The form is implicitly removed and
   // the observer is notified.
   password_manager::PasswordStoreChangeList list;
   list.push_back(password_manager::PasswordStoreChange(
       password_manager::PasswordStoreChange::REMOVE, *www_form));
   EXPECT_CALL(mock_observer, OnLoginsChanged(list));
   EXPECT_CALL(consumer, OnGetPasswordStoreResultsConstRef(IsEmpty()));
-  store_->GetLogins(*www_form, &consumer);
+  store_->GetLogins(PasswordStore::FormDigest(*www_form), &consumer);
   base::RunLoop().Run();
   EXPECT_TRUE(login_db()->GetAutofillableLogins(&all_forms));
   EXPECT_EQ(0u, all_forms.size());
 }
 
 // Verify that Android app passwords can be stored, retrieved, and deleted.
 // Regression test for http://crbug.com/455551
 TEST_F(PasswordStoreMacTest, StoringAndRetrievingAndroidCredentials) {
   PasswordForm form;
   form.signon_realm = "android://7x7IDboo8u9YKraUsbmVkuf1@net.rateflix.app/";
@@ skipping 46 matching lines @@
   FinishAsyncProcessing();
 
   ASSERT_TRUE(base::PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&PasswordStoreMac::ImportFromKeychain, store()),
       base::Bind(&CheckMigrationResult, PasswordStoreMac::MIGRATION_OK)));
   FinishAsyncProcessing();
 
   // The password should be stored in the database by now.
   ScopedVector<PasswordForm> matching_items;
-  EXPECT_TRUE(login_db()->GetLogins(form1, &matching_items));
+  EXPECT_TRUE(
+      login_db()->GetLogins(PasswordStore::FormDigest(form1), &matching_items));
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(form1, *matching_items[0]);
 
-  EXPECT_TRUE(login_db()->GetLogins(form2, &matching_items));
+  EXPECT_TRUE(
+      login_db()->GetLogins(PasswordStore::FormDigest(form2), &matching_items));
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(form2, *matching_items[0]);
 
-  EXPECT_TRUE(login_db()->GetLogins(blacklisted_form, &matching_items));
+  EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(blacklisted_form),
+                                    &matching_items));
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(blacklisted_form, *matching_items[0]);
 
   // The passwords are encrypted using a key from the Keychain.
   EXPECT_TRUE(
       histogram_tester_->GetHistogramSamplesSinceCreation("OSX.Keychain.Access")
           ->TotalCount());
   histogram_tester_.reset();
 }
 
 // Import a federated credential while the Keychain is locked.
 TEST_F(PasswordStoreMacTest, ImportFederatedFromLockedKeychain) {
   keychain()->set_locked(true);
   PasswordForm form1;
   form1.origin = GURL("http://example.com/Login");
   form1.signon_realm = "http://example.com/";
   form1.username_value = ASCIIToUTF16("my_username");
   form1.federation_origin = url::Origin(GURL("https://accounts.google.com/"));
 
   store()->AddLogin(form1);
   FinishAsyncProcessing();
   ASSERT_TRUE(base::PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&PasswordStoreMac::ImportFromKeychain, store()),
       base::Bind(&CheckMigrationResult, PasswordStoreMac::MIGRATION_OK)));
   FinishAsyncProcessing();
 
   ScopedVector<PasswordForm> matching_items;
-  EXPECT_TRUE(login_db()->GetLogins(form1, &matching_items));
+  EXPECT_TRUE(
+      login_db()->GetLogins(PasswordStore::FormDigest(form1), &matching_items));
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(form1, *matching_items[0]);
 }
 
 // Try to import while the Keychain is locked but the encryption key had been
 // read earlier.
 TEST_F(PasswordStoreMacTest, ImportFromLockedKeychainError) {
   PasswordForm form1;
   form1.origin = GURL("http://accounts.google.com/LoginAuth");
   form1.signon_realm = "http://accounts.google.com/";
@@ skipping 10 matching lines @@
   EXPECT_TRUE(adapter.AddPassword(form2));
 
   keychain()->set_locked(true);
   ASSERT_TRUE(base::PostTaskAndReplyWithResult(
       thread_->task_runner().get(), FROM_HERE,
       base::Bind(&PasswordStoreMac::ImportFromKeychain, store()),
       base::Bind(&CheckMigrationResult, PasswordStoreMac::KEYCHAIN_BLOCKED)));
   FinishAsyncProcessing();
 
   ScopedVector<PasswordForm> matching_items;
-  EXPECT_TRUE(login_db()->GetLogins(form1, &matching_items));
+  EXPECT_TRUE(
+      login_db()->GetLogins(PasswordStore::FormDigest(form1), &matching_items));
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(base::string16(), matching_items[0]->password_value);
 
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumPasswordsOnFailure", 1, 1);
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumFailedPasswords", 1, 1);
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumChromeOwnedInaccessiblePasswords",
       2, 1);
   // Don't test the encryption key access.
   histogram_tester_.reset();
 }