Remove stl_util's STLDeleteContainerPointers from autofill.

components/autofill/core/browser/webdata/autofill_table_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 <stddef.h>
 
 #include <map>
 #include <set>
 #include <string>
 #include <tuple>
@@ skipping 1370 matching lines @@
       "INSERT INTO credit_cards (guid, origin, date_modified) "
       "VALUES('00000000-0000-0000-0000-000000000003', '', 17);"
       "INSERT INTO credit_cards (guid, origin, date_modified) "
       "VALUES('00000000-0000-0000-0000-000000000004', "
       "       'https://www.example.com/', 27);"
       "INSERT INTO credit_cards (guid, origin, date_modified) "
       "VALUES('00000000-0000-0000-0000-000000000005', 'Chrome settings', "
       "       37);"));
 
   // Remove all origin URLs set in the bounded time range [21,27).
-  ScopedVector<AutofillProfile> profiles;
+  std::vector<std::unique_ptr<AutofillProfile>> profiles;
   table_->RemoveOriginURLsModifiedBetween(
       Time::FromTimeT(21), Time::FromTimeT(27), &profiles);
   ASSERT_EQ(1UL, profiles.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000001", profiles[0]->guid());
   sql::Statement s_autofill_profiles_bounded(
       db_->GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified, origin FROM autofill_profiles"));
   ASSERT_TRUE(s_autofill_profiles_bounded.is_valid());
   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   EXPECT_EQ(11, s_autofill_profiles_bounded.ColumnInt64(0));
@@ skipping 177 matching lines @@
       CreditCard(CreditCard::MASKED_SERVER_CARD, "b456"));
   inputs[1].SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("Rick Roman"));
   inputs[1].SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("12"));
   inputs[1].SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("1997"));
   inputs[1].SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1111"));
   inputs[1].SetTypeForMaskedCard(kVisaCard);
   inputs[1].SetServerStatus(CreditCard::EXPIRED);
 
   test::SetServerCreditCards(table_.get(), inputs);
 
-  std::vector<CreditCard*> outputs;
+  std::vector<std::unique_ptr<CreditCard>> outputs;
   ASSERT_TRUE(table_->GetServerCreditCards(&outputs));
   ASSERT_EQ(inputs.size(), outputs.size());
 
   // Ordering isn't guaranteed, so fix the ordering if it's backwards.
   if (outputs[1]->server_id() == inputs[0].server_id())
     std::swap(outputs[0], outputs[1]);
 
   // GUIDs for server cards are dynamically generated so will be different
   // after reading from the DB. Check they're valid, but otherwise don't count
   // them in the comparison.
   inputs[0].set_guid(std::string());
   inputs[1].set_guid(std::string());
   outputs[0]->set_guid(std::string());
   outputs[1]->set_guid(std::string());
 
   EXPECT_EQ(inputs[0], *outputs[0]);
   EXPECT_EQ(inputs[1], *outputs[1]);
 
   EXPECT_EQ(CreditCard::OK, outputs[0]->GetServerStatus());
   EXPECT_EQ(CreditCard::EXPIRED, outputs[1]->GetServerStatus());
-
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
 }
 
 TEST_F(AutofillTableTest, MaskUnmaskServerCards) {
   base::string16 masked_number(ASCIIToUTF16("1111"));
   std::vector<CreditCard> inputs;
   inputs.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   inputs[0].SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("Jay Johnson"));
   inputs[0].SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("1"));
   inputs[0].SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2020"));
   inputs[0].SetRawInfo(CREDIT_CARD_NUMBER, masked_number);
   inputs[0].SetTypeForMaskedCard(kVisaCard);
   test::SetServerCreditCards(table_.get(), inputs);
 
   // Unmask the number. The full number should be available.
   base::string16 full_number(ASCIIToUTF16("4111111111111111"));
   ASSERT_TRUE(table_->UnmaskServerCreditCard(inputs[0],
                                              full_number));
 
-  std::vector<CreditCard*> outputs;
+  std::vector<std::unique_ptr<CreditCard>> outputs;
   table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_TRUE(CreditCard::FULL_SERVER_CARD == outputs[0]->record_type());
   EXPECT_EQ(full_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 
   // Re-mask the number, we should only get the last 4 digits out.
   ASSERT_TRUE(table_->MaskServerCreditCard(inputs[0].server_id()));
   table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_TRUE(CreditCard::MASKED_SERVER_CARD == outputs[0]->record_type());
   EXPECT_EQ(masked_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 }
 
 // Calling SetServerCreditCards should replace all existing cards, but unmasked
 // cards should not be re-masked.
 TEST_F(AutofillTableTest, SetServerCardModify) {
   // Add a masked card.
   CreditCard masked_card(CreditCard::MASKED_SERVER_CARD, "a123");
   masked_card.SetRawInfo(CREDIT_CARD_NAME_FULL,
                          ASCIIToUTF16("Paul F. Tompkins"));
   masked_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("1"));
   masked_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2020"));
   masked_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1111"));
   masked_card.SetTypeForMaskedCard(kVisaCard);
 
   std::vector<CreditCard> inputs;
   inputs.push_back(masked_card);
   test::SetServerCreditCards(table_.get(), inputs);
 
   // Now unmask it.
   base::string16 full_number = ASCIIToUTF16("4111111111111111");
   table_->UnmaskServerCreditCard(masked_card, full_number);
 
   // The card should now be unmasked.
-  std::vector<CreditCard*> outputs;
+  std::vector<std::unique_ptr<CreditCard>> outputs;
   table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_TRUE(outputs[0]->record_type() == CreditCard::FULL_SERVER_CARD);
   EXPECT_EQ(full_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 
   // Call set again with the masked number.
   inputs[0] = masked_card;
   test::SetServerCreditCards(table_.get(), inputs);
 
   // The card should stay unmasked.
   table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_TRUE(outputs[0]->record_type() == CreditCard::FULL_SERVER_CARD);
   EXPECT_EQ(full_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 
   // Set inputs that do not include our old card.
   CreditCard random_card(CreditCard::MASKED_SERVER_CARD, "b456");
   random_card.SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("Rick Roman"));
   random_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("12"));
   random_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("1997"));
   random_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("2222"));
   random_card.SetTypeForMaskedCard(kVisaCard);
   inputs[0] = random_card;
   test::SetServerCreditCards(table_.get(), inputs);
 
   // We should have only the new card, the other one should have been deleted.
   table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_TRUE(outputs[0]->record_type() == CreditCard::MASKED_SERVER_CARD);
   EXPECT_EQ(random_card.server_id(), outputs[0]->server_id());
   EXPECT_EQ(ASCIIToUTF16("2222"), outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 
   // Putting back the original card masked should make it masked (this tests
   // that the unmasked data was really deleted).
   inputs[0] = masked_card;
   test::SetServerCreditCards(table_.get(), inputs);
   table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_TRUE(outputs[0]->record_type() == CreditCard::MASKED_SERVER_CARD);
   EXPECT_EQ(masked_card.server_id(), outputs[0]->server_id());
   EXPECT_EQ(ASCIIToUTF16("1111"), outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 }
 
 TEST_F(AutofillTableTest, SetServerCardUpdateUsageStats) {
   // Add a masked card.
   CreditCard masked_card(CreditCard::MASKED_SERVER_CARD, "a123");
   masked_card.SetRawInfo(CREDIT_CARD_NAME_FULL,
                          ASCIIToUTF16("Paul F. Tompkins"));
   masked_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("1"));
   masked_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2020"));
   masked_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1111"));
   masked_card.SetTypeForMaskedCard(kVisaCard);
 
   std::vector<CreditCard> inputs;
   inputs.push_back(masked_card);
   test::SetServerCreditCards(table_.get(), inputs);
 
-  ScopedVector<CreditCard> outputs;
-  table_->GetServerCreditCards(&outputs.get());
+  std::vector<std::unique_ptr<CreditCard>> outputs;
+  table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(masked_card.server_id(), outputs[0]->server_id());
   EXPECT_EQ(1U, outputs[0]->use_count());
   EXPECT_NE(base::Time(), outputs[0]->use_date());
   // We don't track modification date for server cards. It should always be
   // base::Time().
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 
   // Update the usage stats; make sure they're reflected in GetServerProfiles.
   inputs.back().set_use_count(4U);
   inputs.back().set_use_date(base::Time());
   table_->UpdateServerCardUsageStats(inputs.back());
-  table_->GetServerCreditCards(&outputs.get());
+  table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(masked_card.server_id(), outputs[0]->server_id());
   EXPECT_EQ(4U, outputs[0]->use_count());
   EXPECT_EQ(base::Time(), outputs[0]->use_date());
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 
   // Setting the cards again shouldn't delete the usage stats.
   table_->SetServerCreditCards(inputs);
-  table_->GetServerCreditCards(&outputs.get());
+  table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(masked_card.server_id(), outputs[0]->server_id());
   EXPECT_EQ(4U, outputs[0]->use_count());
   EXPECT_EQ(base::Time(), outputs[0]->use_date());
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 
   // Set a card list where the card is missing --- this should clear metadata.
   CreditCard masked_card2(CreditCard::MASKED_SERVER_CARD, "b456");
   inputs.back() = masked_card2;
   table_->SetServerCreditCards(inputs);
 
   // Back to the original card list.
   inputs.back() = masked_card;
   table_->SetServerCreditCards(inputs);
-  table_->GetServerCreditCards(&outputs.get());
+  table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(masked_card.server_id(), outputs[0]->server_id());
   EXPECT_EQ(1U, outputs[0]->use_count());
   EXPECT_NE(base::Time(), outputs[0]->use_date());
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 }
 
 TEST_F(AutofillTableTest, UpdateServerCardBillingAddress) {
   // Add a masked card.
   CreditCard masked_card(CreditCard::MASKED_SERVER_CARD, "a123");
   masked_card.SetRawInfo(CREDIT_CARD_NAME_FULL,
                          ASCIIToUTF16("Paul F. Tompkins"));
   masked_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("1"));
   masked_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2020"));
   masked_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1111"));
   masked_card.set_billing_address_id("billing-address-id-1");
   masked_card.SetTypeForMaskedCard(kVisaCard);
   test::SetServerCreditCards(table_.get(),
                              std::vector<CreditCard>(1, masked_card));
-  ScopedVector<CreditCard> outputs;
-  table_->GetServerCreditCards(&outputs.get());
+  std::vector<std::unique_ptr<CreditCard>> outputs;
+  table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
 
   EXPECT_EQ("billing-address-id-1", outputs[0]->billing_address_id());
 
   masked_card.set_billing_address_id("billing-address-id-2");
   table_->UpdateServerCardBillingAddress(masked_card);
   outputs.clear();
-  table_->GetServerCreditCards(&outputs.get());
+  table_->GetServerCreditCards(&outputs);
   ASSERT_EQ(1u, outputs.size());
 
   EXPECT_EQ("billing-address-id-2", outputs[0]->billing_address_id());
 }
 
 TEST_F(AutofillTableTest, SetServerProfile) {
   AutofillProfile one(AutofillProfile::SERVER_PROFILE, "a123");
   std::vector<AutofillProfile> inputs;
   inputs.push_back(one);
   table_->SetServerProfiles(inputs);
 
-  std::vector<AutofillProfile*> outputs;
+  std::vector<std::unique_ptr<AutofillProfile>> outputs;
   table_->GetServerProfiles(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(one.server_id(), outputs[0]->server_id());
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 
   // Set a different profile.
   AutofillProfile two(AutofillProfile::SERVER_PROFILE, "b456");
   inputs[0] = two;
   table_->SetServerProfiles(inputs);
 
   // The original one should have been replaced.
   table_->GetServerProfiles(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(two.server_id(), outputs[0]->server_id());
 
-  base::STLDeleteContainerPointers(outputs.begin(), outputs.end());
   outputs.clear();
 }
 
 TEST_F(AutofillTableTest, SetServerProfileUpdateUsageStats) {
   AutofillProfile one(AutofillProfile::SERVER_PROFILE, "a123");
   std::vector<AutofillProfile> inputs;
   inputs.push_back(one);
   table_->SetServerProfiles(inputs);
 
-  ScopedVector<AutofillProfile> outputs;
-  table_->GetServerProfiles(&outputs.get());
+  std::vector<std::unique_ptr<AutofillProfile>> outputs;
+  table_->GetServerProfiles(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(one.server_id(), outputs[0]->server_id());
   EXPECT_EQ(0U, outputs[0]->use_count());
   EXPECT_EQ(base::Time(), outputs[0]->use_date());
   // We don't track modification date for server profiles. It should always be
   // base::Time().
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 
   // Update the usage stats; make sure they're reflected in GetServerProfiles.
   inputs.back().set_use_count(4U);
   inputs.back().set_use_date(base::Time::Now());
   table_->UpdateServerAddressUsageStats(inputs.back());
-  table_->GetServerProfiles(&outputs.get());
+  table_->GetServerProfiles(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(one.server_id(), outputs[0]->server_id());
   EXPECT_EQ(4U, outputs[0]->use_count());
   EXPECT_NE(base::Time(), outputs[0]->use_date());
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 
   // Setting the profiles again shouldn't delete the usage stats.
   table_->SetServerProfiles(inputs);
-  table_->GetServerProfiles(&outputs.get());
+  table_->GetServerProfiles(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(one.server_id(), outputs[0]->server_id());
   EXPECT_EQ(4U, outputs[0]->use_count());
   EXPECT_NE(base::Time(), outputs[0]->use_date());
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 
   // Set a null profile list --- this should clear metadata.
   table_->SetServerProfiles(std::vector<AutofillProfile>());
   // Reset the old profile list and see the metadata is reset.
   table_->SetServerProfiles(inputs);
-  table_->GetServerProfiles(&outputs.get());
+  table_->GetServerProfiles(&outputs);
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(one.server_id(), outputs[0]->server_id());
   EXPECT_EQ(0U, outputs[0]->use_count());
   EXPECT_EQ(base::Time(), outputs[0]->use_date());
   EXPECT_EQ(base::Time(), outputs[0]->modification_date());
   outputs.clear();
 }
 
 // Tests that deleting time ranges re-masks server credit cards that were
 // unmasked in that time.
@@ skipping 22 matching lines @@
 
   // Delete data in a range a year in the future.
   std::vector<std::string> profile_guids;
   std::vector<std::string> credit_card_guids;
   ASSERT_TRUE(table_->RemoveAutofillDataModifiedBetween(
       unmasked_time + base::TimeDelta::FromDays(365),
       unmasked_time + base::TimeDelta::FromDays(530),
       &profile_guids, &credit_card_guids));
 
   // This should not affect the unmasked card (should be unmasked).
-  ScopedVector<CreditCard> outputs;
-  ASSERT_TRUE(table_->GetServerCreditCards(&outputs.get()));
+  std::vector<std::unique_ptr<CreditCard>> outputs;
+  ASSERT_TRUE(table_->GetServerCreditCards(&outputs));
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(CreditCard::FULL_SERVER_CARD, outputs[0]->record_type());
   EXPECT_EQ(full_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
   outputs.clear();
 
   // Delete data in the range of the last 24 hours.
   // Fudge |now| to make sure it's strictly greater than the |now| that
   // the database uses.
   base::Time now = base::Time::Now() + base::TimeDelta::FromSeconds(1);
   ASSERT_TRUE(table_->RemoveAutofillDataModifiedBetween(
       now - base::TimeDelta::FromDays(1), now,
       &profile_guids, &credit_card_guids));
 
   // This should re-mask.
-  ASSERT_TRUE(table_->GetServerCreditCards(&outputs.get()));
+  ASSERT_TRUE(table_->GetServerCreditCards(&outputs));
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(CreditCard::MASKED_SERVER_CARD, outputs[0]->record_type());
   EXPECT_EQ(masked_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
   outputs.clear();
 
   // Unmask again, the card should be back.
   table_->UnmaskServerCreditCard(masked_card, full_number);
-  ASSERT_TRUE(table_->GetServerCreditCards(&outputs.get()));
+  ASSERT_TRUE(table_->GetServerCreditCards(&outputs));
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(CreditCard::FULL_SERVER_CARD, outputs[0]->record_type());
   EXPECT_EQ(full_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
   outputs.clear();
 
   // Delete all data.
   ASSERT_TRUE(table_->RemoveAutofillDataModifiedBetween(
       base::Time(), base::Time::Max(), &profile_guids, &credit_card_guids));
 
   // Should be masked again.
-  ASSERT_TRUE(table_->GetServerCreditCards(&outputs.get()));
+  ASSERT_TRUE(table_->GetServerCreditCards(&outputs));
   ASSERT_EQ(1u, outputs.size());
   EXPECT_EQ(CreditCard::MASKED_SERVER_CARD, outputs[0]->record_type());
   EXPECT_EQ(masked_number, outputs[0]->GetRawInfo(CREDIT_CARD_NUMBER));
   outputs.clear();
 }
 
 TEST_F(AutofillTableTest, GetFormValuesForElementName_SubstringMatchEnabled) {
   // Token matching is currently behind a flag.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableSuggestionsWithSubstringMatch);
@@ skipping 43 matching lines @@
     for (size_t j = 0; j < kTestCases[i].expected_suggestion_count; ++j) {
       EXPECT_EQ(ASCIIToUTF16(kTestCases[i].expected_suggestion[j]), v[j]);
     }
 
     changes.clear();
     table_->RemoveFormElementsAddedBetween(t1, Time(), &changes);
   }
 }
 
 }  // namespace autofill