Remove stl_util's STLDeleteContainerPointers from autofill.

components/autofill/core/browser/personal_data_manager.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/personal_data_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <string>
 #include <utility>
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/timezone.h"
+#include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/address_i18n.h"
 #include "components/autofill/core/browser/autofill-inl.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_experiments.h"
 #include "components/autofill/core/browser/autofill_field.h"
@@ skipping 34 matching lines @@
   }
 
   bool operator()(const T& form_group) {
     return form_group.guid() == guid_;
   }
 
   bool operator()(const T* form_group) {
     return form_group->guid() == guid_;
   }
 
+  bool operator()(const std::unique_ptr<T>& form_group) {
+    return form_group->guid() == guid_;
+  }
+
  private:
   const std::string guid_;
 };
 
 template<typename T, typename C>
 typename C::const_iterator FindElementByGUID(const C& container,
                                              const std::string& guid) {
   return std::find_if(container.begin(),
                       container.end(),
                       FormGroupMatchesByGUIDFunctor<T>(guid));
@@ skipping 92 matching lines @@
 
   return profile->GetInfo(type, app_locale);
 }
 
 // Receives the loaded profiles from the web data service and stores them in
 // |*dest|. The pending handle is the address of the pending handle
 // corresponding to this request type. This function is used to save both
 // server and local profiles and credit cards.
 template <typename ValueType>
 void ReceiveLoadedDbValues(WebDataServiceBase::Handle h,
-                           const WDTypedResult* result,
+                           WDTypedResult* result,
                            WebDataServiceBase::Handle* pending_handle,
-                           ScopedVector<ValueType>* dest) {
+                           std::vector<std::unique_ptr<ValueType>>* dest) {
   DCHECK_EQ(*pending_handle, h);
   *pending_handle = 0;
 
-  const WDResult<std::vector<ValueType*>>* r =
-      static_cast<const WDResult<std::vector<ValueType*>>*>(result);
-
-  dest->clear();
-  for (ValueType* value : r->GetValue())
-    dest->push_back(value);
+  *dest = std::move(
+      static_cast<WDResult<std::vector<std::unique_ptr<ValueType>>>*>(result)
+          ->GetValue());
 }
 
 // A helper function for finding the maximum value in a string->int map.
 static bool CompareVotes(const std::pair<std::string, int>& a,
                          const std::pair<std::string, int>& b) {
   return a.second < b.second;
 }
 
 // Returns whether the |suggestion| is valid considering the
 // |field_contents_canon|, the |type| and |is_masked_server_card|. Assigns true
 // to |is_prefix_matched| if the |field_contents_canon| is a prefix to
 // |suggestion|, assigns false otherwise.
 bool IsValidSuggestionForFieldContents(base::string16 suggestion_canon,
                                        base::string16 field_contents_canon,
                                        const AutofillType& type,
                                        bool is_masked_server_card,
                                        bool* is_prefix_matched) {
   *is_prefix_matched = true;
 
   // Phones should do a substring match because they can be trimmed to remove
   // the first parts (e.g. country code or prefix). It is still considered a
   // prefix match in order to put it at the top of the suggestions.
   if ((type.group() == PHONE_HOME || type.group() == PHONE_BILLING) &&
       suggestion_canon.find(field_contents_canon) != base::string16::npos) {
     return true;
   }
 
   // For card number fields, suggest the card if:
   // - the number matches any part of the card, or
-  // - it's a masked card and there are 6 or fewers typed so far.
+  // - it's a masked card and there are 6 or fewer typed so far.
   if (type.GetStorableType() == CREDIT_CARD_NUMBER) {
     if (suggestion_canon.find(field_contents_canon) == base::string16::npos &&
         (!is_masked_server_card || field_contents_canon.size() >= 6)) {
       return false;
     }
     return true;
   }
 
   if (base::StartsWith(suggestion_canon, field_contents_canon,
                        base::CompareCase::SENSITIVE)) {
@@ skipping 89 matching lines @@
   // run, it is a NOP (other than checking the pref).
   ApplyProfileUseDatesFix();
 
   // This runs at most once per major version, tracked in syncable prefs. If it
   // has already run for this version, it's a NOP, other than checking the pref.
   ApplyDedupingRoutine();
 }
 
 void PersonalDataManager::OnWebDataServiceRequestDone(
     WebDataServiceBase::Handle h,
-    const WDTypedResult* result) {
+    std::unique_ptr<WDTypedResult> result) {
   DCHECK(pending_profiles_query_ || pending_server_profiles_query_ ||
          pending_creditcards_query_ || pending_server_creditcards_query_);
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 PersonalDataManager::OnWebDataServiceRequestDone"));
 
   if (!result) {
     // Error from the web database.
     if (h == pending_creditcards_query_)
       pending_creditcards_query_ = 0;
     else if (h == pending_profiles_query_)
       pending_profiles_query_ = 0;
     return;
   }
 
   switch (result->GetType()) {
     case AUTOFILL_PROFILES_RESULT:
       if (h == pending_profiles_query_) {
-        ReceiveLoadedDbValues(h, result, &pending_profiles_query_,
+        ReceiveLoadedDbValues(h, result.get(), &pending_profiles_query_,
                               &web_profiles_);
         LogProfileCount();  // This only logs local profiles.
       } else {
-        ReceiveLoadedDbValues(h, result, &pending_server_profiles_query_,
+        ReceiveLoadedDbValues(h, result.get(), &pending_server_profiles_query_,
                               &server_profiles_);
 
         if (!server_profiles_.empty()) {
           std::string account_id = signin_manager_->GetAuthenticatedAccountId();
           base::string16 email =
               base::UTF8ToUTF16(
                   account_tracker_->GetAccountInfo(account_id).email);
 
           // User may have signed out during the fulfillment of the web data
           // request, in which case there is no point updating
           // |server_profiles_| as it will be cleared.
           if (!email.empty()) {
-            for (AutofillProfile* profile : server_profiles_)
+            for (auto& profile : server_profiles_)
               profile->SetRawInfo(EMAIL_ADDRESS, email);
           }
         }
       }
       break;
     case AUTOFILL_CREDITCARDS_RESULT:
       if (h == pending_creditcards_query_) {
-        ReceiveLoadedDbValues(h, result, &pending_creditcards_query_,
+        ReceiveLoadedDbValues(h, result.get(), &pending_creditcards_query_,
                               &local_credit_cards_);
         LogLocalCreditCardCount();
       } else {
-        ReceiveLoadedDbValues(h, result, &pending_server_creditcards_query_,
+        ReceiveLoadedDbValues(h, result.get(),
+                              &pending_server_creditcards_query_,
                               &server_credit_cards_);
 
         // If the user has a saved unmasked server card and the experiment is
         // disabled, force mask all cards back to the unsaved state.
         if (!OfferStoreUnmaskedCards())
           ResetFullServerCards();
 
         LogServerCreditCardCounts();
       }
       break;
@@ skipping 202 matching lines @@
 
 void PersonalDataManager::UpdateServerCreditCard(
     const CreditCard& credit_card) {
   DCHECK_NE(CreditCard::LOCAL_CARD, credit_card.record_type());
 
   if (is_off_the_record_ || !database_.get())
     return;
 
   // Look up by server id, not GUID.
   const CreditCard* existing_credit_card = nullptr;
-  for (const auto* server_card : server_credit_cards_) {
+  for (const auto& server_card : server_credit_cards_) {
     if (credit_card.server_id() == server_card->server_id()) {
-      existing_credit_card = server_card;
+      existing_credit_card = server_card.get();
       break;
     }
   }
   if (!existing_credit_card)
     return;
 
   DCHECK_NE(existing_credit_card->record_type(), credit_card.record_type());
   DCHECK_EQ(existing_credit_card->Label(), credit_card.Label());
   if (existing_credit_card->record_type() == CreditCard::MASKED_SERVER_CARD) {
     database_->UnmaskServerCreditCard(credit_card,
                                       credit_card.number());
   } else {
     database_->MaskServerCreditCard(credit_card.server_id());
   }
 
   Refresh();
 }
 
 void PersonalDataManager::UpdateServerCardBillingAddress(
     const CreditCard& credit_card) {
   DCHECK_NE(CreditCard::LOCAL_CARD, credit_card.record_type());
 
   if (!database_.get())
     return;
 
   CreditCard* existing_credit_card = nullptr;
-  for (auto* server_card : server_credit_cards_) {
+  for (auto& server_card : server_credit_cards_) {
     if (credit_card.server_id() == server_card->server_id()) {
-      existing_credit_card = server_card;
+      existing_credit_card = server_card.get();
       break;
     }
   }
   if (!existing_credit_card
       || existing_credit_card->billing_address_id() ==
           credit_card.billing_address_id()) {
     return;
   }
 
   existing_credit_card->set_billing_address_id(
       credit_card.billing_address_id());
   database_->UpdateServerCardBillingAddress(*existing_credit_card);
 
   Refresh();
 }
 
 void PersonalDataManager::ResetFullServerCard(const std::string& guid) {
-  for (const CreditCard* card : server_credit_cards_) {
+  for (const auto& card : server_credit_cards_) {
     if (card->guid() == guid) {
       DCHECK_EQ(card->record_type(), CreditCard::FULL_SERVER_CARD);
       CreditCard card_copy = *card;
       card_copy.set_record_type(CreditCard::MASKED_SERVER_CARD);
       card_copy.SetNumber(card->LastFourDigits());
       UpdateServerCreditCard(card_copy);
       break;
     }
   }
 }
 
 void PersonalDataManager::ResetFullServerCards() {
-  for (const CreditCard* card : server_credit_cards_) {
+  for (const auto& card : server_credit_cards_) {
     if (card->record_type() == CreditCard::FULL_SERVER_CARD) {
       CreditCard card_copy = *card;
       card_copy.set_record_type(CreditCard::MASKED_SERVER_CARD);
       card_copy.SetNumber(card->LastFourDigits());
       UpdateServerCreditCard(card_copy);
     }
   }
 }
 
 void PersonalDataManager::ClearAllServerData() {
   // This could theoretically be called before we get the data back from the
   // database on startup, and it could get called when the wallet pref is
   // off (meaning this class won't even query for the server data) so don't
   // check the server_credit_cards_/profiles_ before posting to the DB.
   database_->ClearAllServerData();
 
   // The above call will eventually clear our server data by notifying us
   // that the data changed and then this class will re-fetch. Preemptively
   // clear so that tests can synchronously verify that this data was cleared.
   server_credit_cards_.clear();
   server_profiles_.clear();
 }
 
 void PersonalDataManager::AddServerCreditCardForTest(
     std::unique_ptr<CreditCard> credit_card) {
-  server_credit_cards_.push_back(credit_card.release());
+  server_credit_cards_.push_back(std::move(credit_card));
 }
 
 void PersonalDataManager::RemoveByGUID(const std::string& guid) {
   if (is_off_the_record_)
     return;
 
   bool is_credit_card = FindByGUID<CreditCard>(local_credit_cards_, guid);
   bool is_profile = !is_credit_card &&
       FindByGUID<AutofillProfile>(web_profiles_, guid);
   if (!is_credit_card && !is_profile)
@@ skipping 27 matching lines @@
 }
 
 bool PersonalDataManager::IsDataLoaded() const {
   return is_data_loaded_;
 }
 
 const std::vector<AutofillProfile*>& PersonalDataManager::GetProfiles() const {
   return GetProfiles(false);
 }
 
-const std::vector<AutofillProfile*>& PersonalDataManager::web_profiles() const {
-  return web_profiles_.get();
+std::vector<AutofillProfile*> PersonalDataManager::web_profiles() const {
+  std::vector<AutofillProfile*> result;
+  for (const auto& profile : web_profiles_)
+    result.push_back(profile.get());
+  return result;
 }
 
-const std::vector<CreditCard*>& PersonalDataManager::GetLocalCreditCards()
-    const {
-  return local_credit_cards_.get();
+std::vector<CreditCard*> PersonalDataManager::GetLocalCreditCards() const {
+  std::vector<CreditCard*> result;
+  for (const auto& card : local_credit_cards_)
+    result.push_back(card.get());
+  return result;
 }
 
 const std::vector<CreditCard*>& PersonalDataManager::GetCreditCards() const {
   credit_cards_.clear();
-  credit_cards_.insert(credit_cards_.end(), local_credit_cards_.begin(),
-                       local_credit_cards_.end());
+  for (const auto& card : local_credit_cards_)
+    credit_cards_.push_back(card.get());
   if (pref_service_->GetBoolean(prefs::kAutofillWalletImportEnabled)) {
-    credit_cards_.insert(credit_cards_.end(), server_credit_cards_.begin(),
-                         server_credit_cards_.end());
+    for (const auto& card : server_credit_cards_)
+      credit_cards_.push_back(card.get());
   }
   return credit_cards_;
 }
 
 bool PersonalDataManager::HasServerData() const {
   return !server_credit_cards_.empty() || !server_profiles_.empty();
 }
 
 void PersonalDataManager::Refresh() {
   LoadProfiles();
@@ skipping 195 matching lines @@
   if (profile.IsPresentButInvalid(ADDRESS_HOME_ZIP))
     return false;
 
   return true;
 }
 
 // TODO(crbug.com/618448): Refactor MergeProfile to not depend on class
 // variables.
 std::string PersonalDataManager::MergeProfile(
     const AutofillProfile& new_profile,
-    std::vector<AutofillProfile*> existing_profiles,
+    std::vector<std::unique_ptr<AutofillProfile>>* existing_profiles,
     const std::string& app_locale,
     std::vector<AutofillProfile>* merged_profiles) {
   merged_profiles->clear();
 
   // Sort the existing profiles in decreasing order of frecency, so the "best"
   // profiles are checked first. Put the verified profiles last so the non
   // verified profiles get deduped among themselves before reaching the verified
   // profiles.
   // TODO(crbug.com/620521): Remove the check for verified from the sort.
   base::Time comparison_time = base::Time::Now();
-  std::sort(existing_profiles.begin(), existing_profiles.end(),
-            [comparison_time](const AutofillDataModel* a,
-                              const AutofillDataModel* b) {
+  std::sort(existing_profiles->begin(), existing_profiles->end(),
+            [comparison_time](const std::unique_ptr<AutofillProfile>& a,
+                              const std::unique_ptr<AutofillProfile>& b) {
               if (a->IsVerified() != b->IsVerified())
                 return !a->IsVerified();
-              return a->CompareFrecency(b, comparison_time);
+              return a->CompareFrecency(b.get(), comparison_time);
             });
 
   // Set to true if |existing_profiles| already contains an equivalent profile.
   bool matching_profile_found = false;
   std::string guid = new_profile.guid();
 
   // If we have already saved this address, merge in any missing values.
   // Only merge with the first match.
   AutofillProfileComparator comparator(app_locale);
-  for (AutofillProfile* existing_profile : existing_profiles) {
+  for (const auto& existing_profile : *existing_profiles) {
     if (!matching_profile_found &&
         comparator.AreMergeable(new_profile, *existing_profile) &&
         existing_profile->SaveAdditionalInfo(new_profile, app_locale)) {
       // Unverified profiles should always be updated with the newer data,
       // whereas verified profiles should only ever be overwritten by verified
       // data.  If an automatically aggregated profile would overwrite a
       // verified profile, just drop it.
       matching_profile_found = true;
       guid = existing_profile->guid();
 
@@ skipping 97 matching lines @@
   // Remove empty profiles from input.
   profiles->erase(std::remove_if(profiles->begin(), profiles->end(),
                                  IsEmptyFunctor<AutofillProfile>(app_locale_)),
                   profiles->end());
 
   if (!database_.get())
     return;
 
   // Any profiles that are not in the new profile list should be removed from
   // the web database.
-  for (const AutofillProfile* it : web_profiles_) {
+  for (const auto& it : web_profiles_) {
     if (!FindByGUID<AutofillProfile>(*profiles, it->guid()))
       database_->RemoveAutofillProfile(it->guid());
   }
 
   // Update the web database with the existing profiles.
   for (const AutofillProfile& it : *profiles) {
     if (FindByGUID<AutofillProfile>(web_profiles_, it.guid()))
       database_->UpdateAutofillProfile(it);
   }
 
   // Add the new profiles to the web database.  Don't add a duplicate.
   for (const AutofillProfile& it : *profiles) {
     if (!FindByGUID<AutofillProfile>(web_profiles_, it.guid()) &&
         !FindByContents(web_profiles_, it))
       database_->AddAutofillProfile(it);
   }
 
   // Copy in the new profiles.
   web_profiles_.clear();
   for (const AutofillProfile& it : *profiles) {
-    web_profiles_.push_back(new AutofillProfile(it));
+    web_profiles_.push_back(base::MakeUnique<AutofillProfile>(it));
   }
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::SetCreditCards(
     std::vector<CreditCard>* credit_cards) {
   if (is_off_the_record_)
     return;
 
   // Remove empty credit cards from input.
   credit_cards->erase(std::remove_if(credit_cards->begin(), credit_cards->end(),
                                      IsEmptyFunctor<CreditCard>(app_locale_)),
                       credit_cards->end());
 
   if (!database_.get())
     return;
 
   // Any credit cards that are not in the new credit card list should be
   // removed.
-  for (const CreditCard* card : local_credit_cards_) {
+  for (const auto& card : local_credit_cards_) {
     if (!FindByGUID<CreditCard>(*credit_cards, card->guid()))
       database_->RemoveCreditCard(card->guid());
   }
 
   // Update the web database with the existing credit cards.
   for (const CreditCard& card : *credit_cards) {
     if (FindByGUID<CreditCard>(local_credit_cards_, card.guid()))
       database_->UpdateCreditCard(card);
   }
 
   // Add the new credit cards to the web database.  Don't add a duplicate.
   for (const CreditCard& card : *credit_cards) {
     if (!FindByGUID<CreditCard>(local_credit_cards_, card.guid()) &&
         !FindByContents(local_credit_cards_, card))
       database_->AddCreditCard(card);
   }
 
   // Copy in the new credit cards.
   local_credit_cards_.clear();
   for (const CreditCard& card : *credit_cards)
-    local_credit_cards_.push_back(new CreditCard(card));
+    local_credit_cards_.push_back(base::MakeUnique<CreditCard>(card));
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::LoadProfiles() {
   if (!database_.get()) {
     NOTREACHED();
     return;
   }
@@ skipping 30 matching lines @@
   *handle = 0;
 }
 
 std::string PersonalDataManager::SaveImportedProfile(
     const AutofillProfile& imported_profile) {
   if (is_off_the_record_)
     return std::string();
 
   // Don't save a web profile if the data in the profile is a subset of a
   // server profile, but do record the fact that it was used.
-  for (const AutofillProfile* profile : server_profiles_) {
+  for (const auto& profile : server_profiles_) {
     if (imported_profile.IsSubsetOf(*profile, app_locale_)) {
       RecordUseOf(*profile);
       return profile->guid();
     }
   }
 
   std::vector<AutofillProfile> profiles;
-  std::string guid = MergeProfile(imported_profile, web_profiles_.get(),
-                                  app_locale_, &profiles);
+  std::string guid =
+      MergeProfile(imported_profile, &web_profiles_, app_locale_, &profiles);
   SetProfiles(&profiles);
   return guid;
 }
 
 void PersonalDataManager::NotifyPersonalDataChanged() {
   for (PersonalDataManagerObserver& observer : observers_)
     observer.OnPersonalDataChanged();
 }
 
 std::string PersonalDataManager::SaveImportedCreditCard(
     const CreditCard& imported_card) {
   DCHECK(!imported_card.number().empty());
   if (is_off_the_record_)
     return std::string();
 
   // Set to true if |imported_card| is merged into the credit card list.
   bool merged = false;
 
   std::string guid = imported_card.guid();
   std::vector<CreditCard> credit_cards;
-  for (CreditCard* card : local_credit_cards_) {
+  for (auto& card : local_credit_cards_) {
     // If |imported_card| has not yet been merged, check whether it should be
     // with the current |card|.
     if (!merged && card->UpdateFromImportedCard(imported_card, app_locale_)) {
       guid = card->guid();
       merged = true;
     }
 
     credit_cards.push_back(*card);
   }
 
@@ skipping 14 matching lines @@
 void PersonalDataManager::LogLocalCreditCardCount() const {
   if (!has_logged_local_credit_card_count_) {
     AutofillMetrics::LogStoredLocalCreditCardCount(local_credit_cards_.size());
     has_logged_local_credit_card_count_ = true;
   }
 }
 
 void PersonalDataManager::LogServerCreditCardCounts() const {
   if (!has_logged_server_credit_card_counts_) {
     size_t unmasked_cards = 0, masked_cards = 0;
-    for (CreditCard* card : server_credit_cards_) {
+    for (const auto& card : server_credit_cards_) {
       if (card->record_type() == CreditCard::MASKED_SERVER_CARD) {
         masked_cards++;
       } else if (card->record_type() == CreditCard::FULL_SERVER_CARD) {
         unmasked_cards++;
       }
     }
     AutofillMetrics::LogStoredServerCreditCardCounts(masked_cards,
                                                      unmasked_cards);
     has_logged_server_credit_card_counts_ = true;
   }
@@ skipping 213 matching lines @@
   // Reject the credit card if we did not detect enough filled credit card
   // fields (such as valid number, month, year).
   if (!candidate_credit_card.IsValid())
     return false;
 
   // Attempt to merge with an existing credit card. Don't present a prompt if we
   // have already saved this card number, unless |should_return_local_card| is
   // true which indicates that upload is enabled. In this case, it's useful to
   // present the upload prompt to the user to promote the card from a local card
   // to a synced server card.
-  for (const CreditCard* card : local_credit_cards_) {
+  for (const auto& card : local_credit_cards_) {
     // Make a local copy so that the data in |local_credit_cards_| isn't
     // modified directly by the UpdateFromImportedCard() call.
     CreditCard card_copy(*card);
     if (card_copy.UpdateFromImportedCard(candidate_credit_card,
                                          app_locale_)) {
       UpdateCreditCard(card_copy);
       // If we should not return the local card, return that we merged it,
       // without setting |imported_credit_card|.
       if (!should_return_local_card)
         return true;
 
       break;
     }
   }
 
   // Also don't offer to save if we already have this stored as a server card.
   // We only check the number because if the new card has the same number as the
   // server card, upload is guaranteed to fail. There's no mechanism for entries
   // with the same number but different names or expiration dates as there is
   // for local cards.
-  for (const CreditCard* card : server_credit_cards_) {
+  for (const auto& card : server_credit_cards_) {
     if (candidate_credit_card.HasSameNumberAs(*card))
       return false;
   }
 
   imported_credit_card->reset(new CreditCard(candidate_credit_card));
   return true;
 }
 
 const std::vector<AutofillProfile*>& PersonalDataManager::GetProfiles(
     bool record_metrics) const {
   profiles_.clear();
-  profiles_.insert(profiles_.end(), web_profiles().begin(),
-                   web_profiles().end());
+  for (const auto& profile : web_profiles_)
+    profiles_.push_back(profile.get());
   if (pref_service_->GetBoolean(prefs::kAutofillWalletImportEnabled)) {
-    profiles_.insert(
-        profiles_.end(), server_profiles_.begin(), server_profiles_.end());
+    for (const auto& profile : server_profiles_)
+      profiles_.push_back(profile.get());
   }
   return profiles_;
 }
 
 std::vector<Suggestion> PersonalDataManager::GetSuggestionsForCards(
     const AutofillType& type,
     const base::string16& field_contents,
     const std::vector<CreditCard*>& cards_to_suggest) const {
   std::vector<Suggestion> suggestions;
   base::string16 field_contents_lower = base::i18n::ToLower(field_contents);
@@ skipping 82 matching lines @@
 }
 
 bool PersonalDataManager::ApplyDedupingRoutine() {
   if (!is_autofill_profile_dedupe_pending_)
     return false;
 
   DCHECK(IsAutofillProfileCleanupEnabled());
   is_autofill_profile_dedupe_pending_ = false;
 
   // No need to de-duplicate if there are less than two profiles.
-  if (web_profiles_.get().size() < 2) {
+  if (web_profiles_.size() < 2) {
     DVLOG(1) << "Autofill profile de-duplication not needed.";
     return false;
   }
 
   // Check if de-duplication has already been performed this major version.
   int current_major_version = atoi(version_info::GetVersionNumber().c_str());
   if (pref_service_->GetInteger(prefs::kAutofillLastVersionDeduped) >=
       current_major_version) {
     DVLOG(1)
         << "Autofill profile de-duplication already performed for this version";
     return false;
   }
 
   DVLOG(1) << "Starting autofill profile de-duplication.";
-  std::vector<AutofillProfile*> existing_profiles = web_profiles_.get();
   std::unordered_set<AutofillProfile*> profiles_to_delete;
-  profiles_to_delete.reserve(existing_profiles.size());
+  profiles_to_delete.reserve(web_profiles_.size());
 
-  DedupeProfiles(&existing_profiles, &profiles_to_delete);
+  DedupeProfiles(&web_profiles_, &profiles_to_delete);
 
   // Apply the changes to the database.
-  for (AutofillProfile* profile : existing_profiles) {
+  for (const auto& profile : web_profiles_) {
     // If the profile was set to be deleted, remove it from the database.
-    if (profiles_to_delete.count(profile)) {
+    if (profiles_to_delete.count(profile.get())) {
       database_->RemoveAutofillProfile(profile->guid());
     } else {
       // Otherwise, update the profile in the database.
       database_->UpdateAutofillProfile(*profile);
     }
   }
 
   // Set the pref to the current major version.
   pref_service_->SetInteger(prefs::kAutofillLastVersionDeduped,
                             current_major_version);
 
   // Refresh the local cache and send notifications to observers.
   Refresh();
 
   return true;
 }
 
 void PersonalDataManager::DedupeProfiles(
-    std::vector<AutofillProfile*>* existing_profiles,
+    std::vector<std::unique_ptr<AutofillProfile>>* existing_profiles,
     std::unordered_set<AutofillProfile*>* profiles_to_delete) {
   AutofillMetrics::LogNumberOfProfilesConsideredForDedupe(
       existing_profiles->size());
 
   // Sort the profiles by frecency with all the verified profiles at the end.
   // That way the most relevant profiles will get merged into the less relevant
   // profiles, which keeps the syntax of the most relevant profiles data.
   // Verified profiles are put at the end because they do not merge into other
   // profiles, so the loop can be stopped when we reach those. However they need
   // to be in the vector because an unverified profile trying to merge into a
   // similar verified profile will be discarded.
   base::Time comparison_time = base::Time::Now();
   std::sort(existing_profiles->begin(), existing_profiles->end(),
-            [comparison_time](const AutofillDataModel* a,
-                              const AutofillDataModel* b) {
+            [comparison_time](const std::unique_ptr<AutofillProfile>& a,
+                              const std::unique_ptr<AutofillProfile>& b) {
               if (a->IsVerified() != b->IsVerified())
                 return !a->IsVerified();
-              return a->CompareFrecency(b, comparison_time);
+              return a->CompareFrecency(b.get(), comparison_time);
             });
 
   AutofillProfileComparator comparator(app_locale_);
 
   for (size_t i = 0; i < existing_profiles->size(); ++i) {
-    AutofillProfile* profile_to_merge = (*existing_profiles)[i];
+    AutofillProfile* profile_to_merge = (*existing_profiles)[i].get();
 
     // If the profile was set to be deleted, skip it. It has already been
     // merged into another profile.
     if (profiles_to_delete->count(profile_to_merge))
       continue;
 
     // If we have reached the verified profiles, stop trying to merge. Verified
     // profiles do not get merged.
     if (profile_to_merge->IsVerified())
       break;
 
     // If we have not reached the last profile, try to merge |profile_to_merge|
     // with all the less relevant |existing_profiles|.
     for (size_t j = i + 1; j < existing_profiles->size(); ++j) {
-      AutofillProfile* existing_profile = (*existing_profiles)[j];
+      AutofillProfile* existing_profile = (*existing_profiles)[j].get();
 
       // Don't try to merge a profile that was already set for deletion.
       if (profiles_to_delete->count(existing_profile))
         continue;
 
       // Move on if the profiles are not mergeable.
       if (!comparator.AreMergeable(*existing_profile, *profile_to_merge))
         continue;
 
       // The profiles are found to be mergeable. Attempt to update the existing
       // profile. This returns true if the merge was successful, or if the
       // merge would have been successful but the existing profile IsVerified()
       // and will not accept updates from profile_to_merge.
       if (existing_profile->SaveAdditionalInfo(*profile_to_merge,
                                                app_locale_)) {
         // Since |profile_to_merge| was a duplicate of |existing_profile|
-        // and was merged sucessfully, it can now be deleted.
+        // and was merged successfully, it can now be deleted.
         profiles_to_delete->insert(profile_to_merge);
 
         // Now try to merge the new resulting profile with the rest of the
         // existing profiles.
         profile_to_merge = existing_profile;
 
         // Verified profiles do not get merged. Save some time by not
         // trying.
         if (profile_to_merge->IsVerified())
           break;
       }
     }
   }
   AutofillMetrics::LogNumberOfProfilesRemovedDuringDedupe(
       profiles_to_delete->size());
 }
 
 }  // namespace autofill