Remove ScopedVector from PasswordStoreMac

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 98 matching lines @@
 
 // Macro to simplify calling CheckFormsAgainstExpectations with a useful label.
 #define CHECK_FORMS(forms, expectations, i) \
   CheckFormsAgainstExpectations(forms, expectations, #forms, i)
 
 // Ensures that the data in |forms| match |expectations|, causing test failures
 // for any discrepencies.
 // TODO(stuartmorgan): This is current order-dependent; ideally it shouldn't
 // matter if |forms| and |expectations| are scrambled.
 void CheckFormsAgainstExpectations(
-    const std::vector<PasswordForm*>& forms,
+    const std::vector<std::unique_ptr<PasswordForm>>& forms,
     const std::vector<PasswordFormData*>& expectations,
 
     const char* forms_label,
     unsigned int test_number) {
   EXPECT_EQ(expectations.size(), forms.size()) << forms_label << " in test "
                                                << test_number;
   if (expectations.size() != forms.size())
     return;
 
   for (unsigned int i = 0; i < expectations.size(); ++i) {
     SCOPED_TRACE(testing::Message() << forms_label << " in test " << test_number
                                     << ", item " << i);
-    PasswordForm* form = forms[i];
+    PasswordForm* form = forms[i].get();
     PasswordFormData* expectation = expectations[i];
     EXPECT_EQ(expectation->scheme, form->scheme);
     EXPECT_EQ(std::string(expectation->signon_realm), form->signon_realm);
     EXPECT_EQ(GURL(expectation->origin), form->origin);
     EXPECT_EQ(GURL(expectation->action), form->action);
     EXPECT_EQ(WideToUTF16(expectation->submit_element), form->submit_element);
     EXPECT_EQ(WideToUTF16(expectation->username_element),
               form->username_element);
     EXPECT_EQ(WideToUTF16(expectation->password_element),
               form->password_element);
@@ skipping 347 matching lines @@
   };
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     std::unique_ptr<PasswordForm> query_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
 
     // Check matches treating the form as a fill target.
-    ScopedVector<autofill::PasswordForm> matching_items =
+    std::vector<std::unique_ptr<PasswordForm>> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     EXPECT_EQ(test_data[i].expected_fill_matches, matching_items.size());
 
     // 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::
@@ skipping 59 matching lines @@
 
   for (unsigned int i = 0; i < arraysize(base_form_data); ++i) {
     // Create a base form and make sure we find a match.
     std::unique_ptr<PasswordForm> base_form =
         CreatePasswordFormFromDataForTesting(base_form_data[i]);
     EXPECT_TRUE(keychain_adapter.HasPasswordsMergeableWithForm(*base_form));
     EXPECT_TRUE(keychain_adapter.HasPasswordExactlyMatchingForm(*base_form));
 
     // Make sure that the matching isn't looser than it should be by checking
     // that slightly altered forms don't match.
-    ScopedVector<autofill::PasswordForm> modified_forms;
+    std::vector<std::unique_ptr<PasswordForm>> modified_forms;
 
-    modified_forms.push_back(new PasswordForm(*base_form));
+    modified_forms.push_back(base::MakeUnique<PasswordForm>(*base_form));
     modified_forms.back()->username_value = ASCIIToUTF16("wrong_user");
 
-    modified_forms.push_back(new PasswordForm(*base_form));
-    SetPasswordFormPath(modified_forms.back(), "elsewhere.html");
+    modified_forms.push_back(base::MakeUnique<PasswordForm>(*base_form));
+    SetPasswordFormPath(modified_forms.back().get(), "elsewhere.html");
 
-    modified_forms.push_back(new PasswordForm(*base_form));
+    modified_forms.push_back(base::MakeUnique<PasswordForm>(*base_form));
     modified_forms.back()->scheme = PasswordForm::SCHEME_OTHER;
 
-    modified_forms.push_back(new PasswordForm(*base_form));
-    SetPasswordFormPort(modified_forms.back(), "1234");
+    modified_forms.push_back(base::MakeUnique<PasswordForm>(*base_form));
+    SetPasswordFormPort(modified_forms.back().get(), "1234");
 
-    modified_forms.push_back(new PasswordForm(*base_form));
+    modified_forms.push_back(base::MakeUnique<PasswordForm>(*base_form));
     modified_forms.back()->blacklisted_by_user = true;
 
     if (base_form->scheme == PasswordForm::SCHEME_BASIC ||
         base_form->scheme == PasswordForm::SCHEME_DIGEST) {
-      modified_forms.push_back(new PasswordForm(*base_form));
-      SetPasswordFormRealm(modified_forms.back(), "incorrect");
+      modified_forms.push_back(base::MakeUnique<PasswordForm>(*base_form));
+      SetPasswordFormRealm(modified_forms.back().get(), "incorrect");
     }
 
     for (unsigned int j = 0; j < modified_forms.size(); ++j) {
       bool match =
           keychain_adapter.HasPasswordExactlyMatchingForm(*modified_forms[j]);
       EXPECT_FALSE(match) << "In modified version " << j << " of base form "
                           << i;
     }
   }
 }
@@ skipping 452 matching lines @@
   // credentials are not tried to be matched with a Keychain item.
   ++current_test;
   CHECK(current_test < kTestCount);
   test_data[KEYCHAIN_INPUT][current_test].push_back(&keychain_android);
   test_data[DATABASE_INPUT][current_test].push_back(&db_federated);
   test_data[DATABASE_INPUT][current_test].push_back(&db_android);
   test_data[MERGE_OUTPUT][current_test].push_back(&db_federated);
   test_data[MERGE_OUTPUT][current_test].push_back(&merged_android);
 
   for (unsigned int test_case = 0; test_case <= current_test; ++test_case) {
-    ScopedVector<autofill::PasswordForm> keychain_forms;
+    std::vector<std::unique_ptr<PasswordForm>> keychain_forms;
     for (std::vector<PasswordFormData*>::iterator i =
              test_data[KEYCHAIN_INPUT][test_case].begin();
          i != test_data[KEYCHAIN_INPUT][test_case].end(); ++i) {
-      keychain_forms.push_back(
-          CreatePasswordFormFromDataForTesting(*(*i)).release());
+      keychain_forms.push_back(CreatePasswordFormFromDataForTesting(*(*i)));
     }
-    ScopedVector<autofill::PasswordForm> database_forms;
+    std::vector<std::unique_ptr<PasswordForm>> database_forms;
     for (std::vector<PasswordFormData*>::iterator i =
              test_data[DATABASE_INPUT][test_case].begin();
          i != test_data[DATABASE_INPUT][test_case].end(); ++i) {
-      database_forms.push_back(
-          CreatePasswordFormFromDataForTesting(*(*i)).release());
+      database_forms.push_back(CreatePasswordFormFromDataForTesting(*(*i)));
     }
 
-    ScopedVector<autofill::PasswordForm> merged_forms;
+    std::vector<std::unique_ptr<PasswordForm>> merged_forms;
     internal_keychain_helpers::MergePasswordForms(
         &keychain_forms, &database_forms, &merged_forms);
 
-    CHECK_FORMS(keychain_forms.get(), test_data[KEYCHAIN_OUTPUT][test_case],
+    CHECK_FORMS(keychain_forms, test_data[KEYCHAIN_OUTPUT][test_case],
                 test_case);
-    CHECK_FORMS(database_forms.get(), test_data[DATABASE_OUTPUT][test_case],
+    CHECK_FORMS(database_forms, test_data[DATABASE_OUTPUT][test_case],
                 test_case);
-    CHECK_FORMS(merged_forms.get(), test_data[MERGE_OUTPUT][test_case],
-                test_case);
+    CHECK_FORMS(merged_forms, test_data[MERGE_OUTPUT][test_case], test_case);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestPasswordBulkLookup) {
   PasswordFormData db_data[] = {
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/", "http://some.domain.com/action.cgi",
        L"submit", L"username", L"password", L"joe_user", L"", true, 1212121212},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/page.html",
        "http://some.domain.com/handlepage.cgi", L"submit", L"username",
        L"password", L"joe_user", L"", true, 1234567890},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/page.html",
        "http://some.domain.com/handlepage.cgi", L"submit", L"username",
        L"password", L"second-account", L"", true, 1240000000},
       {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"", true, 1240000000},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/path.html", "http://some.domain.com/action.cgi",
        L"submit", L"username", L"password", NULL, NULL, true, 1212121212},
   };
-  ScopedVector<autofill::PasswordForm> database_forms;
-  for (unsigned int i = 0; i < arraysize(db_data); ++i) {
-    database_forms.push_back(
-        CreatePasswordFormFromDataForTesting(db_data[i]).release());
+  std::vector<std::unique_ptr<PasswordForm>> database_forms;
+  for (const PasswordFormData& form_data : db_data) {
+    database_forms.push_back(CreatePasswordFormFromDataForTesting(form_data));
   }
-  ScopedVector<autofill::PasswordForm> merged_forms;
+  std::vector<std::unique_ptr<PasswordForm>> merged_forms;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &merged_forms);
   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);
 }
 
 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, 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,
        1240000000},
   };
-  ScopedVector<autofill::PasswordForm> database_forms;
-  for (unsigned int i = 0; i < arraysize(db_data); ++i) {
-    database_forms.push_back(
-        CreatePasswordFormFromDataForTesting(db_data[i]).release());
+  std::vector<std::unique_ptr<PasswordForm>> database_forms;
+  for (const PasswordFormData& form_data : db_data) {
+    database_forms.push_back(CreatePasswordFormFromDataForTesting(form_data));
   }
-  ScopedVector<autofill::PasswordForm> merged_forms;
+  std::vector<std::unique_ptr<PasswordForm>> merged_forms;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &merged_forms);
   EXPECT_EQ(2U, database_forms.size());
   ASSERT_EQ(0U, merged_forms.size());
 }
 
 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);
@@ skipping 72 matching lines @@
       {PasswordForm::SCHEME_DIGEST, "https://digest.site.com/differentrealm",
        "https://digest.site.com/secure.html", NULL, NULL, NULL, NULL,
        L"testname", L"testpass", false, 0},
   };
   for (unsigned int i = 0; i < arraysize(owned_password_data); ++i) {
     std::unique_ptr<PasswordForm> form =
         CreatePasswordFormFromDataForTesting(owned_password_data[i]);
     owned_keychain_adapter.AddPassword(*form);
   }
 
-  ScopedVector<autofill::PasswordForm> all_passwords =
+  std::vector<std::unique_ptr<PasswordForm>> all_passwords =
       keychain_adapter.GetAllPasswordFormPasswords();
   EXPECT_EQ(9 + arraysize(owned_password_data), all_passwords.size());
 
-  ScopedVector<autofill::PasswordForm> owned_passwords =
+  std::vector<std::unique_ptr<PasswordForm>> owned_passwords =
       owned_keychain_adapter.GetAllPasswordFormPasswords();
   EXPECT_EQ(arraysize(owned_password_data), owned_passwords.size());
 }
 
 #pragma mark -
 
 class PasswordStoreMacTest : public testing::Test {
  public:
   PasswordStoreMacTest() : ui_thread_(BrowserThread::UI, &message_loop_) {}
 
@@ skipping 223 matching lines @@
   }
 
   FinishAsyncProcessing();
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain());
   for (unsigned int i = 0; i < arraysize(updates); ++i) {
     SCOPED_TRACE(testing::Message("iteration ") << i);
     std::unique_ptr<PasswordForm> query_form =
         CreatePasswordFormFromDataForTesting(updates[i].form_data);
 
-    ScopedVector<autofill::PasswordForm> matching_items =
+    std::vector<std::unique_ptr<PasswordForm>> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     if (updates[i].password) {
       EXPECT_GT(matching_items.size(), 0U);
       if (matching_items.size() >= 1)
         EXPECT_EQ(ASCIIToUTF16(updates[i].password),
                   matching_items[0]->password_value);
     } else {
       EXPECT_EQ(0U, matching_items.size());
     }
@@ skipping 59 matching lines @@
   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 =
+  std::vector<std::unique_ptr<PasswordForm>> matching_items =
       owned_keychain_adapter.PasswordsFillingForm(www_form->signon_realm,
                                                   www_form->scheme);
   EXPECT_EQ(0u, matching_items.size());
 
   std::vector<std::unique_ptr<PasswordForm>> matching_db_items;
   EXPECT_TRUE(login_db()->GetLogins(PasswordStore::FormDigest(*www_form),
                                     &matching_db_items));
   EXPECT_EQ(0u, matching_db_items.size());
 
   // No trace of m.facebook.com.
@@ skipping 98 matching lines @@
   test->store()->AddLogin(*form_facebook);
   test->store()->AddLogin(*form_other);
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_facebook_old)));
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_facebook)));
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_other)));
   observer.WaitAndVerify(test);
 
   // Check the keychain content.
   MacKeychainPasswordFormAdapter owned_keychain_adapter(test->keychain());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(false);
-  ScopedVector<PasswordForm> matching_items(
+  std::vector<std::unique_ptr<PasswordForm>> matching_items(
       owned_keychain_adapter.PasswordsFillingForm(form_facebook->signon_realm,
                                                   form_facebook->scheme));
   EXPECT_EQ(1u, matching_items.size());
   matching_items = owned_keychain_adapter.PasswordsFillingForm(
       form_other->signon_realm, form_other->scheme);
   EXPECT_EQ(1u, matching_items.size());
 
   // Remove facebook.
   if (check_created) {
     test->store()->RemoveLoginsCreatedBetween(base::Time(), next_day,
@@ skipping 80 matching lines @@
   form_google->skip_zero_click = false;
 
   // Add the zero-clickable forms to the database.
   PasswordsChangeObserver observer(store());
   store()->AddLogin(*form_facebook);
   store()->AddLogin(*form_google);
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_facebook)));
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_google)));
   observer.WaitAndVerify(this);
 
-  ScopedVector<autofill::PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   EXPECT_TRUE(login_db()->GetAutoSignInLogins(&forms));
   EXPECT_EQ(2u, forms.size());
   EXPECT_FALSE(forms[0]->skip_zero_click);
   EXPECT_FALSE(forms[1]->skip_zero_click);
 
   store()->DisableAutoSignInForOrigins(
       base::Bind(static_cast<bool (*)(const GURL&, const GURL&)>(operator==),
                  form_google->origin),
       base::Closure());
   FinishAsyncProcessing();
@@ skipping 64 matching lines @@
   store_->RemoveLoginsCreatedBetween(base::Time(), base::Time(),
                                      base::Closure());
   FinishAsyncProcessing();
 
   // Check the second facebook form is gone.
   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.
-  ScopedVector<PasswordForm> matching_keychain_items;
+  std::vector<std::unique_ptr<PasswordForm>> matching_keychain_items;
   matching_keychain_items = owned_keychain_adapter.PasswordsFillingForm(
       www_form->signon_realm, www_form->scheme);
   ASSERT_EQ(1u, matching_keychain_items.size());
   EXPECT_EQ(ASCIIToUTF16("joe_user"),
             matching_keychain_items[0]->username_value);
 
   // Check the third-party password is still there.
   owned_keychain_adapter.SetFindsOnlyOwnedItems(false);
   matching_keychain_items = owned_keychain_adapter.PasswordsFillingForm(
       "http://some.domain.com/insecure.html", PasswordForm::SCHEME_HTML);
@@ skipping 207 matching lines @@
   MockAppleKeychain::KeychainTestData data1 = { kSecAuthenticationTypeHTMLForm,
      "some.domain.com", kSecProtocolTypeHTTP, NULL, 0, NULL, "20020601171500Z",
      "joe_user", "sekrit", false};
   keychain()->AddTestItem(data1);
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain());
   PasswordFormData data2 = { 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, 0 };
   keychain_adapter.AddPassword(*CreatePasswordFormFromDataForTesting(data2));
-  std::vector<std::unique_ptr<autofill::PasswordForm>> passwords =
-      password_manager_util::ConvertScopedVector(
-          keychain_adapter.GetAllPasswordFormPasswords());
+  std::vector<std::unique_ptr<PasswordForm>> passwords =
+      keychain_adapter.GetAllPasswordFormPasswords();
   EXPECT_EQ(2u, passwords.size());
 
   // Delete everyhting but only the Chrome-owned item should be affected.
   PasswordStoreMac::CleanUpKeychain(keychain(), passwords);
-  passwords = password_manager_util::ConvertScopedVector(
-      keychain_adapter.GetAllPasswordFormPasswords());
+  passwords = keychain_adapter.GetAllPasswordFormPasswords();
   ASSERT_EQ(1u, passwords.size());
   EXPECT_EQ("http://some.domain.com/", passwords[0]->signon_realm);
   EXPECT_EQ(ASCIIToUTF16("sekrit"), passwords[0]->password_value);
 }