Remove stl_util's STLDeleteContainerPointers from autofill.

components/autofill/core/browser/form_structure_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/form_structure.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 1971 matching lines @@
   field.label = ASCIIToUTF16("Expiration Year");
   field.name = ASCIIToUTF16("expiration_year");
   form.fields.push_back(field);
 
   // Add checkable field.
   FormFieldData checkable_field;
   checkable_field.check_status = FormFieldData::CHECKABLE_BUT_UNCHECKED;
   checkable_field.label = ASCIIToUTF16("Checkable1");
   checkable_field.name = ASCIIToUTF16("Checkable1");
   form.fields.push_back(checkable_field);
+  FormStructure form_structure(form);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
   std::vector<std::string> encoded_signatures;
 
   // Prepare the expected proto string.
   AutofillQueryContents query;
   query.set_client_version("6.1.1715.1442/en (GGLL)");
   AutofillQueryContents::Form* query_form = query.add_form();
   query_form->set_signature(11337937696949187602U);
 
   test::FillQueryField(query_form->add_field(), 412125936U, "name_on_card",
                        "text");
   test::FillQueryField(query_form->add_field(), 1917667676U, "billing_address",
                        "text");
   test::FillQueryField(query_form->add_field(), 2226358947U, "card_number",
                        "text");
   test::FillQueryField(query_form->add_field(), 747221617U, "expiration_month",
                        "text");
   test::FillQueryField(query_form->add_field(), 4108155786U, "expiration_year",
                        "text");
 
   std::string expected_query_string;
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
   const char kSignature1[] = "11337937696949187602";
 
   AutofillQueryContents encoded_query;
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kSignature1, encoded_signatures[0]);
 
   std::string encoded_query_string;
   encoded_query.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 
   // Add the same form, only one will be encoded, so EncodeQueryRequest() should
   // return the same data.
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure2(form);
+  forms.push_back(&form_structure2);
 
   AutofillQueryContents encoded_query2;
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query2));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query2));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kSignature1, encoded_signatures[0]);
 
   encoded_query2.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 
   // Add 5 address fields - this should be still a valid form.
   for (size_t i = 0; i < 5; ++i) {
     field.label = ASCIIToUTF16("Address");
     field.name = ASCIIToUTF16("address");
     form.fields.push_back(field);
   }
 
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure3(form);
+  forms.push_back(&form_structure3);
 
   // Add the second form to the expected proto.
   query_form = query.add_form();
   query_form->set_signature(8308881815906226214U);
 
   test::FillQueryField(query_form->add_field(), 412125936U, "name_on_card",
                        "text");
   test::FillQueryField(query_form->add_field(), 1917667676U, "billing_address",
                        "text");
   test::FillQueryField(query_form->add_field(), 2226358947U, "card_number",
                        "text");
   test::FillQueryField(query_form->add_field(), 747221617U, "expiration_month",
                        "text");
   test::FillQueryField(query_form->add_field(), 4108155786U, "expiration_year",
                        "text");
   for (int i = 0; i < 5; ++i) {
     test::FillQueryField(query_form->add_field(), 509334676U, "address",
                          "text");
   }
 
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
   AutofillQueryContents encoded_query3;
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query3));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query3));
   ASSERT_EQ(2U, encoded_signatures.size());
   EXPECT_EQ(kSignature1, encoded_signatures[0]);
   const char kSignature2[] = "8308881815906226214";
   EXPECT_EQ(kSignature2, encoded_signatures[1]);
 
   encoded_query3.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 
   FormData malformed_form(form);
   // Add 50 address fields - the form is not valid anymore, but previous ones
   // are. The result should be the same as in previous test.
   for (size_t i = 0; i < 50; ++i) {
     field.label = ASCIIToUTF16("Address");
     field.name = ASCIIToUTF16("address");
     malformed_form.fields.push_back(field);
   }
 
-  forms.push_back(new FormStructure(malformed_form));
+  FormStructure malformed_form_structure(malformed_form);
+  forms.push_back(&malformed_form_structure);
   AutofillQueryContents encoded_query4;
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query4));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query4));
   ASSERT_EQ(2U, encoded_signatures.size());
   EXPECT_EQ(kSignature1, encoded_signatures[0]);
   EXPECT_EQ(kSignature2, encoded_signatures[1]);
 
   encoded_query4.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 
   // Check that we fail if there are only bad form(s).
-  ScopedVector<FormStructure> bad_forms;
-  bad_forms.push_back(new FormStructure(malformed_form));
+  std::vector<FormStructure*> bad_forms;
+  bad_forms.push_back(&malformed_form_structure);
   AutofillQueryContents encoded_query5;
-  EXPECT_FALSE(FormStructure::EncodeQueryRequest(
-      bad_forms.get(), &encoded_signatures, &encoded_query5));
+  EXPECT_FALSE(FormStructure::EncodeQueryRequest(bad_forms, &encoded_signatures,
+                                                 &encoded_query5));
 }
 
 TEST_F(FormStructureTest, EncodeUploadRequest) {
   std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
@@ skipping 1276 matching lines @@
   field.form_control_type = "checkbox";
   field.check_status = FormFieldData::CHECKABLE_BUT_UNCHECKED;
   form.fields.push_back(field);
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("email");
   field.form_control_type = "text";
   field.check_status = FormFieldData::NOT_CHECKABLE;
   form.fields.push_back(field);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure(form);
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
   std::vector<std::string> encoded_signatures;
   AutofillQueryContents encoded_query;
 
   // Create the expected query and serialize it to a string.
   AutofillQueryContents query;
   query.set_client_version("6.1.1715.1442/en (GGLL)");
   AutofillQueryContents::Form* query_form = query.add_form();
   query_form->set_signature(18006745212084723782U);
 
   test::FillQueryField(query_form->add_field(), 239111655U, "username", "text");
   test::FillQueryField(query_form->add_field(), 420638584U, "email", "text");
 
   std::string expected_query_string;
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
   const char kExpectedSignature[] = "18006745212084723782";
 
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kExpectedSignature, encoded_signatures[0]);
 
   std::string encoded_query_string;
   encoded_query.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 }
 
 TEST_F(FormStructureTest, EncodeQueryRequest_WithLabels) {
   FormData form;
@@ skipping 10 matching lines @@
   field.label = ASCIIToUTF16("Enter your Email address");
   field.name = ASCIIToUTF16("email");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Enter your Password");
   field.name = ASCIIToUTF16("password");
   field.form_control_type = "password";
   form.fields.push_back(field);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  std::vector<FormStructure*> forms;
+  FormStructure form_structure(form);
+  forms.push_back(&form_structure);
   std::vector<std::string> encoded_signatures;
   AutofillQueryContents encoded_query;
 
   // Create the expected query and serialize it to a string.
   AutofillQueryContents query;
   query.set_client_version("6.1.1715.1442/en (GGLL)");
   AutofillQueryContents::Form* query_form = query.add_form();
   query_form->set_signature(13906559713264665730U);
 
   test::FillQueryField(query_form->add_field(), 239111655U, "username", "text");
   test::FillQueryField(query_form->add_field(), 420638584U, "email", "text");
   test::FillQueryField(query_form->add_field(), 2051817934U, "password",
                        "password");
 
   std::string expected_query_string;
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
-  EXPECT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query));
+  EXPECT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query));
 
   std::string encoded_query_string;
   encoded_query.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 }
 
 TEST_F(FormStructureTest, EncodeQueryRequest_WithLongLabels) {
   FormData form;
   form.name = ASCIIToUTF16("the-name");
   form.origin = GURL("http://cool.com");
@@ skipping 13 matching lines @@
       "Exceeding A Certain Number Of Characters...");
   field.name = ASCIIToUTF16("email");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Enter your Password");
   field.name = ASCIIToUTF16("password");
   field.form_control_type = "password";
   form.fields.push_back(field);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure(form);
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
   std::vector<std::string> encoded_signatures;
   AutofillQueryContents encoded_query;
 
   // Create the expected query and serialize it to a string.
   AutofillQueryContents query;
   query.set_client_version("6.1.1715.1442/en (GGLL)");
   AutofillQueryContents::Form* query_form = query.add_form();
   query_form->set_signature(13906559713264665730U);
 
   test::FillQueryField(query_form->add_field(), 239111655U, "username", "text");
   test::FillQueryField(query_form->add_field(), 420638584U, "email", "text");
   test::FillQueryField(query_form->add_field(), 2051817934U, "password",
                        "password");
 
   std::string expected_query_string;
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
-  EXPECT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query));
+  EXPECT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query));
 
   std::string encoded_query_string;
   encoded_query.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 }
 
 // One name is missing from one field.
 TEST_F(FormStructureTest, EncodeQueryRequest_MissingNames) {
   FormData form;
   // No name set for the form.
   form.origin = GURL("http://cool.com");
   form.action = form.origin.Resolve("/login");
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = base::string16();
   // No name set for this field.
   field.name = ASCIIToUTF16("");
   field.form_control_type = "text";
   field.check_status = FormFieldData::NOT_CHECKABLE;
   form.fields.push_back(field);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure(form);
+
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
   std::vector<std::string> encoded_signatures;
   AutofillQueryContents encoded_query;
 
   // Create the expected query and serialize it to a string.
   AutofillQueryContents query;
   query.set_client_version("6.1.1715.1442/en (GGLL)");
   AutofillQueryContents::Form* query_form = query.add_form();
   query_form->set_signature(16416961345885087496U);
 
   test::FillQueryField(query_form->add_field(), 239111655U, "username", "text");
   test::FillQueryField(query_form->add_field(), 1318412689U, nullptr, "text");
 
   std::string expected_query_string;
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
   const char kExpectedSignature[] = "16416961345885087496";
 
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kExpectedSignature, encoded_signatures[0]);
 
   std::string encoded_query_string;
   encoded_query.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 }
 
 // Sending field metadata to the server is disabled.
 TEST_F(FormStructureTest, EncodeQueryRequest_DisabledMetadataTrial) {
   DisableAutofillMetadataFieldTrial();
 
   FormData form;
   // No name set for the form.
   form.origin = GURL("http://cool.com");
   form.action = form.origin.Resolve("/login");
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("country");
   field.form_control_type = "text";
   field.check_status = FormFieldData::NOT_CHECKABLE;
   form.fields.push_back(field);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure(form);
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
   std::vector<std::string> encoded_signatures;
   AutofillQueryContents encoded_query;
 
   // Create the expected query and serialize it to a string.
   AutofillQueryContents query;
   query.set_client_version("6.1.1715.1442/en (GGLL)");
   AutofillQueryContents::Form* query_form = query.add_form();
   query_form->set_signature(7635954436925888745U);
 
   test::FillQueryField(query_form->add_field(), 239111655U, nullptr, nullptr);
   test::FillQueryField(query_form->add_field(), 3654076265U, nullptr, nullptr);
 
   std::string expected_query_string;
   ASSERT_TRUE(query.SerializeToString(&expected_query_string));
 
   const char kExpectedSignature[] = "7635954436925888745";
 
-  ASSERT_TRUE(FormStructure::EncodeQueryRequest(
-      forms.get(), &encoded_signatures, &encoded_query));
+  ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms, &encoded_signatures,
+                                                &encoded_query));
   ASSERT_EQ(1U, encoded_signatures.size());
   EXPECT_EQ(kExpectedSignature, encoded_signatures[0]);
 
   std::string encoded_query_string;
   encoded_query.SerializeToString(&encoded_query_string);
   EXPECT_EQ(expected_query_string, encoded_query_string);
 }
 
 TEST_F(FormStructureTest, PossibleValues) {
   FormData form_data;
@@ skipping 50 matching lines @@
   field.name = ASCIIToUTF16("address");
   form.fields.push_back(field);
 
   // 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);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure(form);
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
 
   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));
+  FormStructure form_structure2(form);
+  forms.push_back(&form_structure2);
 
   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));
-  FormStructure::ParseQueryResponse(response_string, forms.get(), nullptr);
+  FormStructure::ParseQueryResponse(response_string, forms, nullptr);
 
   ASSERT_GE(forms[0]->field_count(), 2U);
   ASSERT_GE(forms[1]->field_count(), 2U);
   EXPECT_EQ(7, forms[0]->field(0)->server_type());
   EXPECT_EQ(30, forms[0]->field(1)->server_type());
   EXPECT_EQ(9, forms[1]->field(0)->server_type());
   EXPECT_EQ(0, forms[1]->field(1)->server_type());
 }
 
 TEST_F(FormStructureTest, ParseQueryResponseAuthorDefinedTypes) {
   FormData form;
   form.origin = GURL("http://foo.com");
   FormFieldData field;
 
   field.label = ASCIIToUTF16("email");
   field.name = ASCIIToUTF16("email");
   field.form_control_type = "text";
   field.autocomplete_attribute = "email";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
   field.name = ASCIIToUTF16("password");
   field.form_control_type = "password";
   field.autocomplete_attribute = "new-password";
   form.fields.push_back(field);
 
-  ScopedVector<FormStructure> forms;
-  forms.push_back(new FormStructure(form));
+  FormStructure form_structure(form);
+  std::vector<FormStructure*> forms;
+  forms.push_back(&form_structure);
   forms.front()->DetermineHeuristicTypes();
 
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(EMAIL_ADDRESS);
   response.add_field()->set_autofill_type(ACCOUNT_CREATION_PASSWORD);
 
   std::string response_string;
   ASSERT_TRUE(response.SerializeToString(&response_string));
-  FormStructure::ParseQueryResponse(response_string, forms.get(), nullptr);
+  FormStructure::ParseQueryResponse(response_string, forms, nullptr);
 
   ASSERT_GE(forms[0]->field_count(), 2U);
   // Server type is parsed from the response and is the end result type.
   EXPECT_EQ(EMAIL_ADDRESS, forms[0]->field(0)->server_type());
   EXPECT_EQ(EMAIL_ADDRESS, forms[0]->field(0)->Type().GetStorableType());
   EXPECT_EQ(ACCOUNT_CREATION_PASSWORD, forms[0]->field(1)->server_type());
   // TODO(crbug.com/613666): Should be a properly defined type, and not
   // UNKNOWN_TYPE.
   EXPECT_EQ(UNKNOWN_TYPE, forms[0]->field(1)->Type().GetStorableType());
 }
@@ skipping 32 matching lines @@
   prefix = FormStructure::FindLongestCommonPrefix(strings);
   EXPECT_EQ(ASCIIToUTF16("1234567890123456"), prefix);
 
   // Empty vector.
   strings.clear();
   prefix = FormStructure::FindLongestCommonPrefix(strings);
   EXPECT_EQ(ASCIIToUTF16(""), prefix);
 }
 
 }  // namespace autofill