Remove stl_util's STLDeleteContainerPointers from autofill.

components/autofill/core/browser/webdata/autofill_table.cc

 // Copyright 2013 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/autofill/core/browser/webdata/autofill_table.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
@@ skipping 874 matching lines @@
   // Get associated email info.
   AddAutofillProfileEmailsToProfile(db_, p.get());
 
   // Get associated phone info.
   AddAutofillProfilePhonesToProfile(db_, p.get());
 
   return p;
 }
 
 bool AutofillTable::GetAutofillProfiles(
-    std::vector<AutofillProfile*>* profiles) {
+    std::vector<std::unique_ptr<AutofillProfile>>* profiles) {
   DCHECK(profiles);
   profiles->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM autofill_profiles "
       "ORDER BY date_modified DESC, guid"));
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     std::unique_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
     if (!profile)
       return false;
-    profiles->push_back(profile.release());
+    profiles->push_back(std::move(profile));
   }
 
   return s.Succeeded();
 }
 
-bool AutofillTable::GetServerProfiles(std::vector<AutofillProfile*>* profiles) {
+bool AutofillTable::GetServerProfiles(
+    std::vector<std::unique_ptr<AutofillProfile>>* profiles) {
   profiles->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT "
         "id,"
         "use_count,"
         "use_date,"
         "recipient_name,"
         "company_name,"
         "street_address,"
         "address_1,"  // ADDRESS_HOME_STATE
         "address_2,"  // ADDRESS_HOME_CITY
         "address_3,"  // ADDRESS_HOME_DEPENDENT_LOCALITY
         "address_4,"  // Not supported in AutofillProfile yet.
         "postal_code,"  // ADDRESS_HOME_ZIP
         "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
         "country_code,"  // ADDRESS_HOME_COUNTRY
         "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
         "language_code "
       "FROM server_addresses addresses "
       "LEFT OUTER JOIN server_address_metadata USING (id)"));
 
   while (s.Step()) {
     int index = 0;
-    std::unique_ptr<AutofillProfile> profile(new AutofillProfile(
-        AutofillProfile::SERVER_PROFILE, s.ColumnString(index++)));
+    std::unique_ptr<AutofillProfile> profile =
+        base::MakeUnique<AutofillProfile>(AutofillProfile::SERVER_PROFILE,
+                                          s.ColumnString(index++));
     profile->set_use_count(s.ColumnInt64(index++));
     profile->set_use_date(Time::FromInternalValue(s.ColumnInt64(index++)));
     // Modification date is not tracked for server profiles. Explicitly set it
     // here to override the default value of Time::Now().
     profile->set_modification_date(Time());
 
     base::string16 recipient_name = s.ColumnString16(index++);
     profile->SetRawInfo(COMPANY_NAME, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_STATE, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_CITY, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
                         s.ColumnString16(index++));
     index++;  // Skip address_4 which we haven't added to AutofillProfile yet.
     profile->SetRawInfo(ADDRESS_HOME_ZIP, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_SORTING_CODE, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(index++));
     base::string16 phone_number = s.ColumnString16(index++);
     profile->set_language_code(s.ColumnString(index++));
 
     // SetInfo instead of SetRawInfo so the constituent pieces will be parsed
     // for these data types.
     profile->SetInfo(AutofillType(NAME_FULL), recipient_name,
                      profile->language_code());
     profile->SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), phone_number,
                      profile->language_code());
 
-    profiles->push_back(profile.release());
+    profiles->push_back(std::move(profile));
   }
 
   return s.Succeeded();
 }
 
 void AutofillTable::SetServerProfiles(
     const std::vector<AutofillProfile>& profiles) {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return;
@@ skipping 166 matching lines @@
       "WHERE guid = ?"));
   s.BindString(0, guid);
 
   if (!s.Step())
     return std::unique_ptr<CreditCard>();
 
   return CreditCardFromStatement(s);
 }
 
 bool AutofillTable::GetCreditCards(
-    std::vector<CreditCard*>* credit_cards) {
+    std::vector<std::unique_ptr<CreditCard>>* credit_cards) {
   DCHECK(credit_cards);
   credit_cards->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM credit_cards "
       "ORDER BY date_modified DESC, guid"));
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     std::unique_ptr<CreditCard> credit_card = GetCreditCard(guid);
     if (!credit_card)
       return false;
-    credit_cards->push_back(credit_card.release());
+    credit_cards->push_back(std::move(credit_card));
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::GetServerCreditCards(
-    std::vector<CreditCard*>* credit_cards) {
+    std::vector<std::unique_ptr<CreditCard>>* credit_cards) {
   credit_cards->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT "
       "card_number_encrypted, "  // 0
       "last_four,"     // 1
       "masked.id,"     // 2
       "metadata.use_count,"     // 3
       "metadata.use_date,"      // 4
       "type,"          // 5
@@ skipping 10 matching lines @@
 
     // If the card_number_encrypted field is nonempty, we can assume this card
     // is a full card, otherwise it's masked.
     base::string16 full_card_number = UnencryptedCardFromColumn(s, index++);
     base::string16 last_four = s.ColumnString16(index++);
     CreditCard::RecordType record_type = full_card_number.empty() ?
         CreditCard::MASKED_SERVER_CARD :
         CreditCard::FULL_SERVER_CARD;
     std::string server_id = s.ColumnString(index++);
 
-    CreditCard* card = new CreditCard(record_type, server_id);
+    std::unique_ptr<CreditCard> card =
+        base::MakeUnique<CreditCard>(record_type, server_id);
     card->SetRawInfo(
         CREDIT_CARD_NUMBER,
         record_type == CreditCard::MASKED_SERVER_CARD ? last_four
                                                       : full_card_number);
     card->set_use_count(s.ColumnInt64(index++));
     card->set_use_date(Time::FromInternalValue(s.ColumnInt64(index++)));
     // Modification date is not tracked for server cards. Explicitly set it here
     // to override the default value of Time::Now().
     card->set_modification_date(Time());
 
     std::string card_type = s.ColumnString(index++);
     if (record_type == CreditCard::MASKED_SERVER_CARD) {
       // The type must be set after setting the number to override the
-      // autodectected type.
+      // autodetected type.
       card->SetTypeForMaskedCard(card_type.c_str());
     } else {
       DCHECK_EQ(CreditCard::GetCreditCardType(full_card_number), card_type);
     }
 
     card->SetServerStatus(ServerStatusStringToEnum(s.ColumnString(index++)));
     card->SetRawInfo(CREDIT_CARD_NAME_FULL, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(index++));
     card->set_billing_address_id(s.ColumnString(index++));
-    credit_cards->push_back(card);
+    credit_cards->push_back(std::move(card));
   }
 
   return s.Succeeded();
 }
 
 void AutofillTable::SetServerCreditCards(
     const std::vector<CreditCard>& credit_cards) {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return;
@@ skipping 286 matching lines @@
       "DELETE FROM unmasked_credit_cards "
       "WHERE unmask_date >= ? AND unmask_date < ?"));
   s_unmasked_cards.BindInt64(0, delete_begin.ToInternalValue());
   s_unmasked_cards.BindInt64(1, delete_end.ToInternalValue());
   return s_unmasked_cards.Run();
 }
 
 bool AutofillTable::RemoveOriginURLsModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end,
-    ScopedVector<AutofillProfile>* profiles) {
+    std::vector<std::unique_ptr<AutofillProfile>>* profiles) {
   DCHECK(delete_end.is_null() || delete_begin < delete_end);
 
   time_t delete_begin_t = delete_begin.ToTimeT();
   time_t delete_end_t = GetEndTime(delete_end);
 
   // Remember Autofill profiles with URL origins in the time range.
   sql::Statement s_profiles_get(db_->GetUniqueStatement(
       "SELECT guid, origin FROM autofill_profiles "
       "WHERE date_modified >= ? AND date_modified < ?"));
   s_profiles_get.BindInt64(0, delete_begin_t);
@@ skipping 14 matching lines @@
     sql::Statement s_profile(db_->GetUniqueStatement(
         "UPDATE autofill_profiles SET origin='' WHERE guid=?"));
     s_profile.BindString(0, guid);
     if (!s_profile.Run())
       return false;
 
     std::unique_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
     if (!profile)
       return false;
 
-    profiles->push_back(profile.release());
+    profiles->push_back(std::move(profile));
   }
 
   // Remember Autofill credit cards with URL origins in the time range.
   sql::Statement s_credit_cards_get(db_->GetUniqueStatement(
       "SELECT guid, origin FROM credit_cards "
       "WHERE date_modified >= ? AND date_modified < ?"));
   s_credit_cards_get.BindInt64(0, delete_begin_t);
   s_credit_cards_get.BindInt64(1, delete_end_t);
 
   std::vector<std::string> credit_card_guids;
@@ skipping 699 matching lines @@
 }
 
 bool AutofillTable::MigrateToVersion67AddMaskedCardBillingAddress() {
   // The default value for this column is null, but Connection::ColumnString()
   // returns an empty string for that.
   return db_->Execute(
       "ALTER TABLE masked_credit_cards ADD COLUMN billing_address_id VARCHAR");
 }
 
 }  // namespace autofill