components/autofill: scoped_ptr -> unique_ptr

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>
@@ skipping 81 matching lines @@
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_ZIP));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_SORTING_CODE));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_COUNTRY));
   s->BindInt64(index++, profile.use_count());
   s->BindInt64(index++, profile.use_date().ToTimeT());
   s->BindInt64(index++, modification_date.ToTimeT());
   s->BindString(index++, profile.origin());
   s->BindString(index++, profile.language_code());
 }
 
-scoped_ptr<AutofillProfile> AutofillProfileFromStatement(
+std::unique_ptr<AutofillProfile> AutofillProfileFromStatement(
     const sql::Statement& s) {
-  scoped_ptr<AutofillProfile> profile(new AutofillProfile);
+  std::unique_ptr<AutofillProfile> profile(new AutofillProfile);
   int index = 0;
   profile->set_guid(s.ColumnString(index++));
   DCHECK(base::IsValidGUID(profile->guid()));
 
   profile->SetRawInfo(COMPANY_NAME, s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
                       s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_CITY, s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_STATE, s.ColumnString16(index++));
@@ skipping 44 matching lines @@
   if (encrypted_number_len) {
     std::string encrypted_number;
     encrypted_number.resize(encrypted_number_len);
     memcpy(&encrypted_number[0], s.ColumnBlob(column_index),
            encrypted_number_len);
     OSCrypt::DecryptString16(encrypted_number, &credit_card_number);
   }
   return credit_card_number;
 }
 
-scoped_ptr<CreditCard> CreditCardFromStatement(const sql::Statement& s) {
-  scoped_ptr<CreditCard> credit_card(new CreditCard);
+std::unique_ptr<CreditCard> CreditCardFromStatement(const sql::Statement& s) {
+  std::unique_ptr<CreditCard> credit_card(new CreditCard);
 
   int index = 0;
   credit_card->set_guid(s.ColumnString(index++));
   DCHECK(base::IsValidGUID(credit_card->guid()));
 
   credit_card->SetRawInfo(CREDIT_CARD_NAME_FULL, s.ColumnString16(index++));
   credit_card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(index++));
   credit_card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                           s.ColumnString16(index++));
   credit_card->SetRawInfo(CREDIT_CARD_NUMBER,
@@ skipping 686 matching lines @@
       " date_modified, origin, language_code)"
       "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)"));
   BindAutofillProfileToStatement(profile, Time::Now(), &s);
 
   if (!s.Run())
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
-scoped_ptr<AutofillProfile> AutofillTable::GetAutofillProfile(
+std::unique_ptr<AutofillProfile> AutofillTable::GetAutofillProfile(
     const std::string& guid) {
   DCHECK(base::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, company_name, street_address, dependent_locality, city,"
       " state, zipcode, sorting_code, country_code, use_count, use_date,"
       " date_modified, origin, language_code "
       "FROM autofill_profiles "
       "WHERE guid=?"));
   s.BindString(0, guid);
 
-  scoped_ptr<AutofillProfile> p;
+  std::unique_ptr<AutofillProfile> p;
   if (!s.Step())
     return p;
 
   p = AutofillProfileFromStatement(s);
 
   // Get associated name info.
   AddAutofillProfileNamesToProfile(db_, p.get());
 
   // 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) {
   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);
-    scoped_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
+    std::unique_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
     if (!profile)
       return false;
     profiles->push_back(profile.release());
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::GetServerProfiles(std::vector<AutofillProfile*>* profiles) {
   profiles->clear();
@@ skipping 13 matching lines @@
         "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;
-    scoped_ptr<AutofillProfile> profile(new AutofillProfile(
+    std::unique_ptr<AutofillProfile> profile(new AutofillProfile(
         AutofillProfile::SERVER_PROFILE, s.ColumnString(index++)));
     profile->set_use_count(s.ColumnInt64(index++));
     profile->set_use_date(Time::FromInternalValue(s.ColumnInt64(index++)));
 
     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,
@@ skipping 79 matching lines @@
 }
 
 bool AutofillTable::UpdateAutofillProfile(const AutofillProfile& profile) {
   DCHECK(base::IsValidGUID(profile.guid()));
 
   // Don't update anything until the trash has been emptied.  There may be
   // pending modifications to process.
   if (!IsAutofillProfilesTrashEmpty())
     return true;
 
-  scoped_ptr<AutofillProfile> old_profile = GetAutofillProfile(profile.guid());
+  std::unique_ptr<AutofillProfile> old_profile =
+      GetAutofillProfile(profile.guid());
   if (!old_profile)
     return false;
 
   bool update_modification_date = *old_profile != profile;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE autofill_profiles "
       "SET guid=?, company_name=?, street_address=?, dependent_locality=?, "
       "    city=?, state=?, zipcode=?, sorting_code=?, country_code=?, "
       "    use_count=?, use_date=?, date_modified=?, origin=?, language_code=? "
@@ skipping 72 matching lines @@
       "VALUES (?,?,?,?,?,?,?,?,?)"));
   BindCreditCardToStatement(credit_card, Time::Now(), &s);
 
   if (!s.Run())
     return false;
 
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return true;
 }
 
-scoped_ptr<CreditCard> AutofillTable::GetCreditCard(const std::string& guid) {
+std::unique_ptr<CreditCard> AutofillTable::GetCreditCard(
+    const std::string& guid) {
   DCHECK(base::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
              "card_number_encrypted, use_count, use_date, date_modified, "
              "origin "
       "FROM credit_cards "
       "WHERE guid = ?"));
   s.BindString(0, guid);
 
   if (!s.Step())
-    return scoped_ptr<CreditCard>();
+    return std::unique_ptr<CreditCard>();
 
   return CreditCardFromStatement(s);
 }
 
 bool AutofillTable::GetCreditCards(
     std::vector<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);
-    scoped_ptr<CreditCard> credit_card = GetCreditCard(guid);
+    std::unique_ptr<CreditCard> credit_card = GetCreditCard(guid);
     if (!credit_card)
       return false;
     credit_cards->push_back(credit_card.release());
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::GetServerCreditCards(
     std::vector<CreditCard*>* credit_cards) {
@@ skipping 226 matching lines @@
   address_metadata.Run();
   changed |= db_->GetLastChangeCount() > 0;
 
   transaction.Commit();
   return changed;
 }
 
 bool AutofillTable::UpdateCreditCard(const CreditCard& credit_card) {
   DCHECK(base::IsValidGUID(credit_card.guid()));
 
-  scoped_ptr<CreditCard> old_credit_card = GetCreditCard(credit_card.guid());
+  std::unique_ptr<CreditCard> old_credit_card =
+      GetCreditCard(credit_card.guid());
   if (!old_credit_card)
     return false;
 
   bool update_modification_date = *old_credit_card != credit_card;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE credit_cards "
       "SET guid=?, name_on_card=?, expiration_month=?,"
           "expiration_year=?, card_number_encrypted=?, use_count=?, use_date=?,"
           "date_modified=?, origin=?"
@@ skipping 114 matching lines @@
     return false;
 
   // Clear out the origins for the found Autofill profiles.
   for (const std::string& guid : profile_guids) {
     sql::Statement s_profile(db_->GetUniqueStatement(
         "UPDATE autofill_profiles SET origin='' WHERE guid=?"));
     s_profile.BindString(0, guid);
     if (!s_profile.Run())
       return false;
 
-    scoped_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
+    std::unique_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
     if (!profile)
       return false;
 
     profiles->push_back(profile.release());
   }
 
   // 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 < ?"));
@@ skipping 687 matching lines @@
     insert.BindString16(index++, profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
     insert.BindString(index++, profile.language_code());
     insert.Run();
     insert.Reset(true);
   }
 
   return transaction.Commit();
 }
 
 }  // namespace autofill