Remove stl_util's STLDeleteContainerPointers from autofill.

components/autofill/core/browser/autofill_metrics_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_metrics.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/user_action_tester.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/payments/payments_client.h"
@@ skipping 34 matching lines @@
 
   using PersonalDataManager::set_account_tracker;
   using PersonalDataManager::set_signin_manager;
   using PersonalDataManager::set_database;
   using PersonalDataManager::SetPrefService;
 
   // Overridden to avoid a trip to the database. This should be a no-op except
   // for the side-effect of logging the profile count.
   void LoadProfiles() override {
     {
-      std::vector<AutofillProfile*> profiles;
-      web_profiles_.release(&profiles);
-      WDResult<std::vector<AutofillProfile*> > result(AUTOFILL_PROFILES_RESULT,
-                                                      profiles);
+      std::vector<std::unique_ptr<AutofillProfile>> profiles;
+      web_profiles_.swap(profiles);
+      std::unique_ptr<WDTypedResult> result = base::MakeUnique<
+          WDResult<std::vector<std::unique_ptr<AutofillProfile>>>>(
+          AUTOFILL_PROFILES_RESULT, std::move(profiles));
       pending_profiles_query_ = 123;
-      OnWebDataServiceRequestDone(pending_profiles_query_, &result);
+      OnWebDataServiceRequestDone(pending_profiles_query_, std::move(result));
     }
     {
-      std::vector<AutofillProfile*> profiles;
-      server_profiles_.release(&profiles);
-      WDResult<std::vector<AutofillProfile*> > result(AUTOFILL_PROFILES_RESULT,
-                                                      profiles);
+      std::vector<std::unique_ptr<AutofillProfile>> profiles;
+      server_profiles_.swap(profiles);
+      std::unique_ptr<WDTypedResult> result = base::MakeUnique<
+          WDResult<std::vector<std::unique_ptr<AutofillProfile>>>>(
+          AUTOFILL_PROFILES_RESULT, std::move(profiles));
       pending_server_profiles_query_ = 124;
-      OnWebDataServiceRequestDone(pending_server_profiles_query_, &result);
+      OnWebDataServiceRequestDone(pending_server_profiles_query_,
+                                  std::move(result));
     }
   }
 
   // Overridden to avoid a trip to the database.
   void LoadCreditCards() override {
     {
-      std::vector<CreditCard*> credit_cards;
-      local_credit_cards_.release(&credit_cards);
-      WDResult<std::vector<CreditCard*> > result(
-          AUTOFILL_CREDITCARDS_RESULT, credit_cards);
+      std::vector<std::unique_ptr<CreditCard>> credit_cards;
+      local_credit_cards_.swap(credit_cards);
+      std::unique_ptr<WDTypedResult> result =
+          base::MakeUnique<WDResult<std::vector<std::unique_ptr<CreditCard>>>>(
+              AUTOFILL_CREDITCARDS_RESULT, std::move(credit_cards));
       pending_creditcards_query_ = 125;
-      OnWebDataServiceRequestDone(pending_creditcards_query_, &result);
+      OnWebDataServiceRequestDone(pending_creditcards_query_,
+                                  std::move(result));
     }
     {
-      std::vector<CreditCard*> credit_cards;
-      server_credit_cards_.release(&credit_cards);
-      WDResult<std::vector<CreditCard*> > result(
-          AUTOFILL_CREDITCARDS_RESULT, credit_cards);
+      std::vector<std::unique_ptr<CreditCard>> credit_cards;
+      server_credit_cards_.swap(credit_cards);
+      std::unique_ptr<WDTypedResult> result =
+          base::MakeUnique<WDResult<std::vector<std::unique_ptr<CreditCard>>>>(
+              AUTOFILL_CREDITCARDS_RESULT, std::move(credit_cards));
       pending_server_creditcards_query_ = 126;
-      OnWebDataServiceRequestDone(pending_server_creditcards_query_, &result);
+      OnWebDataServiceRequestDone(pending_server_creditcards_query_,
+                                  std::move(result));
     }
   }
 
   // Overridden to add potential new profiles to the |web_profiles_|. Since
   // there is no database set for the test, the original method would do
   // nothing.
   void SetProfiles(std::vector<AutofillProfile>* profiles) override {
     // Only need to copy all the profiles. This adds any new profiles created at
     // form submission.
     web_profiles_.clear();
-    for (std::vector<AutofillProfile>::iterator iter = profiles->begin();
-         iter != profiles->end(); ++iter) {
-      web_profiles_.push_back(new AutofillProfile(*iter));
-    }
+    for (const auto& profile : *profiles)
+      web_profiles_.push_back(base::MakeUnique<AutofillProfile>(profile));
   }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   // Removes all existing profiles and creates 0 or 1 local profiles and 0 or 1
-  // server profile according to the paramters.
+  // server profile according to the parameters.
   void RecreateProfiles(bool include_local_profile,
                         bool include_server_profile) {
     web_profiles_.clear();
     server_profiles_.clear();
     if (include_local_profile) {
-      AutofillProfile* profile = new AutofillProfile;
-      test::SetProfileInfo(profile, "Elvis", "Aaron",
-                           "Presley", "theking@gmail.com", "RCA",
-                           "3734 Elvis Presley Blvd.", "Apt. 10",
-                           "Memphis", "Tennessee", "38116", "US",
-                           "12345678901");
+      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");
-      web_profiles_.push_back(profile);
+      web_profiles_.push_back(std::move(profile));
     }
     if (include_server_profile) {
-      AutofillProfile* profile = new AutofillProfile(
-          AutofillProfile::SERVER_PROFILE, "server_id");
-      test::SetProfileInfo(profile, "Charles", "Hardin",
-                           "Holley", "buddy@gmail.com", "Decca",
-                           "123 Apple St.", "unit 6", "Lubbock",
-                           "Texas", "79401", "US", "2345678901");
+      std::unique_ptr<AutofillProfile> profile =
+          base::MakeUnique<AutofillProfile>(AutofillProfile::SERVER_PROFILE,
+                                            "server_id");
+      test::SetProfileInfo(profile.get(), "Charles", "Hardin", "Holley",
+                           "buddy@gmail.com", "Decca", "123 Apple St.",
+                           "unit 6", "Lubbock", "Texas", "79401", "US",
+                           "2345678901");
       profile->set_guid("00000000-0000-0000-0000-000000000002");
-      server_profiles_.push_back(profile);
+      server_profiles_.push_back(std::move(profile));
     }
     Refresh();
   }
 
   // Removes all existing credit cards and creates 0 or 1 local profiles and
-  // 0 or 1 server profile according to the paramters.
+  // 0 or 1 server profile according to the parameters.
   void RecreateCreditCards(bool include_local_credit_card,
                            bool include_masked_server_credit_card,
                            bool include_full_server_credit_card) {
     local_credit_cards_.clear();
     server_credit_cards_.clear();
     if (include_local_credit_card) {
-      std::unique_ptr<CreditCard> credit_card(new CreditCard(
-          "10000000-0000-0000-0000-000000000001", std::string()));
+      std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>(
+          "10000000-0000-0000-0000-000000000001", std::string());
       test::SetCreditCardInfo(credit_card.get(), nullptr, "4111111111111111",
                               "12", "24");
-      local_credit_cards_.push_back(credit_card.release());
+      local_credit_cards_.push_back(std::move(credit_card));
     }
     if (include_masked_server_credit_card) {
-      std::unique_ptr<CreditCard> credit_card(new CreditCard(
-          CreditCard::MASKED_SERVER_CARD, "server_id"));
+      std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>(
+          CreditCard::MASKED_SERVER_CARD, "server_id");
       credit_card->set_guid("10000000-0000-0000-0000-000000000002");
       credit_card->SetTypeForMaskedCard(kDiscoverCard);
-      server_credit_cards_.push_back(credit_card.release());
+      server_credit_cards_.push_back(std::move(credit_card));
     }
     if (include_full_server_credit_card) {
-      std::unique_ptr<CreditCard> credit_card(new CreditCard(
-          CreditCard::FULL_SERVER_CARD, "server_id"));
+      std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>(
+          CreditCard::FULL_SERVER_CARD, "server_id");
       credit_card->set_guid("10000000-0000-0000-0000-000000000003");
-      server_credit_cards_.push_back(credit_card.release());
+      server_credit_cards_.push_back(std::move(credit_card));
     }
     Refresh();
   }
 
   bool IsAutofillEnabled() const override { return autofill_enabled_; }
 
  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", "2345678901");
+    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", "2345678901");
     profile->set_guid("00000000-0000-0000-0000-000000000002");
-    profiles->push_back(profile);
+    profiles->push_back(std::move(profile));
   }
 
   bool autofill_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
 };
 
 class TestFormStructure : public FormStructure {
  public:
   explicit TestFormStructure(const FormData& form) : FormStructure(form) {}
@@ skipping 34 matching lines @@
   }
 
   void AddSeenForm(const FormData& form,
                    const std::vector<ServerFieldType>& heuristic_types,
                    const std::vector<ServerFieldType>& server_types) {
     FormData empty_form = form;
     for (size_t i = 0; i < empty_form.fields.size(); ++i) {
       empty_form.fields[i].value = base::string16();
     }
 
-    // |form_structure| will be owned by |form_structures()|.
-    TestFormStructure* form_structure = new TestFormStructure(empty_form);
+    std::unique_ptr<TestFormStructure> form_structure =
+        base::MakeUnique<TestFormStructure>(empty_form);
     form_structure->SetFieldTypes(heuristic_types, server_types);
-    form_structures()->push_back(form_structure);
+    form_structures()->push_back(std::move(form_structure));
   }
 
   // Calls AutofillManager::OnWillSubmitForm and waits for it to complete.
   void WillSubmitForm(const FormData& form, const TimeTicks& timestamp) {
     ResetRunLoop();
     if (!OnWillSubmitForm(form, timestamp))
       return;
 
     // Wait for the asynchronous OnWillSubmitForm() call to complete.
     RunRunLoop();
@@ skipping 463 matching lines @@
   // Heuristic value will be unknown.
   test::CreateTestFormField("Garbage label", "garbage", "", "text", &field);
   field.autocomplete_attribute = "postal-code";
   form.fields.push_back(field);
 
   // No autocomplete attribute. No metric logged.
   test::CreateTestFormField("Address", "address", "", "text", &field);
   field.autocomplete_attribute = "";
   form.fields.push_back(field);
 
-  TestFormStructure* form_structure = new TestFormStructure(form);
+  std::unique_ptr<TestFormStructure> form_structure =
+      base::MakeUnique<TestFormStructure>(form);
+  TestFormStructure* form_structure_ptr = form_structure.get();
   form_structure->DetermineHeuristicTypes();
-  autofill_manager_->form_structures()->push_back(form_structure);
+  autofill_manager_->form_structures()->push_back(std::move(form_structure));
 
   AutofillQueryResponseContents response;
   // Server response will match with autocomplete.
   response.add_field()->set_autofill_type(NAME_LAST);
   // Server response will NOT match with autocomplete.
   response.add_field()->set_autofill_type(NAME_FIRST);
   // Server response will have no data.
   response.add_field()->set_autofill_type(NO_SERVER_DATA);
   // Not logged.
   response.add_field()->set_autofill_type(NAME_MIDDLE);
 
   std::string response_string;
   ASSERT_TRUE(response.SerializeToString(&response_string));
 
   std::vector<std::string> signatures;
-  signatures.push_back(form_structure->FormSignatureAsStr());
+  signatures.push_back(form_structure_ptr->FormSignatureAsStr());
 
   base::HistogramTester histogram_tester;
   autofill_manager_->OnLoadedServerPredictions(response_string, signatures);
 
   // Verify that FormStructure::ParseQueryResponse was called (here and below).
   histogram_tester.ExpectBucketCount("Autofill.ServerQueryResponse",
                                      AutofillMetrics::QUERY_RESPONSE_RECEIVED,
                                      1);
   histogram_tester.ExpectBucketCount("Autofill.ServerQueryResponse",
                                      AutofillMetrics::QUERY_RESPONSE_PARSED, 1);
 
   // Autocomplete-derived types are eventually what's inferred.
-  EXPECT_EQ(NAME_LAST, form_structure->field(0)->Type().GetStorableType());
-  EXPECT_EQ(NAME_MIDDLE, form_structure->field(1)->Type().GetStorableType());
+  EXPECT_EQ(NAME_LAST, form_structure_ptr->field(0)->Type().GetStorableType());
+  EXPECT_EQ(NAME_MIDDLE,
+            form_structure_ptr->field(1)->Type().GetStorableType());
   EXPECT_EQ(ADDRESS_HOME_ZIP,
-            form_structure->field(2)->Type().GetStorableType());
+            form_structure_ptr->field(2)->Type().GetStorableType());
 
   // Heuristic predictions.
   // Unknown:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.BasedOnAutocomplete",
       AutofillMetrics::TYPE_UNKNOWN, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.BasedOnAutocomplete",
       GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP, AutofillMetrics::TYPE_UNKNOWN),
       1);
@@ skipping 3209 matching lines @@
     field.form_control_type = "text";
 
     field.label = ASCIIToUTF16("fullname");
     field.name = ASCIIToUTF16("fullname");
     form.fields.push_back(field);
 
     field.label = ASCIIToUTF16("address");
     field.name = ASCIIToUTF16("address");
     form.fields.push_back(field);
 
-    // Checkable fields should be ignored in parsing
+    // Checkable fields should be ignored in parsing.
     FormFieldData checkable_field;
     checkable_field.label = ASCIIToUTF16("radio_button");
     checkable_field.form_control_type = "radio";
     checkable_field.check_status = FormFieldData::CHECKABLE_BUT_UNCHECKED;
     form.fields.push_back(checkable_field);
 
-    forms_.push_back(new FormStructure(form));
+    owned_forms_.push_back(base::MakeUnique<FormStructure>(form));
+    forms_.push_back(owned_forms_.back().get());
 
     field.label = ASCIIToUTF16("email");
     field.name = ASCIIToUTF16("email");
     form.fields.push_back(field);
 
     field.label = ASCIIToUTF16("password");
     field.name = ASCIIToUTF16("password");
     field.form_control_type = "password";
     form.fields.push_back(field);
 
-    forms_.push_back(new FormStructure(form));
+    owned_forms_.push_back(base::MakeUnique<FormStructure>(form));
+    forms_.push_back(owned_forms_.back().get());
   }
 
  protected:
   TestRapporService rappor_service_;
-  ScopedVector<FormStructure> forms_;
+  std::vector<std::unique_ptr<FormStructure>> owned_forms_;
+  std::vector<FormStructure*> forms_;
 };
 
 TEST_F(AutofillMetricsParseQueryResponseTest, ServerHasData) {
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(7);
   response.add_field()->set_autofill_type(30);
   response.add_field()->set_autofill_type(9);
   response.add_field()->set_autofill_type(0);
 
   std::string response_string;
   ASSERT_TRUE(response.SerializeToString(&response_string));
 
   base::HistogramTester histogram_tester;
-  FormStructure::ParseQueryResponse(response_string, forms_.get(),
-                                    &rappor_service_);
+  FormStructure::ParseQueryResponse(response_string, forms_, &rappor_service_);
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Autofill.ServerResponseHasDataForForm"),
       ElementsAre(Bucket(true, 2)));
 
   // No RAPPOR metrics are logged in the case there is server data available for
   // all forms.
   EXPECT_EQ(0, rappor_service_.GetReportsCount());
 }
 
 // If the server returns NO_SERVER_DATA for one of the forms, expect RAPPOR
 // logging.
 TEST_F(AutofillMetricsParseQueryResponseTest, OneFormNoServerData) {
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(0);
   response.add_field()->set_autofill_type(0);
   response.add_field()->set_autofill_type(9);
   response.add_field()->set_autofill_type(0);
 
   std::string response_string;
   ASSERT_TRUE(response.SerializeToString(&response_string));
 
   base::HistogramTester histogram_tester;
-  FormStructure::ParseQueryResponse(response_string, forms_.get(),
-                                    &rappor_service_);
+  FormStructure::ParseQueryResponse(response_string, forms_, &rappor_service_);
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Autofill.ServerResponseHasDataForForm"),
       ElementsAre(Bucket(false, 1), Bucket(true, 1)));
 
   EXPECT_EQ(1, rappor_service_.GetReportsCount());
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service_.GetRecordedSampleForMetric(
       "Autofill.QueryResponseHasNoServerDataForForm", &sample, &type));
   EXPECT_EQ("foo.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // If the server returns NO_SERVER_DATA for both of the forms, expect RAPPOR
 // logging.
 TEST_F(AutofillMetricsParseQueryResponseTest, AllFormsNoServerData) {
   AutofillQueryResponseContents response;
   for (int i = 0; i < 4; ++i) {
     response.add_field()->set_autofill_type(0);
   }
 
   std::string response_string;
   ASSERT_TRUE(response.SerializeToString(&response_string));
 
   base::HistogramTester histogram_tester;
-  FormStructure::ParseQueryResponse(response_string, forms_.get(),
-                                    &rappor_service_);
+  FormStructure::ParseQueryResponse(response_string, forms_, &rappor_service_);
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Autofill.ServerResponseHasDataForForm"),
       ElementsAre(Bucket(false, 2)));
 
   // Even though both forms are logging to RAPPOR, there is only one sample for
   // a given eTLD+1.
   EXPECT_EQ(1, rappor_service_.GetReportsCount());
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service_.GetRecordedSampleForMetric(
       "Autofill.QueryResponseHasNoServerDataForForm", &sample, &type));
   EXPECT_EQ("foo.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // If the server returns NO_SERVER_DATA for only some of the fields, expect no
 // RAPPOR logging, and expect the UMA metric to say there is data.
 TEST_F(AutofillMetricsParseQueryResponseTest, PartialNoServerData) {
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(0);
   response.add_field()->set_autofill_type(10);
   response.add_field()->set_autofill_type(0);
   response.add_field()->set_autofill_type(11);
 
   std::string response_string;
   ASSERT_TRUE(response.SerializeToString(&response_string));
 
   base::HistogramTester histogram_tester;
-  FormStructure::ParseQueryResponse(response_string, forms_.get(),
-                                    &rappor_service_);
+  FormStructure::ParseQueryResponse(response_string, forms_, &rappor_service_);
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Autofill.ServerResponseHasDataForForm"),
       ElementsAre(Bucket(true, 2)));
 
   // No RAPPOR metrics are logged in the case there is at least some server data
   // available for all forms.
   EXPECT_EQ(0, rappor_service_.GetReportsCount());
 }
 
 }  // namespace autofill