Remove stl_util's STLDeleteContainerPointers from autofill.

components/autofill/core/browser/autofill_manager_unittest.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/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
@@ skipping 96 matching lines @@
 
   using PersonalDataManager::set_database;
   using PersonalDataManager::SetPrefService;
 
   int num_times_save_imported_profile_called() {
     return num_times_save_imported_profile_called_;
   }
 
   std::string SaveImportedProfile(const AutofillProfile& profile) override {
     num_times_save_imported_profile_called_++;
-    AutofillProfile* imported_profile = new AutofillProfile(profile);
-    AddProfile(imported_profile);
+    AddProfile(base::MakeUnique<AutofillProfile>(profile));
     return profile.guid();
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
     for (AutofillProfile* profile : GetProfiles()) {
       if (!profile->guid().compare(guid))
         return profile;
     }
     return NULL;
   }
 
   CreditCard* GetCreditCardWithGUID(const char* guid) {
     for (CreditCard* card : GetCreditCards()) {
       if (!card->guid().compare(guid))
         return card;
     }
     return NULL;
   }
 
-  void AddProfile(AutofillProfile* profile) {
+  void AddProfile(std::unique_ptr<AutofillProfile> profile) {
     profile->set_modification_date(base::Time::Now());
-    web_profiles_.push_back(profile);
+    web_profiles_.push_back(std::move(profile));
   }
 
-  void AddCreditCard(CreditCard* credit_card) {
+  void AddCreditCard(std::unique_ptr<CreditCard> credit_card) {
     credit_card->set_modification_date(base::Time::Now());
-    local_credit_cards_.push_back(credit_card);
+    local_credit_cards_.push_back(std::move(credit_card));
   }
 
   void RecordUseOf(const AutofillDataModel& data_model) override {
     CreditCard* credit_card = GetCreditCardWithGUID(data_model.guid().c_str());
     if (credit_card)
       credit_card->RecordAndLogUse();
 
     AutofillProfile* profile = GetProfileWithGUID(data_model.guid().c_str());
     if (profile)
       profile->RecordAndLogUse();
   }
 
   void RemoveByGUID(const std::string& guid) override {
     CreditCard* credit_card = GetCreditCardWithGUID(guid.c_str());
     if (credit_card) {
       local_credit_cards_.erase(
-          std::find(local_credit_cards_.begin(), local_credit_cards_.end(),
-                    credit_card));
+          std::find_if(local_credit_cards_.begin(), local_credit_cards_.end(),
+                       [credit_card](const std::unique_ptr<CreditCard>& ptr) {
+                         return ptr.get() == credit_card;
+                       }));
     }
 
     AutofillProfile* profile = GetProfileWithGUID(guid.c_str());
     if (profile) {
       web_profiles_.erase(
-          std::find(web_profiles_.begin(), web_profiles_.end(), profile));
+          std::find_if(web_profiles_.begin(), web_profiles_.end(),
+                       [profile](const std::unique_ptr<AutofillProfile>& ptr) {
+                         return ptr.get() == profile;
+                       }));
     }
   }
 
   void ClearAutofillProfiles() {
     web_profiles_.clear();
   }
 
   void ClearCreditCards() {
     local_credit_cards_.clear();
   }
 
   // Create Elvis card with whitespace in the credit card number.
   void CreateTestCreditCardWithWhitespace() {
     ClearCreditCards();
-    CreditCard* credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "Elvis Presley",
+    std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "Elvis Presley",
                             "4234 5678 9012 3456",  // Visa
                             "04", "2999");
     credit_card->set_guid("00000000-0000-0000-0000-000000000008");
-    local_credit_cards_.push_back(credit_card);
+    local_credit_cards_.push_back(std::move(credit_card));
   }
 
   // Create Elvis card with separator characters in the credit card number.
   void CreateTestCreditCardWithSeparators() {
     ClearCreditCards();
-    CreditCard* credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "Elvis Presley",
+    std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "Elvis Presley",
                             "4234-5678-9012-3456",  // Visa
                             "04", "2999");
     credit_card->set_guid("00000000-0000-0000-0000-000000000009");
-    local_credit_cards_.push_back(credit_card);
+    local_credit_cards_.push_back(std::move(credit_card));
   }
 
   void CreateTestCreditCardsYearAndMonth(const char* year, const char* month) {
     ClearCreditCards();
-    CreditCard* credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "Miku Hatsune",
+    std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "Miku Hatsune",
                             "4234567890654321",  // Visa
                             month, year);
     credit_card->set_guid("00000000-0000-0000-0000-000000000007");
-    local_credit_cards_.push_back(credit_card);
+    local_credit_cards_.push_back(std::move(credit_card));
   }
 
   void CreateTestExpiredCreditCard() {
     ClearCreditCards();
-    CreditCard* credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "Homer Simpson",
+    std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "Homer Simpson",
                             "4234567890654321",  // Visa
                             "05", "2000");
     credit_card->set_guid("00000000-0000-0000-0000-000000000009");
-    local_credit_cards_.push_back(credit_card);
+    local_credit_cards_.push_back(std::move(credit_card));
   }
 
  private:
-  void CreateTestAutofillProfiles(ScopedVector<AutofillProfile>* profiles) {
-    AutofillProfile* profile = new AutofillProfile;
-    test::SetProfileInfo(profile, "Elvis", "Aaron",
-                         "Presley", "theking@gmail.com", "RCA",
-                         "3734 Elvis Presley Blvd.", "Apt. 10",
-                         "Memphis", "Tennessee", "38116", "US",
+  void CreateTestAutofillProfiles(
+      std::vector<std::unique_ptr<AutofillProfile>>* profiles) {
+    std::unique_ptr<AutofillProfile> profile =
+        base::MakeUnique<AutofillProfile>();
+    test::SetProfileInfo(profile.get(), "Elvis", "Aaron", "Presley",
+                         "theking@gmail.com", "RCA", "3734 Elvis Presley Blvd.",
+                         "Apt. 10", "Memphis", "Tennessee", "38116", "US",
                          "12345678901");
     profile->set_guid("00000000-0000-0000-0000-000000000001");
-    profiles->push_back(profile);
-    profile = new AutofillProfile;
-    test::SetProfileInfo(profile, "Charles", "Hardin",
-                         "Holley", "buddy@gmail.com", "Decca",
-                         "123 Apple St.", "unit 6", "Lubbock",
-                         "Texas", "79401", "US", "23456789012");
+    profiles->push_back(std::move(profile));
+    profile = base::MakeUnique<AutofillProfile>();
+    test::SetProfileInfo(profile.get(), "Charles", "Hardin", "Holley",
+                         "buddy@gmail.com", "Decca", "123 Apple St.", "unit 6",
+                         "Lubbock", "Texas", "79401", "US", "23456789012");
     profile->set_guid("00000000-0000-0000-0000-000000000002");
-    profiles->push_back(profile);
-    profile = new AutofillProfile;
-    test::SetProfileInfo(
-        profile, "", "", "", "", "", "", "", "", "", "", "", "");
+    profiles->push_back(std::move(profile));
+    profile = base::MakeUnique<AutofillProfile>();
+    test::SetProfileInfo(profile.get(), "", "", "", "", "", "", "", "", "", "",
+                         "", "");
     profile->set_guid("00000000-0000-0000-0000-000000000003");
-    profiles->push_back(profile);
+    profiles->push_back(std::move(profile));
   }
 
-  void CreateTestCreditCards(ScopedVector<CreditCard>* credit_cards) {
-    CreditCard* credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "Elvis Presley",
+  void CreateTestCreditCards(
+      std::vector<std::unique_ptr<CreditCard>>* credit_cards) {
+    std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "Elvis Presley",
                             "4234567890123456",  // Visa
                             "04", "2999");
     credit_card->set_guid("00000000-0000-0000-0000-000000000004");
     credit_card->set_use_count(10);
     credit_card->set_use_date(base::Time::Now() - base::TimeDelta::FromDays(5));
-    credit_cards->push_back(credit_card);
+    credit_cards->push_back(std::move(credit_card));
 
-    credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "Buddy Holly",
+    credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "Buddy Holly",
                             "5187654321098765",  // Mastercard
                             "10", "2998");
     credit_card->set_guid("00000000-0000-0000-0000-000000000005");
     credit_card->set_use_count(5);
     credit_card->set_use_date(base::Time::Now() - base::TimeDelta::FromDays(4));
-    credit_cards->push_back(credit_card);
+    credit_cards->push_back(std::move(credit_card));
 
-    credit_card = new CreditCard;
-    test::SetCreditCardInfo(credit_card, "", "", "", "");
+    credit_card = base::MakeUnique<CreditCard>();
+    test::SetCreditCardInfo(credit_card.get(), "", "", "", "");
     credit_card->set_guid("00000000-0000-0000-0000-000000000006");
-    credit_cards->push_back(credit_card);
+    credit_cards->push_back(std::move(credit_card));
   }
 
   size_t num_times_save_imported_profile_called_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
 };
 
 class TestAutofillDownloadManager : public AutofillDownloadManager {
  public:
   TestAutofillDownloadManager(AutofillDriver* driver,
@@ skipping 287 matching lines @@
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
     return personal_data_->GetProfileWithGUID(guid);
   }
 
   CreditCard* GetCreditCardWithGUID(const char* guid) {
     return personal_data_->GetCreditCardWithGUID(guid);
   }
 
-  void AddProfile(AutofillProfile* profile) {
-    personal_data_->AddProfile(profile);
+  void AddProfile(std::unique_ptr<AutofillProfile> profile) {
+    personal_data_->AddProfile(std::move(profile));
   }
 
-  void AddCreditCard(CreditCard* credit_card) {
-    personal_data_->AddCreditCard(credit_card);
+  void AddCreditCard(std::unique_ptr<CreditCard> credit_card) {
+    personal_data_->AddCreditCard(std::move(credit_card));
   }
 
   int GetPackedCreditCardID(int credit_card_id) {
     std::string credit_card_guid =
         base::StringPrintf("00000000-0000-0000-0000-%012d", credit_card_id);
 
     return MakeFrontendID(credit_card_guid, std::string());
   }
 
-  void AddSeenForm(FormStructure* form) {
-    form_structures()->push_back(form);
+  void AddSeenForm(std::unique_ptr<FormStructure> form) {
+    form_structures()->push_back(std::move(form));
   }
 
   void ClearFormStructures() {
     form_structures()->clear();
   }
 
  private:
   void OnDidUploadCard(AutofillClient::PaymentsRpcResult result) override {
     credit_card_was_uploaded_ = true;
   };
@@ skipping 645 matching lines @@
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // First name is already autofilled which will make the section appear as
   // "already autofilled".
   form.fields[0].is_autofilled = true;
 
   // Two profiles have the same last name, and the third shares the same first
   // letter for last name.
-  AutofillProfile* profile1 = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile1 =
+      base::MakeUnique<AutofillProfile>();
   profile1->set_guid("00000000-0000-0000-0000-000000000103");
   profile1->SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Robin"), "en-US");
   profile1->SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Grimes"), "en-US");
   profile1->SetInfo(AutofillType(ADDRESS_HOME_LINE1),
                     ASCIIToUTF16("1234 Smith Blvd."), "en-US");
-  autofill_manager_->AddProfile(profile1);
+  autofill_manager_->AddProfile(std::move(profile1));
 
-  AutofillProfile* profile2 = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile2 =
+      base::MakeUnique<AutofillProfile>();
   profile2->set_guid("00000000-0000-0000-0000-000000000124");
   profile2->SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Carl"), "en-US");
   profile2->SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Grimes"), "en-US");
   profile2->SetInfo(AutofillType(ADDRESS_HOME_LINE1),
                     ASCIIToUTF16("1234 Smith Blvd."), "en-US");
-  autofill_manager_->AddProfile(profile2);
+  autofill_manager_->AddProfile(std::move(profile2));
 
-  AutofillProfile* profile3 = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile3 =
+      base::MakeUnique<AutofillProfile>();
   profile3->set_guid("00000000-0000-0000-0000-000000000126");
   profile3->SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Aaron"), "en-US");
   profile3->SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Googler"), "en-US");
   profile3->SetInfo(AutofillType(ADDRESS_HOME_LINE1),
                     ASCIIToUTF16("1600 Amphitheater pkwy"), "en-US");
-  autofill_manager_->AddProfile(profile3);
+  autofill_manager_->AddProfile(std::move(profile3));
 
   FormFieldData field;
   test::CreateTestFormField("Last Name", "lastname", "G", "text", &field);
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate. No labels,
   // with duplicate values "Grimes" merged.
   external_delegate_->CheckSuggestions(
       kDefaultPageID, Suggestion("Googler", "" /* no label */, "", 1),
       Suggestion("Grimes", "" /* no label */, "", 2));
@@ skipping 49 matching lines @@
 
 // Test that we cull duplicate profile suggestions.
 TEST_F(AutofillManagerTest, GetProfileSuggestions_WithDuplicates) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Add a duplicate profile.
-  AutofillProfile* duplicate_profile =
-      new AutofillProfile(
-          *(autofill_manager_->GetProfileWithGUID(
-              "00000000-0000-0000-0000-000000000001")));
-  autofill_manager_->AddProfile(duplicate_profile);
+  std::unique_ptr<AutofillProfile> duplicate_profile =
+      base::MakeUnique<AutofillProfile>(*(autofill_manager_->GetProfileWithGUID(
+          "00000000-0000-0000-0000-000000000001")));
+  autofill_manager_->AddProfile(std::move(duplicate_profile));
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
       kDefaultPageID, Suggestion("Charles", "123 Apple St.", "", 1),
       Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 2));
 }
 
@@ skipping 84 matching lines @@
       Suggestion("MasterCard\xC2\xA0\xE2\x8B\xAF"
                  "8765",
                  "10/98", kMasterCard,
                  autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return all credit card profile suggestions when the triggering
 // field has stop characters in it and some input.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_StopCharsWithInput) {
   // Add a credit card with particular numbers that we will attempt to recall.
-  CreditCard* credit_card = new CreditCard;
-  test::SetCreditCardInfo(credit_card, "John Smith",
+  std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+  test::SetCreditCardInfo(credit_card.get(), "John Smith",
                           "5255667890123123",  // Mastercard
                           "08", "2017");
   credit_card->set_guid("00000000-0000-0000-0000-000000000007");
-  autofill_manager_->AddCreditCard(credit_card);
+  autofill_manager_->AddCreditCard(std::move(credit_card));
 
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
 
   field.value = ASCIIToUTF16("5255-66__-____-____");
@@ skipping 85 matching lines @@
   GetAutofillSuggestions(form, field);
   // Autocomplete suggestions are queried, but not Autofill.
   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
 }
 
 // Test that we return all credit card suggestions in the case that two cards
 // have the same obfuscated number.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_RepeatedObfuscatedNumber) {
   // Add a credit card with the same obfuscated number as Elvis's.
   // |credit_card| will be owned by the mock PersonalDataManager.
-  CreditCard* credit_card = new CreditCard;
-  test::SetCreditCardInfo(credit_card, "Elvis Presley",
+  std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
+  test::SetCreditCardInfo(credit_card.get(), "Elvis Presley",
                           "5231567890123456",  // Mastercard
                           "05", "2999");
   credit_card->set_guid("00000000-0000-0000-0000-000000000007");
   credit_card->set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
-  autofill_manager_->AddCreditCard(credit_card);
+  autofill_manager_->AddCreditCard(std::move(credit_card));
 
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
@@ skipping 134 matching lines @@
 // Test that we do not return duplicate values drawn from multiple profiles when
 // filling an already filled field.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWithDuplicateValues) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
-  AutofillProfile* profile = new AutofillProfile;
-  test::SetProfileInfo(
-      profile, "Elvis", "", "", "", "", "", "", "", "", "", "", "");
+  std::unique_ptr<AutofillProfile> profile =
+      base::MakeUnique<AutofillProfile>();
+  test::SetProfileInfo(profile.get(), "Elvis", "", "", "", "", "", "", "", "",
+                       "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
-  autofill_manager_->AddProfile(profile);
+  autofill_manager_->AddProfile(std::move(profile));
 
   FormFieldData& field = form.fields[0];
   field.is_autofilled = true;
   field.value = ASCIIToUTF16("Elvis");
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
       kDefaultPageID,
       Suggestion("Elvis", "", "", 1));
 }
 
 TEST_F(AutofillManagerTest, GetProfileSuggestions_FancyPhone) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  AutofillProfile* profile = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile =
+      base::MakeUnique<AutofillProfile>();
   profile->set_guid("00000000-0000-0000-0000-000000000103");
   profile->SetInfo(AutofillType(NAME_FULL), ASCIIToUTF16("Natty Bumppo"),
                    "en-US");
   profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
                       ASCIIToUTF16("1800PRAIRIE"));
-  autofill_manager_->AddProfile(profile);
+  autofill_manager_->AddProfile(std::move(profile));
 
   const FormFieldData& field = form.fields[9];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate. Inferred
   // labels include the most private field of those that would be filled.
   external_delegate_->CheckSuggestions(
       kDefaultPageID,
       Suggestion("18007724743", "Natty Bumppo", "", 1),  // 1800PRAIRIE
       Suggestion("23456789012", "123 Apple St.", "", 2),
@@ skipping 23 matching lines @@
     test::CreateTestFormField(
         test_fields[i].label, test_fields[i].name, "", "text", &field);
     field.max_length = test_fields[i].max_length;
     field.autocomplete_attribute = std::string();
     form.fields.push_back(field);
   }
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  AutofillProfile* profile = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile =
+      base::MakeUnique<AutofillProfile>();
   profile->set_guid("00000000-0000-0000-0000-000000000104");
   profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("1800FLOWERS"));
   personal_data_.ClearAutofillProfiles();
-  autofill_manager_->AddProfile(profile);
+  autofill_manager_->AddProfile(std::move(profile));
 
   const FormFieldData& phone_prefix = form.fields[2];
   GetAutofillSuggestions(form, phone_prefix);
 
   // Test that we sent the right prefix values to the external delegate.
   external_delegate_->CheckSuggestions(kDefaultPageID,
                                        Suggestion("356", "1800FLOWERS", "", 1));
 
   const FormFieldData& phone_suffix = form.fields[3];
   GetAutofillSuggestions(form, phone_suffix);
@@ skipping 1368 matching lines @@
 // signature of the queried form and apply type predictions.
 TEST_F(AutofillManagerTest, OnLoadedServerPredictions) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
   form_structure->DetermineHeuristicTypes();
-  autofill_manager_->AddSeenForm(form_structure);
+  autofill_manager_->AddSeenForm(base::WrapUnique(form_structure));
 
   // Similarly, a second form.
   FormData form2;
   form2.name = ASCIIToUTF16("MyForm");
   form2.origin = GURL("http://myform.com/form.html");
   form2.action = GURL("http://myform.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Last Name", "lastname", "", "text", &field);
   form2.fields.push_back(field);
 
   test::CreateTestFormField("Middle Name", "middlename", "", "text", &field);
   form2.fields.push_back(field);
 
   test::CreateTestFormField("Postal Code", "zipcode", "", "text", &field);
   form2.fields.push_back(field);
 
   TestFormStructure* form_structure2 = new TestFormStructure(form2);
   form_structure2->DetermineHeuristicTypes();
-  autofill_manager_->AddSeenForm(form_structure2);
+  autofill_manager_->AddSeenForm(base::WrapUnique(form_structure2));
 
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(3);
   for (int i = 0; i < 7; ++i) {
     response.add_field()->set_autofill_type(0);
   }
   response.add_field()->set_autofill_type(3);
   response.add_field()->set_autofill_type(2);
   response.add_field()->set_autofill_type(61);
   response.add_field()->set_autofill_type(5);
@@ skipping 32 matching lines @@
 // response received.
 TEST_F(AutofillManagerTest, OnLoadedServerPredictions_ResetManager) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
   form_structure->DetermineHeuristicTypes();
-  autofill_manager_->AddSeenForm(form_structure);
+  autofill_manager_->AddSeenForm(base::WrapUnique(form_structure));
 
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(3);
   for (int i = 0; i < 7; ++i) {
     response.add_field()->set_autofill_type(0);
   }
   response.add_field()->set_autofill_type(3);
   response.add_field()->set_autofill_type(2);
   response.add_field()->set_autofill_type(61);
 
@@ skipping 25 matching lines @@
   TestFormStructure* form_structure = new TestFormStructure(form);
   form_structure->DetermineHeuristicTypes();
 
   // Clear the heuristic types, and instead set the appropriate server types.
   std::vector<ServerFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
     server_types.push_back(form_structure->field(i)->heuristic_type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
-  autofill_manager_->AddSeenForm(form_structure);
+  autofill_manager_->AddSeenForm(base::WrapUnique(form_structure));
 
   // Fill the form.
   const char guid[] = "00000000-0000-0000-0000-000000000001";
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
                                      MakeFrontendID(std::string(), guid),
                                      &response_page_id, &response_data);
   ExpectFilledAddressFormElvis(response_page_id, response_data, kDefaultPageID,
                                false);
@@ skipping 529 matching lines @@
                   possible_types.find(test_fields[i].expected_upload_type));
       } else {
         EXPECT_EQ(2U, possible_types.size());
       }
     }
   }
 }
 
 TEST_F(AutofillManagerTest, RemoveProfile) {
   // Add and remove an Autofill profile.
-  AutofillProfile* profile = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile =
+      base::MakeUnique<AutofillProfile>();
   const char guid[] = "00000000-0000-0000-0000-000000000102";
   profile->set_guid(guid);
-  autofill_manager_->AddProfile(profile);
+  autofill_manager_->AddProfile(std::move(profile));
 
   int id = MakeFrontendID(std::string(), guid);
 
   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
 
   EXPECT_FALSE(autofill_manager_->GetProfileWithGUID(guid));
 }
 
 TEST_F(AutofillManagerTest, RemoveCreditCard) {
   // Add and remove an Autofill credit card.
-  CreditCard* credit_card = new CreditCard;
+  std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
   const char guid[] = "00000000-0000-0000-0000-000000100007";
   credit_card->set_guid(guid);
-  autofill_manager_->AddCreditCard(credit_card);
+  autofill_manager_->AddCreditCard(std::move(credit_card));
 
   int id = MakeFrontendID(guid, std::string());
 
   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
 
   EXPECT_FALSE(autofill_manager_->GetCreditCardWithGUID(guid));
 }
 
 // Test our external delegate is called at the right time.
 TEST_F(AutofillManagerTest, TestExternalDelegate) {
@@ skipping 1141 matching lines @@
   // Token matching is currently behind a flag.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableSuggestionsWithSubstringMatch);
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  AutofillProfile* profile1 = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile1 =
+      base::MakeUnique<AutofillProfile>();
   profile1->set_guid("00000000-0000-0000-0000-000000000103");
   profile1->SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Robin"), "en-US");
   profile1->SetInfo(AutofillType(NAME_MIDDLE), ASCIIToUTF16("Adam Smith"),
                     "en-US");
   profile1->SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Grimes"), "en-US");
   profile1->SetInfo(AutofillType(ADDRESS_HOME_LINE1),
                     ASCIIToUTF16("1234 Smith Blvd."), "en-US");
-  autofill_manager_->AddProfile(profile1);
+  autofill_manager_->AddProfile(std::move(profile1));
 
-  AutofillProfile* profile2 = new AutofillProfile;
+  std::unique_ptr<AutofillProfile> profile2 =
+      base::MakeUnique<AutofillProfile>();
   profile2->set_guid("00000000-0000-0000-0000-000000000124");
   profile2->SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Carl"), "en-US");
   profile2->SetInfo(AutofillType(NAME_MIDDLE), ASCIIToUTF16("Shawn Smith"),
                     "en-US");
   profile2->SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Grimes"), "en-US");
   profile2->SetInfo(AutofillType(ADDRESS_HOME_LINE1),
                     ASCIIToUTF16("1234 Smith Blvd."), "en-US");
-  autofill_manager_->AddProfile(profile2);
+  autofill_manager_->AddProfile(std::move(profile2));
 
   FormFieldData field;
   test::CreateTestFormField("Middle Name", "middlename", "S", "text", &field);
   GetAutofillSuggestions(form, field);
 
   external_delegate_->CheckSuggestions(
       kDefaultPageID,
       Suggestion("Shawn Smith", "1234 Smith Blvd., Carl Shawn Smith Grimes", "",
                  1),
       Suggestion("Adam Smith", "1234 Smith Blvd., Robin Adam Smith Grimes", "",
@@ skipping 122 matching lines @@
   FormsSeen(mixed_forms);
 
   // Suggestions should always be displayed.
   for (const FormFieldData& field : mixed_form.fields) {
     GetAutofillSuggestions(mixed_form, field);
     EXPECT_TRUE(external_delegate_->on_suggestions_returned_seen());
   }
 }
 
 }  // namespace autofill