Remove ScopedVector from PasswordStoreX

chrome/browser/password_manager/native_backend_kwallet_x_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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 119 matching lines @@
   // legacy shared passwords in these tests, for testing the migration code.
   bool reject_local_folders_;
 
   // No need to disallow copy and assign. This class is safe to copy and assign.
 };
 
 // Runs |backend->GetAutofillableLogins(forms)| and expects that the return
 // value is false.
 void CheckGetAutofillableLoginsFails(
     PasswordStoreX::NativeBackend* backend,
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   EXPECT_FALSE(backend->GetAutofillableLogins(forms));
 }
 
 void CheckTrue(bool result) {
   EXPECT_TRUE(result);
 }
 
 void WriteHTMLAttributes(const PasswordForm& form, base::Pickle* pickle) {
   pickle->WriteInt(form.scheme);
   pickle->WriteString(form.origin.spec());
@@ skipping 505 matching lines @@
   std::vector<std::string> entries;
   EXPECT_TRUE(wallet_.entryList(folder, &entries));
   EXPECT_EQ(sorted_expected.size(), entries.size());
   std::sort(entries.begin(), entries.end());
   for (size_t i = 0; i < entries.size() && i < sorted_expected.size(); ++i) {
     EXPECT_EQ(sorted_expected[i].first, entries[i]);
     TestKWallet::Blob value;
     EXPECT_TRUE(wallet_.readEntry(folder, entries[i], &value));
     base::Pickle pickle(reinterpret_cast<const char*>(value.data()),
                         value.size());
-    ScopedVector<autofill::PasswordForm> forms =
+    std::vector<std::unique_ptr<PasswordForm>> forms =
         NativeBackendKWalletStub::DeserializeValue(entries[i], pickle);
     const std::vector<const PasswordForm*>& expect = sorted_expected[i].second;
     EXPECT_EQ(expect.size(), forms.size());
     for (size_t j = 0; j < forms.size() && j < expect.size(); ++j)
       CheckPasswordForm(*expect[j], *forms[j], true);
   }
 }
 
 TEST_P(NativeBackendKWalletTest, NotEnabled) {
   NativeBackendKWalletStub kwallet(42, desktop_env_);
@@ skipping 95 matching lines @@
 
 TEST_P(NativeBackendKWalletTest, BasicListLogins) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
   RunDBThread();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
@@ skipping 99 matching lines @@
   // Attempt to remove a login that doesn't exist.
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::RemoveLogin,
                  base::Unretained(&backend), form_isc_, &changes),
       base::Bind(&CheckPasswordChangesWithResult,
                  base::Owned(new PasswordStoreChangeList), &changes));
 
   // Make sure we can still get the first form back.
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
   RunDBThread();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
@@ skipping 55 matching lines @@
   password_manager::PasswordStore::FormDigest observed_android_form(
       saved_android_form);
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::AddLogin,
                  base::Unretained(&backend), saved_android_form),
       base::Bind(&CheckPasswordChanges,
                  PasswordStoreChangeList(1, PasswordStoreChange(
                      PasswordStoreChange::ADD, saved_android_form))));
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetLogins,
                  base::Unretained(&backend), observed_android_form, &form_list),
       base::Bind(&CheckTrue));
 
   RunDBThread();
 
   EXPECT_EQ(1u, form_list.size());
 
@@ skipping 87 matching lines @@
   ASSERT_TRUE(wallet_.readEntry("Chrome Form Data (42)",
                                 form_google_.signon_realm, &value));
   TestKWallet::Blob sample(reinterpret_cast<const uint8_t*>(unique_string));
   size_t position = value.find(sample);
   ASSERT_NE(TestKWallet::Blob::npos, position);
   value.replace(position, sample.length(),
                 reinterpret_cast<const uint8_t*>(unique_string_replacement));
   wallet_.writeEntry("Chrome Form Data (42)", form_google_.signon_realm, value);
 
   // Now test that GetAutofillableLogins returns only one form.
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
   RunDBThread();
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(form_google_, *form_list[0]);
 
@@ skipping 14 matching lines @@
   // Store some non-blacklisted logins to be potentially returned.
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::AddLogin,
                  base::Unretained(&backend), form_google_),
       base::Bind(&CheckPasswordChanges,
                  PasswordStoreChangeList(1, PasswordStoreChange(
                       PasswordStoreChange::ADD, form_google_))));
 
   // Verify that nothing is in fact returned, because KWallet fails to respond.
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
                           base::Bind(&CheckGetAutofillableLoginsFails,
                                      base::Unretained(&backend), &form_list));
   RunDBThread();
   EXPECT_EQ(0u, form_list.size());
 }
 
 TEST_P(NativeBackendKWalletTest, GetAllLogins) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_isc_));
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAllLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
   RunDBThread();
 
   EXPECT_EQ(2u, form_list.size());
   EXPECT_THAT(form_list,
@@ skipping 87 matching lines @@
 
 void NativeBackendKWalletPickleTest::CheckVersion9Pickle() {
   // Pickle 9+ dropped an old flag in the middle of PasswordForm. This test
   // makes sure that the attributes after the dropped flag are deserialised
   // correctly.
   base::Pickle pickle;
   PasswordForm default_values;
   PasswordForm form = form_google_;
 
   CreateVersion1PlusPickle(form, &pickle, 9, 9);
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], true);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion8Pickle() {
   base::Pickle pickle;
   PasswordForm default_values;
   PasswordForm form = form_google_;
 
   // Version 8 pickles deserialize with their own 'skip_zero_click' value.
   form.skip_zero_click = false;
   CreateVersion1PlusPickle(form, &pickle, 8, 8);
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], true);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion7Pickle() {
   base::Pickle pickle;
   PasswordForm default_values;
   PasswordForm form = form_google_;
 
   // Version 7 pickles always deserialize with 'skip_zero_click' of 'true'.
   form.skip_zero_click = false;
   CreateVersion1PlusPickle(form, &pickle, 7, 7);
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
   EXPECT_EQ(1u, form_list.size());
   form.skip_zero_click = true;
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], true);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion6Pickle(
     bool with_optional_field) {
   base::Pickle pickle;
   PasswordForm form = form_google_;
   if (!with_optional_field) {
     PasswordForm default_values;
     form.generation_upload_status = default_values.generation_upload_status;
   }
   CreateVersion1PlusPickle(form, &pickle, 6, with_optional_field ? 7 : 5);
 
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
 
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], true);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion5Pickle() {
   base::Pickle pickle;
   PasswordForm default_values;
   PasswordForm form = form_google_;
   // Remove the field which was not present in version #5.
   form.generation_upload_status = default_values.generation_upload_status;
   CreateVersion1PlusPickle(form, &pickle, 6, 6);
 
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
 
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], true);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion3Pickle() {
   base::Pickle pickle;
   PasswordForm default_values;
   PasswordForm form = form_google_;
   // Remove the fields which were not present in version #3.
   form.display_name = default_values.display_name;
   form.icon_url = default_values.icon_url;
   form.federation_origin = default_values.federation_origin;
   form.skip_zero_click = default_values.skip_zero_click;
   form.generation_upload_status = default_values.generation_upload_status;
   CreateVersion1PlusPickle(form, &pickle, 3, 3);
 
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
 
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], false);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion2Pickle() {
   base::Pickle pickle;
   PasswordForm form = old_form_google_;
   form.times_used = form_google_.times_used;
   form.type = form_google_.type;
   form.form_data = form_google_.form_data;
   CreateVersion1PlusPickle(form, &pickle, 2, 2);
 
-  ScopedVector<PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
 
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], false);
 }
 
 // Make sure that we can still read version 1 pickles.
 void NativeBackendKWalletPickleTest::CheckVersion1Pickle() {
   base::Pickle pickle;
   PasswordForm form = form_google_;
   CreateVersion1PlusPickle(form, &pickle, 1, 1);
 
-  ScopedVector<autofill::PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
 
   // This will match |old_form_google_| because not all the fields present in
   // |form_google_| will be deserialized.
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(old_form_google_, *form_list[0], false);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion0Pickle(
     bool size_32, PasswordForm::Scheme scheme) {
   base::Pickle pickle;
   PasswordForm form = old_form_google_;
   form.scheme = scheme;
   CreateVersion0Pickle(size_32, form, &pickle);
-  ScopedVector<autofill::PasswordForm> form_list =
+  std::vector<std::unique_ptr<PasswordForm>> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], false);
 }
 
 // We try both SCHEME_HTML and SCHEME_BASIC since the scheme is stored right
 // after the size in the pickle, so it's what gets read as part of the count
 // when reading 32-bit pickles on 64-bit systems. SCHEME_HTML is 0 (so we'll
 // detect errors later) while SCHEME_BASIC is 1 (so we'll detect it then). We
@@ skipping 42 matching lines @@
   CheckVersion7Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion8Pickle) {
   CheckVersion8Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion9Pickle) {
   CheckVersion9Pickle();
 }