Remove ScopedVector from PasswordStoreX

chrome/browser/password_manager/native_backend_gnome_x.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/native_backend_gnome_x.h"
 
 #include <limits>
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 97 matching lines @@
   }
   return form;
 }
 
 // Converts native credentials in |found| to PasswordForms. If not NULL,
 // |lookup_form| is used to filter out results -- only credentials with signon
 // realms passing the PSL matching against |lookup_form->signon_realm| will be
 // kept. PSL matched results get their signon_realm, origin, and action
 // rewritten to those of |lookup_form_|, with the original signon_realm saved
 // into the result's original_signon_realm data member.
-ScopedVector<PasswordForm> ConvertFormList(
+std::vector<std::unique_ptr<PasswordForm>> ConvertFormList(
     GList* found,
     const PasswordStore::FormDigest* lookup_form) {
-  ScopedVector<PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   password_manager::PSLDomainMatchMetric psl_domain_match_metric =
       password_manager::PSL_DOMAIN_MATCH_NONE;
   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;
        element = g_list_next(element)) {
     GnomeKeyringFound* data = static_cast<GnomeKeyringFound*>(element->data);
     GnomeKeyringAttributeList* attrs = data->attributes;
@@ skipping 94 matching lines @@
   void RemoveLogin(const PasswordForm& form, const char* app_string);
   void GetLogins(const PasswordStore::FormDigest& form, const char* app_string);
   void GetLoginsList(uint32_t blacklisted_by_user, const char* app_string);
   void GetAllLogins(const char* app_string);
 
   // Use after AddLogin, RemoveLogin.
   GnomeKeyringResult WaitResult();
 
   // Use after LoginSearch, GetLogins, GetLoginsList, GetAllLogins. Replaces the
   // content of |forms| with found logins.
-  GnomeKeyringResult WaitResult(ScopedVector<PasswordForm>* forms);
+  GnomeKeyringResult WaitResult(
+      std::vector<std::unique_ptr<PasswordForm>>* forms);
 
  private:
   struct GnomeKeyringAttributeListFreeDeleter {
     inline void operator()(void* list) const {
       gnome_keyring_attribute_list_free_ptr(
           static_cast<GnomeKeyringAttributeList*>(list));
     }
   };
 
   typedef std::unique_ptr<GnomeKeyringAttributeList,
@@ skipping 15 matching lines @@
   static void OnOperationDone(GnomeKeyringResult result, gpointer data);
 
   // This is marked as static, but acts on the GKRMethod instance that |data|
   // points to. Saves |result| to |result_|. If the result is OK, overwrites
   // |forms_| with the found credentials. Clears |forms_| otherwise.
   static void OnOperationGetList(GnomeKeyringResult result, GList* list,
                                  gpointer data);
 
   base::WaitableEvent event_;
   GnomeKeyringResult result_;
-  ScopedVector<PasswordForm> forms_;
+  std::vector<std::unique_ptr<PasswordForm>> forms_;
   // If the credential search is specified by a single form and needs to use
   // PSL matching, then the specifying form is stored in |lookup_form_|. If
   // PSL matching is used to find a result, then the results signon realm and
   // origin are stored are replaced by those of |lookup_form_|. Additionally,
   // |lookup_form_->signon_realm| is also used to narrow down the found logins
   // to those which indeed PSL-match the look-up. And finally, |lookup_form_|
   // set to NULL means that PSL matching is not required.
   std::unique_ptr<const PasswordStore::FormDigest> lookup_form_;
 };
 
@@ skipping 125 matching lines @@
                                /*data=*/this,
                                /*destroy_data=*/nullptr);
 }
 
 GnomeKeyringResult GKRMethod::WaitResult() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   event_.Wait();
   return result_;
 }
 
-GnomeKeyringResult GKRMethod::WaitResult(ScopedVector<PasswordForm>* forms) {
+GnomeKeyringResult GKRMethod::WaitResult(
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   event_.Wait();
   *forms = std::move(forms_);
   return result_;
 }
 
 // static
 void GKRMethod::AppendString(GKRMethod::ScopedAttributeList* list,
                              const char* name,
                              const char* value) {
@@ skipping 78 matching lines @@
   // on origin_url, username_element, username_value, password_element, submit
   // element, and signon_realm first, remove that, 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_CURRENTLY_ON(BrowserThread::DB);
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::LoginSearch,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
-  ScopedVector<PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   GnomeKeyringResult result = method.WaitResult(&forms);
   if (result != GNOME_KEYRING_RESULT_OK &&
       result != GNOME_KEYRING_RESULT_NO_MATCH) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message_ptr(result);
     return password_manager::PasswordStoreChangeList();
   }
   password_manager::PasswordStoreChangeList 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 NativeBackendGnome::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_CURRENTLY_ON(BrowserThread::DB);
   DCHECK(changes);
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::LoginSearch,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
-  ScopedVector<PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   GnomeKeyringResult result = method.WaitResult(&forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   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);
@@ skipping 38 matching lines @@
 bool NativeBackendGnome::RemoveLoginsSyncedBetween(
     base::Time delete_begin,
     base::Time delete_end,
     password_manager::PasswordStoreChangeList* changes) {
   return RemoveLoginsBetween(delete_begin, delete_end, SYNC_TIMESTAMP, changes);
 }
 
 bool NativeBackendGnome::DisableAutoSignInForOrigins(
     const base::Callback<bool(const GURL&)>& origin_filter,
     password_manager::PasswordStoreChangeList* changes) {
-  ScopedVector<PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   if (!GetAllLogins(&forms))
     return false;
 
-  for (auto* form : forms) {
+  for (const std::unique_ptr<PasswordForm>& form : 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 NativeBackendGnome::GetLogins(const PasswordStore::FormDigest& form,
-                                   ScopedVector<PasswordForm>* forms) {
+bool NativeBackendGnome::GetLogins(
+    const PasswordStore::FormDigest& form,
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetLogins,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   return true;
 }
 
 bool NativeBackendGnome::GetAutofillableLogins(
-    ScopedVector<PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   return GetLoginsList(true, forms);
 }
 
-bool NativeBackendGnome::GetBlacklistLogins(ScopedVector<PasswordForm>* forms) {
+bool NativeBackendGnome::GetBlacklistLogins(
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   return GetLoginsList(false, forms);
 }
 
-bool NativeBackendGnome::GetLoginsList(bool autofillable,
-                                       ScopedVector<PasswordForm>* forms) {
+bool NativeBackendGnome::GetLoginsList(
+    bool autofillable,
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
 
   uint32_t blacklisted_by_user = !autofillable;
 
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetLoginsList,
                                      base::Unretained(&method),
                                      blacklisted_by_user, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
 
   // Get rid of the forms with the same sync tags.
-  ScopedVector<autofill::PasswordForm> duplicates;
+  std::vector<std::unique_ptr<PasswordForm>> duplicates;
   std::vector<std::vector<autofill::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 NativeBackendGnome::GetAllLogins(ScopedVector<PasswordForm>* forms) {
+bool NativeBackendGnome::GetAllLogins(
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetAllLogins,
                                      base::Unretained(&method),
                                      app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   return true;
 }
 
-bool NativeBackendGnome::GetLoginsBetween(base::Time get_begin,
-                                          base::Time get_end,
-                                          TimestampToCompare date_to_compare,
-                                          ScopedVector<PasswordForm>* forms) {
+bool NativeBackendGnome::GetLoginsBetween(
+    base::Time get_begin,
+    base::Time get_end,
+    TimestampToCompare date_to_compare,
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   forms->clear();
   // We could walk the list and add items as we find them, but it is much
   // easier to build the list and then filter the results.
-  ScopedVector<PasswordForm> all_forms;
+  std::vector<std::unique_ptr<PasswordForm>> all_forms;
   if (!GetAllLogins(&all_forms))
     return false;
 
   base::Time PasswordForm::*date_member = date_to_compare == CREATION_TIMESTAMP
                                               ? &PasswordForm::date_created
                                               : &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;
+  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 NativeBackendGnome::RemoveLoginsBetween(
     base::Time get_begin,
     base::Time get_end,
     TimestampToCompare date_to_compare,
     password_manager::PasswordStoreChangeList* changes) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   DCHECK(changes);
   changes->clear();
   // We could walk the list and delete items as we find them, but it is much
   // easier to build the list and use RemoveLogin() to delete them.
-  ScopedVector<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;
 }