Remove ScopedVector from PasswordStoreMac

components/password_manager/core/browser/login_database.cc

 // Copyright 2014 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 "components/password_manager/core/browser/login_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
@@ skipping 892 matching lines @@
   s.BindString16(2, form.username_value);
   s.BindString16(3, form.password_element);
   s.BindString(4, form.signon_realm);
 
   return s.Run() && db_.GetLastChangeCount() > 0;
 }
 
 bool LoginDatabase::RemoveLoginsCreatedBetween(base::Time delete_begin,
                                                base::Time delete_end) {
 #if defined(OS_IOS)
-  ScopedVector<autofill::PasswordForm> forms;
+  std::vector<std::unique_ptr<PasswordForm>> forms;
   if (GetLoginsCreatedBetween(delete_begin, delete_end, &forms)) {
     for (size_t i = 0; i < forms.size(); i++) {
       DeleteEncryptedPassword(*forms[i]);
     }
   }
 #endif
 
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM logins WHERE "
       "date_created >= ? AND date_created < ?"));
@@ skipping 11 matching lines @@
       "DELETE FROM logins WHERE date_synced >= ? AND date_synced < ?"));
   s.BindInt64(0, delete_begin.ToInternalValue());
   s.BindInt64(1,
               delete_end.is_null() ? base::Time::Max().ToInternalValue()
                                    : delete_end.ToInternalValue());
 
   return s.Run();
 }
 
 bool LoginDatabase::GetAutoSignInLogins(
-    ScopedVector<autofill::PasswordForm>* forms) const {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   DCHECK(forms);
   DCHECK(!autosignin_statement_.empty());
   sql::Statement s(
       db_.GetCachedStatement(SQL_FROM_HERE, autosignin_statement_.c_str()));
 
   return StatementToForms(&s, nullptr, forms);
 }
 
 bool LoginDatabase::DisableAutoSignInForOrigin(const GURL& origin) {
   sql::Statement s(db_.GetCachedStatement(
@@ skipping 72 matching lines @@
   DCHECK(generation_upload_status_int >= 0 &&
          generation_upload_status_int <= PasswordForm::UNKNOWN_STATUS);
   form->generation_upload_status =
       static_cast<PasswordForm::GenerationUploadStatus>(
           generation_upload_status_int);
   return ENCRYPTION_RESULT_SUCCESS;
 }
 
 bool LoginDatabase::GetLogins(
     const PasswordStore::FormDigest& form,
-    std::vector<std::unique_ptr<autofill::PasswordForm>>* forms) const {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   DCHECK(forms);
   const GURL signon_realm(form.signon_realm);
   std::string registered_domain = GetRegistryControlledDomain(signon_realm);
   const bool should_PSL_matching_apply =
       form.scheme == PasswordForm::SCHEME_HTML &&
       ShouldPSLDomainMatchingApply(registered_domain);
   const bool should_federated_apply = form.scheme == PasswordForm::SCHEME_HTML;
   DCHECK(!get_statement_.empty());
   DCHECK(!get_statement_psl_.empty());
   DCHECK(!get_statement_federated_.empty());
@@ skipping 43 matching lines @@
     s.BindString(placeholder++, expression);
   }
 
   if (!should_PSL_matching_apply && !should_federated_apply) {
     // Otherwise the histogram is reported in StatementToForms.
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               PSL_DOMAIN_MATCH_NOT_USED,
                               PSL_DOMAIN_MATCH_COUNT);
   }
 
-  ScopedVector<autofill::PasswordForm> forms_scopedvector;
   bool success = StatementToForms(
       &s, should_PSL_matching_apply || should_federated_apply ? &form : nullptr,
-      &forms_scopedvector);
-  if (success) {
-    *forms = password_manager_util::ConvertScopedVector(
-        std::move(forms_scopedvector));
+      forms);
+  if (success)
     return true;
-  }
   forms->clear();
   return false;
 }
 
 bool LoginDatabase::GetLoginsCreatedBetween(
     const base::Time begin,
     const base::Time end,
-    ScopedVector<autofill::PasswordForm>* forms) const {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   DCHECK(forms);
   DCHECK(!created_statement_.empty());
   sql::Statement s(
       db_.GetCachedStatement(SQL_FROM_HERE, created_statement_.c_str()));
   s.BindInt64(0, begin.ToInternalValue());
   s.BindInt64(1, end.is_null() ? std::numeric_limits<int64_t>::max()
                                : end.ToInternalValue());
 
   return StatementToForms(&s, nullptr, forms);
 }
 
 bool LoginDatabase::GetLoginsSyncedBetween(
     const base::Time begin,
     const base::Time end,
-    ScopedVector<autofill::PasswordForm>* forms) const {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   DCHECK(forms);
   DCHECK(!synced_statement_.empty());
   sql::Statement s(
       db_.GetCachedStatement(SQL_FROM_HERE, synced_statement_.c_str()));
   s.BindInt64(0, begin.ToInternalValue());
   s.BindInt64(1,
               end.is_null() ? base::Time::Max().ToInternalValue()
                             : end.ToInternalValue());
 
   return StatementToForms(&s, nullptr, forms);
 }
 
 bool LoginDatabase::GetAutofillableLogins(
-    std::vector<std::unique_ptr<autofill::PasswordForm>>* forms) const {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   return GetAllLoginsWithBlacklistSetting(false, forms);
 }
 
 bool LoginDatabase::GetBlacklistLogins(
-    std::vector<std::unique_ptr<autofill::PasswordForm>>* forms) const {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   return GetAllLoginsWithBlacklistSetting(true, forms);
 }
 
 bool LoginDatabase::GetAllLoginsWithBlacklistSetting(
     bool blacklisted,
     std::vector<std::unique_ptr<PasswordForm>>* forms) const {
   DCHECK(forms);
   DCHECK(!blacklisted_statement_.empty());
   sql::Statement s(
       db_.GetCachedStatement(SQL_FROM_HERE, blacklisted_statement_.c_str()));
   s.BindInt(0, blacklisted ? 1 : 0);
 
-  ScopedVector<autofill::PasswordForm> forms_scopedvector;
-  bool success = StatementToForms(&s, nullptr, &forms_scopedvector);
-  if (success) {
-    *forms = password_manager_util::ConvertScopedVector(
-        std::move(forms_scopedvector));
+  bool success = StatementToForms(&s, nullptr, forms);
+  if (success)
     return true;
-  }
   forms->clear();
   return false;
 }
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init();
 }
 
 std::string LoginDatabase::GetEncryptedPassword(
-    const autofill::PasswordForm& form) const {
+    const PasswordForm& form) const {
   DCHECK(!encrypted_statement_.empty());
   sql::Statement s(
       db_.GetCachedStatement(SQL_FROM_HERE, encrypted_statement_.c_str()));
 
   s.BindString(0, form.origin.spec());
   s.BindString16(1, form.username_element);
   s.BindString16(2, form.username_value);
   s.BindString16(3, form.password_element);
   s.BindString(4, form.signon_realm);
 
   std::string encrypted_password;
   if (s.Step()) {
     s.ColumnBlobAsString(0, &encrypted_password);
   }
   return encrypted_password;
 }
 
 // static
 bool LoginDatabase::StatementToForms(
     sql::Statement* statement,
     const PasswordStore::FormDigest* matched_form,
-    ScopedVector<autofill::PasswordForm>* forms) {
+    std::vector<std::unique_ptr<PasswordForm>>* forms) {
   PSLDomainMatchMetric psl_domain_match_metric = PSL_DOMAIN_MATCH_NONE;
 
   forms->clear();
   while (statement->Step()) {
-    std::unique_ptr<PasswordForm> new_form(new PasswordForm());
+    auto new_form = base::MakeUnique<PasswordForm>();
     EncryptionResult result =
         InitPasswordFormFromStatement(new_form.get(), *statement);
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
       return false;
     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
       continue;
     DCHECK_EQ(ENCRYPTION_RESULT_SUCCESS, result);
     if (matched_form && matched_form->signon_realm != new_form->signon_realm) {
       if (new_form->scheme != PasswordForm::SCHEME_HTML)
         continue;  // Ignore non-HTML matches.
@@ skipping 80 matching lines @@
   DCHECK(blacklisted_statement_.empty());
   blacklisted_statement_ =
       "SELECT " + all_column_names +
       " FROM logins WHERE blacklisted_by_user == ? ORDER BY origin_url";
   DCHECK(encrypted_statement_.empty());
   encrypted_statement_ =
       "SELECT password_value FROM logins WHERE " + all_unique_key_column_names;
 }
 
 }  // namespace password_manager