PasswordStore: Use ScopedVector to express ownership of forms

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 <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 106 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,
-    PasswordStoreX::NativeBackend::PasswordFormList* forms) {
+    ScopedVector<autofill::PasswordForm>* forms) {
   EXPECT_FALSE(backend->GetAutofillableLogins(forms));
 }
 
 }  // anonymous namespace
 
 // Obscure magic: we need to declare storage for this constant because we use it
 // in ways that require its address in this test, but not in the actual code.
 const int NativeBackendKWallet::kInvalidKWalletHandle;
 
 // Subclass NativeBackendKWallet to promote some members to public for testing.
@@ skipping 454 matching lines @@
   EXPECT_TRUE(wallet_.hasFolder(folder));
   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));
     Pickle pickle(reinterpret_cast<const char*>(value.data()), value.size());
-    std::vector<PasswordForm*> forms;
+    ScopedVector<autofill::PasswordForm> forms;
     NativeBackendKWalletStub::DeserializeValue(entries[i], pickle, &forms);
     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]);
-    STLDeleteElements(&forms);
   }
 }
 
 TEST_F(NativeBackendKWalletTest, NotEnabled) {
   NativeBackendKWalletStub kwallet(42);
   kwallet_enabled_ = false;
   EXPECT_FALSE(kwallet.InitWithBus(mock_session_bus_));
   EXPECT_FALSE(klauncher_contacted_);
 }
 
@@ skipping 84 matching lines @@
 
 TEST_F(NativeBackendKWalletTest, BasicListLogins) {
   NativeBackendKWalletStub backend(42);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
-  std::vector<PasswordForm*> form_list;
+  ScopedVector<autofill::PasswordForm> form_list;
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           base::IgnoreResult(&NativeBackendKWalletStub::GetAutofillableLogins),
           base::Unretained(&backend), &form_list));
 
   RunDBThread();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
-  STLDeleteElements(&form_list);
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
@@ skipping 80 matching lines @@
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 
   // Attempt to remove a login that doesn't exist.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::RemoveLogin),
                  base::Unretained(&backend), form_isc_));
 
   // Make sure we can still get the first form back.
-  std::vector<PasswordForm*> form_list;
+  ScopedVector<autofill::PasswordForm> form_list;
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           base::IgnoreResult(&NativeBackendKWalletStub::GetAutofillableLogins),
           base::Unretained(&backend), &form_list));
 
   RunDBThread();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
-  STLDeleteElements(&form_list);
 
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_F(NativeBackendKWalletTest, AddDuplicateLogin) {
   NativeBackendKWalletStub backend(42);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   PasswordStoreChangeList changes;
   changes.push_back(PasswordStoreChange(PasswordStoreChange::ADD,
@@ skipping 33 matching lines @@
 TEST_F(NativeBackendKWalletTest, ListLoginsAppends) {
   NativeBackendKWalletStub backend(42);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   // Send the same request twice with the same list both times.
-  std::vector<PasswordForm*> form_list;
+  ScopedVector<autofill::PasswordForm> form_list;
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           base::IgnoreResult(&NativeBackendKWalletStub::GetAutofillableLogins),
           base::Unretained(&backend), &form_list));
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           base::IgnoreResult(&NativeBackendKWalletStub::GetAutofillableLogins),
           base::Unretained(&backend), &form_list));
 
   RunDBThread();
 
   // Quick check that we got two results back.
   EXPECT_EQ(2u, form_list.size());
-  STLDeleteElements(&form_list);
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
@@ skipping 80 matching lines @@
   Pickle pickle;
   PasswordForm form = form_google_;
   // Remove the fields which were not present in version #3.
   form.display_name.clear();
   form.avatar_url = GURL();
   form.federation_url = GURL();
   form.is_zero_click = false;
   CreateVersion3Pickle(form, &pickle);
 
   ScopedVector<PasswordForm> form_list;
-  NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
-                                             pickle, &form_list.get());
+  NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle,
+                                             &form_list);
 
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0]);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion2Pickle() {
   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;
   CreateVersion2Pickle(form, &pickle);
 
   ScopedVector<PasswordForm> form_list;
-  NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
-                                             pickle, &form_list.get());
+  NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle,
+                                             &form_list);
 
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0]);
 }
 
 // Make sure that we can still read version 1 pickles.
 void NativeBackendKWalletPickleTest::CheckVersion1Pickle() {
   Pickle pickle;
   PasswordForm form = form_google_;
   CreateVersion1Pickle(form, &pickle);
 
-  std::vector<PasswordForm*> form_list;
+  ScopedVector<autofill::PasswordForm> form_list;
   NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
                                              pickle, &form_list);
 
   // 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]);
-  STLDeleteElements(&form_list);
 }
 
 void NativeBackendKWalletPickleTest::CheckVersion0Pickle(
     bool size_32, PasswordForm::Scheme scheme) {
   Pickle pickle;
   PasswordForm form = old_form_google_;
   form.scheme = scheme;
   CreateVersion0Pickle(size_32, form, &pickle);
-  std::vector<PasswordForm*> form_list;
+  ScopedVector<autofill::PasswordForm> form_list;
   NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
                                              pickle, &form_list);
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0]);
-  STLDeleteElements(&form_list);
 }
 
 // Check that if KWallet fails to respond, the backend propagates the error.
 TEST_F(NativeBackendKWalletTest, GetAllLoginsErrorHandling) {
   NativeBackendKWalletStub backend(42);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
   // Make KWallet fail on calling readEntry.
   failing_methods_.insert("readEntry");
 
   // Store some non-blacklisted logins to be potentially returned.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   // Verify that nothing is in fact returned, because KWallet fails to respond.
-  std::vector<PasswordForm*> form_list;
+  ScopedVector<autofill::PasswordForm> form_list;
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
                           base::Bind(&CheckGetAutofillableLoginsFails,
                                      base::Unretained(&backend), &form_list));
   RunDBThread();
   EXPECT_EQ(0u, form_list.size());
 }
 
 // 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
@@ skipping 22 matching lines @@
   CheckVersion1Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion2Pickle) {
   CheckVersion2Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion3Pickle) {
   CheckVersion3Pickle();
 }