Remove ScopedVector from PasswordStoreX

chrome/browser/password_manager/native_backend_libsecret.cc

 // Copyright (c) 2015 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/native_backend_libsecret.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <libsecret/secret.h>
@@ skipping 162 matching lines @@
 bool NativeBackendLibsecret::Init() {
   return LibsecretLoader::EnsureLibsecretLoaded();
 }
 
 password_manager::PasswordStoreChangeList NativeBackendLibsecret::AddLogin(
     const PasswordForm& form) {
   // Based on LoginDatabase::AddLogin(), we search for an existing match based
   // on origin_url, username_element, username_value, password_element and
   // signon_realm first, remove that, and then add the new entry.
   password_manager::PasswordStoreChangeList changes;
-  ScopedVector<autofill::PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   if (!AddUpdateLoginSearch(form, &forms))
     return changes;
 
   if (forms.size() > 0) {
     password_manager::PasswordStoreChangeList temp_changes;
     if (forms.size() > 1) {
       LOG(WARNING) << "Adding login when there are " << forms.size()
                    << " matching logins already!";
     }
-    for (const PasswordForm* old_form : forms) {
+    for (const auto& old_form : forms) {
       if (!RemoveLogin(*old_form, &temp_changes))
         return changes;
     }
     changes.push_back(password_manager::PasswordStoreChange(
         password_manager::PasswordStoreChange::REMOVE, *forms[0]));
   }
   if (RawAddLogin(form)) {
     changes.push_back(password_manager::PasswordStoreChange(
         password_manager::PasswordStoreChange::ADD, form));
   }
   return changes;
 }
 
 bool NativeBackendLibsecret::UpdateLogin(
     const PasswordForm& form,
     password_manager::PasswordStoreChangeList* changes) {
   // Based on LoginDatabase::UpdateLogin(), we search for forms to update by
   // origin_url, username_element, username_value, password_element, and
   // signon_realm. We then compare the result to the updated form. If they
   // differ in any of the mutable fields, then we remove the original, and
   // then add the new entry. We'd add the new one first, and then delete the
   // original, but then the delete might actually delete the newly-added entry!
   DCHECK(changes);
-  ScopedVector<autofill::PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   if (!AddUpdateLoginSearch(form, &forms))
     return false;
   if (forms.empty())
     return true;
   if (forms.size() == 1 && *forms.front() == form)
     return true;
 
   password_manager::PasswordStoreChangeList temp_changes;
-  for (const PasswordForm* keychain_form : forms) {
+  for (const auto& keychain_form : forms) {
     // Remove all the obsolete forms. Note that RemoveLogin can remove any form
     // matching the unique key. Thus, it's important to call it the right number
     // of times.
     if (!RemoveLogin(*keychain_form, &temp_changes))
       return false;
   }
 
   if (RawAddLogin(form)) {
     password_manager::PasswordStoreChange change(
         password_manager::PasswordStoreChange::UPDATE, form);
     changes->push_back(change);
     return true;
   }
   return false;
 }
 
 bool NativeBackendLibsecret::RemoveLogin(
-    const autofill::PasswordForm& form,
+    const PasswordForm& form,
     password_manager::PasswordStoreChangeList* changes) {
   DCHECK(changes);
   GError* error = nullptr;
   if (LibsecretLoader::secret_password_clear_sync(
           &kLibsecretSchema, nullptr, &error, "origin_url",
           form.origin.spec().c_str(), "username_element",
           UTF16ToUTF8(form.username_element).c_str(), "username_value",
           UTF16ToUTF8(form.username_value).c_str(), "password_element",
           UTF16ToUTF8(form.password_element).c_str(), "signon_realm",
           form.signon_realm.c_str(), "application", app_string_.c_str(),
@@ skipping 21 matching lines @@
 bool NativeBackendLibsecret::RemoveLoginsSyncedBetween(
     base::Time delete_begin,
     base::Time delete_end,
     password_manager::PasswordStoreChangeList* changes) {
   return RemoveLoginsBetween(delete_begin, delete_end, SYNC_TIMESTAMP, changes);
 }
 
 bool NativeBackendLibsecret::DisableAutoSignInForOrigins(
     const base::Callback<bool(const GURL&)>& origin_filter,
     password_manager::PasswordStoreChangeList* changes) {
-  ScopedVector<autofill::PasswordForm> all_forms;
+  std::vector<std::unique_ptr<PasswordForm>> all_forms;
   if (!GetLoginsList(nullptr, ALL_LOGINS, &all_forms))
     return false;
 
-  for (auto* form : all_forms) {
+  for (const std::unique_ptr<PasswordForm>& form : all_forms) {
     if (origin_filter.Run(form->origin) && !form->skip_zero_click) {
       form->skip_zero_click = true;
       if (!UpdateLogin(*form, changes))
         return false;
     }
   }
 
   return true;
 }
 
 bool NativeBackendLibsecret::GetLogins(
     const PasswordStore::FormDigest& form,
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   return GetLoginsList(&form, ALL_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::AddUpdateLoginSearch(
-    const autofill::PasswordForm& lookup_form,
-    ScopedVector<autofill::PasswordForm>* forms) {
+    const PasswordForm& lookup_form,
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   if (!ensured_keyring_unlocked_) {
     LibsecretLoader::EnsureKeyringUnlocked();
     ensured_keyring_unlocked_ = true;
   }
 
   LibsecretAttributesBuilder attrs;
   attrs.Append("origin_url", lookup_form.origin.spec());
   attrs.Append("username_element", UTF16ToUTF8(lookup_form.username_element));
   attrs.Append("username_value", UTF16ToUTF8(lookup_form.username_value));
   attrs.Append("password_element", UTF16ToUTF8(lookup_form.password_element));
@@ skipping 68 matching lines @@
 
   if (error) {
     LOG(ERROR) << "Libsecret add raw login failed: " << error->message;
     g_error_free(error);
     return false;
   }
   return true;
 }
 
 bool NativeBackendLibsecret::GetAutofillableLogins(
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   return GetLoginsList(nullptr, AUTOFILLABLE_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::GetBlacklistLogins(
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   return GetLoginsList(nullptr, BLACKLISTED_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::GetAllLogins(
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   return GetLoginsList(nullptr, ALL_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::GetLoginsList(
     const PasswordStore::FormDigest* lookup_form,
     GetLoginsListOptions options,
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   if (!ensured_keyring_unlocked_) {
     LibsecretLoader::EnsureKeyringUnlocked();
     ensured_keyring_unlocked_ = true;
   }
 
   LibsecretAttributesBuilder attrs;
   attrs.Append("application", app_string_);
   if (options != ALL_LOGINS)
     attrs.Append("blacklisted_by_user", options == BLACKLISTED_LOGINS);
   if (lookup_form &&
@@ skipping 16 matching lines @@
     if (found)
       g_list_free(found);
     return false;
   }
 
   *forms = ConvertFormList(found, lookup_form);
   if (lookup_form)
     return true;
 
   // Get rid of the forms with the same sync tags.
-  ScopedVector<autofill::PasswordForm> duplicates;
-  std::vector<std::vector<autofill::PasswordForm*>> tag_groups;
+  std::vector<std::unique_ptr<PasswordForm>> duplicates;
+  std::vector<std::vector<PasswordForm*>> tag_groups;
   password_manager_util::FindDuplicates(forms, &duplicates, &tag_groups);
   if (duplicates.empty())
     return true;
   for (const auto& group : tag_groups) {
     if (group.size() > 1) {
       // There are duplicates. Readd the first form. AddLogin() is smart enough
       // to clean the previous ones.
       password_manager::PasswordStoreChangeList changes = AddLogin(*group[0]);
       if (changes.empty() ||
           changes.back().type() != password_manager::PasswordStoreChange::ADD)
         return false;
     }
   }
   return true;
 }
 
 bool NativeBackendLibsecret::GetLoginsBetween(
     base::Time get_begin,
     base::Time get_end,
     TimestampToCompare date_to_compare,
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   forms->clear();
-  ScopedVector<autofill::PasswordForm> all_forms;
+  std::vector<std::unique_ptr<PasswordForm>> all_forms;
   if (!GetLoginsList(nullptr, ALL_LOGINS, &all_forms))
     return false;
 
-  base::Time autofill::PasswordForm::*date_member =
-      date_to_compare == CREATION_TIMESTAMP
-          ? &autofill::PasswordForm::date_created
-          : &autofill::PasswordForm::date_synced;
-  for (auto*& saved_form : all_forms) {
-    if (get_begin <= saved_form->*date_member &&
-        (get_end.is_null() || saved_form->*date_member < get_end)) {
-      forms->push_back(saved_form);
-      saved_form = nullptr;
+  base::Time PasswordForm::*date_member = date_to_compare == CREATION_TIMESTAMP
+                                              ? &PasswordForm::date_created
+                                              : &PasswordForm::date_synced;
+  for (std::unique_ptr<PasswordForm>& saved_form : all_forms) {
+    if (get_begin <= saved_form.get()->*date_member &&
+        (get_end.is_null() || saved_form.get()->*date_member < get_end)) {
+      forms->push_back(std::move(saved_form));
     }
   }
 
   return true;
 }
 
 bool NativeBackendLibsecret::RemoveLoginsBetween(
     base::Time get_begin,
     base::Time get_end,
     TimestampToCompare date_to_compare,
     password_manager::PasswordStoreChangeList* changes) {
   DCHECK(changes);
   changes->clear();
-  ScopedVector<autofill::PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   if (!GetLoginsBetween(get_begin, get_end, date_to_compare, &forms))
     return false;
 
   for (size_t i = 0; i < forms.size(); ++i) {
     if (!RemoveLogin(*forms[i], changes))
       return false;
   }
   return true;
 }
 
-ScopedVector<autofill::PasswordForm> NativeBackendLibsecret::ConvertFormList(
+std::vector<std::unique_ptr<PasswordForm>>
+NativeBackendLibsecret::ConvertFormList(
     GList* found,
     const PasswordStore::FormDigest* lookup_form) {
-  ScopedVector<autofill::PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   password_manager::PSLDomainMatchMetric psl_domain_match_metric =
       password_manager::PSL_DOMAIN_MATCH_NONE;
   GError* error = nullptr;
   const bool allow_psl_match =
       lookup_form && password_manager::ShouldPSLDomainMatchingApply(
                          password_manager::GetRegistryControlledDomain(
                              GURL(lookup_form->signon_realm)));
   for (GList* element = g_list_first(found); element != nullptr;
        element = g_list_next(element)) {
     SecretItem* secretItem = static_cast<SecretItem*>(element->data);
@@ skipping 43 matching lines @@
   if (lookup_form) {
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               allow_psl_match
                                   ? psl_domain_match_metric
                                   : password_manager::PSL_DOMAIN_MATCH_NOT_USED,
                               password_manager::PSL_DOMAIN_MATCH_COUNT);
   }
   g_list_free(found);
   return forms;
 }