[Password Generation] Send id attribute to server for HTML based form classifier

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 2173 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(8736493185895608956U);
   upload.set_autofill_used(false);
   upload.set_data_present("144200030e");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 3763331450U, "firstname", "text",
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 3494530716U, "lastname", "text",
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   test::FillUploadField(upload.add_field(), 1029417091U, "email", "email",
-                        nullptr, 9U, nullptr);
+                        nullptr, 9U);
   test::FillUploadField(upload.add_field(), 466116101U, "phone", "number",
-                        nullptr, 14U, nullptr);
+                        nullptr, 14U);
   test::FillUploadField(upload.add_field(), 2799270304U, "country",
-                        "select-one", nullptr, 36U, nullptr);
+                        "select-one", nullptr, 36U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
@@ skipping 27 matching lines @@
   ASSERT_EQ(form_structure->field_count(), possible_field_types.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i)
     form_structure->field(i)->set_possible_types(possible_field_types[i]);
 
   // Adjust the expected proto string.
   upload.set_form_signature(7816485729218079147U);
   upload.set_autofill_used(false);
   // Create an additonal 8 fields (total of 13).
   for (int i = 0; i < 8; ++i) {
     test::FillUploadField(upload.add_field(), 509334676U, "address", "text",
-                          nullptr, 30U, nullptr);
+                          nullptr, 30U);
   }
   // Put the appropriate autofill type on the different address fields.
   upload.mutable_field(6)->set_autofill_type(31U);
   upload.mutable_field(7)->set_autofill_type(37U);
   upload.mutable_field(8)->set_autofill_type(38U);
   upload.mutable_field(10)->set_autofill_type(31U);
   upload.mutable_field(11)->set_autofill_type(37U);
   upload.mutable_field(12)->set_autofill_type(38U);
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
@@ skipping 107 matching lines @@
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(5810032074788446513U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440000000000000000802");
   upload.set_action_signature(15724779818122431245U);
   upload.set_login_form_signature(42);
 
   AutofillUploadContents::Field* upload_firstname_field = upload.add_field();
   test::FillUploadField(upload_firstname_field, 4224610201U, "firstname", "",
-                        "given-name", 3U, nullptr);
+                        "given-name", 3U);
   upload_firstname_field->set_form_classifier_outcome(
       AutofillUploadContents::Field::NON_GENERATION_ELEMENT);
   upload_firstname_field->set_properties_mask(FieldPropertiesFlags::HAD_FOCUS);
 
   AutofillUploadContents::Field* upload_lastname_field = upload.add_field();
   test::FillUploadField(upload_lastname_field, 2786066110U, "lastname", "",
-                        "family-name", 5U, nullptr);
+                        "family-name", 5U);
   upload_lastname_field->set_form_classifier_outcome(
       AutofillUploadContents::Field::NON_GENERATION_ELEMENT);
   upload_lastname_field->set_properties_mask(FieldPropertiesFlags::HAD_FOCUS |
                                              FieldPropertiesFlags::USER_TYPED);
 
   AutofillUploadContents::Field* upload_email_field = upload.add_field();
   test::FillUploadField(upload_email_field, 1029417091U, "email", "email",
-                        "email", 9U, nullptr);
+                        "email", 9U);
   upload_email_field->set_form_classifier_outcome(
       AutofillUploadContents::Field::NON_GENERATION_ELEMENT);
   upload_email_field->set_properties_mask(FieldPropertiesFlags::HAD_FOCUS |
                                           FieldPropertiesFlags::USER_TYPED);
 
   AutofillUploadContents::Field* upload_username_field = upload.add_field();
   test::FillUploadField(upload_username_field, 239111655U, "username", "text",
-                        "email", 86U, nullptr);
+                        "email", 86U);
   upload_username_field->set_form_classifier_outcome(
       AutofillUploadContents::Field::NON_GENERATION_ELEMENT);
   upload_username_field->set_properties_mask(FieldPropertiesFlags::HAD_FOCUS |
                                              FieldPropertiesFlags::USER_TYPED);
 
   AutofillUploadContents::Field* upload_password_field = upload.add_field();
   test::FillUploadField(upload_password_field, 2051817934U, "password",
-                        "password", "email", 76U, nullptr);
+                        "password", "email", 76U);
   upload_password_field->set_form_classifier_outcome(
       AutofillUploadContents::Field::GENERATION_ELEMENT);
   upload_password_field->set_generation_type(
       AutofillUploadContents::Field::
           MANUALLY_TRIGGERED_GENERATION_ON_SIGN_UP_FORM);
   upload_password_field->set_properties_mask(FieldPropertiesFlags::HAD_FOCUS |
                                              FieldPropertiesFlags::USER_TYPED);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
@@ skipping 53 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(14746822798145140279U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 3763331450U, "firstname", "text",
-                        "given-name", 3U, nullptr);
+                        "given-name", 3U);
   test::FillUploadField(upload.add_field(), 3494530716U, "lastname", "text",
-                        "family-name", 5U, nullptr);
+                        "family-name", 5U);
   test::FillUploadField(upload.add_field(), 1029417091U, "email", "email",
-                        "email", 9U, nullptr);
+                        "email", 9U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
@@ skipping 43 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(false);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(14746822798145140279U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 3763331450U, "firstname", "text",
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 3494530716U, "lastname", "text",
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   test::FillUploadField(upload.add_field(), 1029417091U, "email", "email",
-                        nullptr, 9U, nullptr);
+                        nullptr, 9U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(),
       /* observed_submission= */ false, &encoded_upload));
 
   std::string encoded_upload_string;
@@ skipping 40 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(6949133589768631292U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 9U, nullptr);
+                        nullptr, 9U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
-TEST_F(FormStructureTest, EncodeUploadRequest_WithCssClasses) {
+TEST_F(FormStructureTest, EncodeUploadRequest_WithCssClassesAndIds) {
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
   possible_field_types.back().insert(NAME_FIRST);
 
   field.css_classes = ASCIIToUTF16("last_name_field");
+  field.id = ASCIIToUTF16("lastname_id");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
   possible_field_types.back().insert(NAME_LAST);
 
   field.css_classes = ASCIIToUTF16("email_field required_field");
+  field.id = ASCIIToUTF16("email_id");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
   possible_field_types.back().insert(EMAIL_ADDRESS);
 
   std::unique_ptr<FormStructure> form_structure(new FormStructure(form));
 
   ASSERT_EQ(form_structure->field_count(), possible_field_types.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i)
     form_structure->field(i)->set_possible_types(possible_field_types[i]);
 
   ServerFieldTypeSet available_field_types;
   available_field_types.insert(NAME_FIRST);
   available_field_types.insert(NAME_LAST);
   available_field_types.insert(EMAIL_ADDRESS);
 
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(6949133589768631292U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
   upload.set_action_signature(15724779818122431245U);
 
-  test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 3U, nullptr);
-  test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 5U, "last_name_field");
-  test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 9U, "email_field required_field");
+  AutofillUploadContents::Field* firstname_field = upload.add_field();
+  test::FillUploadField(firstname_field, 1318412689U, nullptr, "text", nullptr,
+                        3U);
+
+  AutofillUploadContents::Field* lastname_field = upload.add_field();
+  test::FillUploadField(lastname_field, 1318412689U, nullptr, "text", nullptr,
+                        5U);
+  lastname_field->set_id("lastname_id");
+  lastname_field->set_css_classes("last_name_field");
+
+  AutofillUploadContents::Field* email_field = upload.add_field();
+  test::FillUploadField(email_field, 1318412689U, nullptr, "text", nullptr, 9U);
+  email_field->set_id("email_id");
+  email_field->set_css_classes("email_field required_field");
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
@@ skipping 40 matching lines @@
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(2345951786066580868U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
   upload.set_action_signature(15724779818122431245U);
   upload.set_form_name("myform");
 
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 9U, nullptr);
+                        nullptr, 9U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
@@ skipping 45 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(13043654279838250996U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 1318412689U, nullptr, "text",
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 3494530716U, "lastname", "text",
-                        "family-name", 5U, nullptr);
+                        "family-name", 5U);
   test::FillUploadField(upload.add_field(), 1545468175U, "lastname", "email",
-                        "email", 9U, nullptr);
+                        "email", 9U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 // Sending field metadata to the server is disabled.
 TEST_F(FormStructureTest, EncodeUploadRequest_DisabledMetadataTrial) {
   DisableAutofillMetadataFieldTrial();
 
   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;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
+  field.id = ASCIIToUTF16("first_name");
   field.autocomplete_attribute = "given-name";
   field.css_classes = ASCIIToUTF16("class1 class2");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
   possible_field_types.back().insert(NAME_FIRST);
 
   field.label = ASCIIToUTF16("Last Name");
   field.name = ASCIIToUTF16("lastname");
+  field.id = ASCIIToUTF16("last_name");
   field.autocomplete_attribute = "family-name";
   field.css_classes = ASCIIToUTF16("class1 class2");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
   possible_field_types.back().insert(NAME_LAST);
 
   field.label = ASCIIToUTF16("Email");
   field.name = ASCIIToUTF16("email");
+  field.id = ASCIIToUTF16("e-mail");
   field.form_control_type = "email";
   field.autocomplete_attribute = "email";
   field.css_classes = ASCIIToUTF16("class1 class2");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
   possible_field_types.back().insert(EMAIL_ADDRESS);
 
   form_structure.reset(new FormStructure(form));
 
   ASSERT_EQ(form_structure->field_count(), possible_field_types.size());
   for (size_t i = 0; i < form_structure->field_count(); ++i)
     form_structure->field(i)->set_possible_types(possible_field_types[i]);
 
   ServerFieldTypeSet available_field_types;
   available_field_types.insert(NAME_FIRST);
   available_field_types.insert(NAME_LAST);
   available_field_types.insert(EMAIL_ADDRESS);
 
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(14746822798145140279U);
   upload.set_autofill_used(true);
   upload.set_data_present("1440");
 
   test::FillUploadField(upload.add_field(), 3763331450U, nullptr, nullptr,
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 3494530716U, nullptr, nullptr,
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   test::FillUploadField(upload.add_field(), 1029417091U, nullptr, nullptr,
-                        nullptr, 9U, nullptr);
+                        nullptr, 9U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
@@ skipping 35 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(6402244543831589061U);
   upload.set_autofill_used(false);
   upload.set_data_present("");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 1089846351U, "first", "text",
-                        nullptr, 1U, nullptr);
+                        nullptr, 1U);
   test::FillUploadField(upload.add_field(), 2404144663U, "last", "text",
-                        nullptr, 1U, nullptr);
+                        nullptr, 1U);
   test::FillUploadField(upload.add_field(), 420638584U, "email", "text",
-                        nullptr, 1U, nullptr);
+                        nullptr, 1U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure.EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
@@ skipping 243 matching lines @@
   // Prepare the expected proto string.
   AutofillUploadContents upload;
   upload.set_submission(true);
   upload.set_client_version("6.1.1715.1442/en (GGLL)");
   upload.set_form_signature(18062476096658145866U);
   upload.set_autofill_used(false);
   upload.set_data_present("1440000360000008");
   upload.set_action_signature(15724779818122431245U);
 
   test::FillUploadField(upload.add_field(), 420638584U, "email", "text",
-                        nullptr, 9U, nullptr);
+                        nullptr, 9U);
   test::FillUploadField(upload.add_field(), 1089846351U, "first", "text",
-                        nullptr, 3U, nullptr);
+                        nullptr, 3U);
   test::FillUploadField(upload.add_field(), 2404144663U, "last", "text",
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   test::FillUploadField(upload.add_field(), 509334676U, "address", "text",
-                        nullptr, 30U, nullptr);
+                        nullptr, 30U);
 
   std::string expected_upload_string;
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 
   // Match third field as both first and last.
   possible_field_types[2].insert(NAME_FIRST);
   form_structure->field(2)->set_possible_types(possible_field_types[2]);
 
   // Modify the expected upload.
   // Put the NAME_FIRST prediction on the third field.
   upload.mutable_field(2)->set_autofill_type(3);
   // Replace the fourth field by the old third field.
   test::FillUploadField(upload.mutable_field(3), 2404144663U, "last", "text",
-                        nullptr, 5U, nullptr);
+                        nullptr, 5U);
   // Re-add the old fourth field.
   test::FillUploadField(upload.add_field(), 509334676U, "address", "text",
-                        nullptr, 30U, nullptr);
+                        nullptr, 30U);
 
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload2;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload2));
 
   encoded_upload2.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 
   // Match last field as both address home line 1 and 2.
   possible_field_types[3].insert(ADDRESS_HOME_LINE2);
   form_structure->field(form_structure->field_count() - 1)->set_possible_types(
       possible_field_types[form_structure->field_count() - 1]);
 
   // Adjust the expected upload proto.
   test::FillUploadField(upload.add_field(), 509334676U, "address", "text",
-                        nullptr, 31U, nullptr);
+                        nullptr, 31U);
   ASSERT_TRUE(upload.SerializeToString(&expected_upload_string));
 
   AutofillUploadContents encoded_upload3;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload3));
 
   encoded_upload3.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 
   // Replace the address line 2 prediction by company name.
@@ skipping 538 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