PasswordStore: Clean up expectations about rewriting vectors of forms

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 "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
@@ skipping 473 matching lines @@
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     scoped_ptr<PasswordForm> query_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
 
     // Check matches treating the form as a fill target.
     ScopedVector<autofill::PasswordForm> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     EXPECT_EQ(test_data[i].expected_fill_matches, matching_items.size());
-    matching_items.clear();
 
     // Check matches treating the form as a merging target.
     EXPECT_EQ(test_data[i].expected_merge_matches > 0,
               keychain_adapter.HasPasswordsMergeableWithForm(*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 =
@@ skipping 735 matching lines @@
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     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;
     }
-    matching_items.clear();
 
-    login_db()->GetLogins(*query_form, &matching_items);
+    EXPECT_TRUE(login_db()->GetLogins(*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 42 matching lines @@
   // 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());
-  login_db()->GetLogins(*www_form, &matching_items);
+  EXPECT_TRUE(login_db()->GetLogins(*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());
-  login_db()->GetLogins(m_form, &matching_items);
+  EXPECT_TRUE(login_db()->GetLogins(m_form, &matching_items));
   EXPECT_EQ(0u, matching_items.size());
 }
 
 namespace {
 
 class PasswordsChangeObserver :
     public password_manager::PasswordStore::Observer {
 public:
   PasswordsChangeObserver(TestPasswordStoreMac* store) : observer_(this) {
     observer_.Add(store);
@@ skipping 147 matching lines @@
   // Add a password from the current profile.
   PasswordFormData www_form_data2 = {
       PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
       "http://www.facebook.com/index.html", "login", L"username", L"password",
       L"submit", L"not_joe_user", L"12345", true, false, 1 };
   www_form = CreatePasswordFormFromDataForTesting(www_form_data2);
   store_->AddLogin(*www_form);
   FinishAsyncProcessing();
 
   ScopedVector<PasswordForm> matching_items;
-  login_db()->GetLogins(*www_form, &matching_items);
+  EXPECT_TRUE(login_db()->GetLogins(*www_form, &matching_items));
   EXPECT_EQ(1u, matching_items.size());
-  matching_items.clear();
 
   store_->RemoveLoginsCreatedBetween(base::Time(), base::Time());
   FinishAsyncProcessing();
 
   // Check the second facebook form is gone.
-  login_db()->GetLogins(*www_form, &matching_items);
+  EXPECT_TRUE(login_db()->GetLogins(*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);
-  matching_items.clear();
 
   // Check the third-party password is still there.
   owned_keychain_adapter.SetFindsOnlyOwnedItems(false);
   matching_items = owned_keychain_adapter.PasswordsFillingForm(
       "http://some.domain.com/insecure.html", PasswordForm::SCHEME_HTML);
   ASSERT_EQ(1u, matching_items.size());
 }
 
 // Open the store and immediately write to it and try to read it back, without
 // first waiting for the initialization to finish. If tasks are processed in
@@ skipping 118 matching lines @@
       .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, PasswordStore::ALLOW_PROMPT, &consumer);
   base::MessageLoop::current()->Run();
   ScopedVector<autofill::PasswordForm> all_forms;
   EXPECT_TRUE(login_db()->GetAutofillableLogins(&all_forms));
   EXPECT_EQ(1u, all_forms.size());
-  all_forms.clear();
   ::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, PasswordStore::ALLOW_PROMPT, &consumer);
@@ skipping 27 matching lines @@
   query_form.password_value.clear();
   query_form.username_value.clear();
   EXPECT_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(SizeIs(1u)))
       .WillOnce(
           DoAll(SaveACopyOfFirstForm(&returned_form), QuitUIMessageLoop()));
   store()->GetLogins(query_form, PasswordStore::ALLOW_PROMPT, &mock_consumer);
   base::MessageLoop::current()->Run();
   ::testing::Mock::VerifyAndClearExpectations(&mock_consumer);
   EXPECT_EQ(form, returned_form);
 }