[Password Generation] Sends the flag whether a field has nonempty user input

chrome/renderer/autofill/form_autofill_browsertest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
@@ skipping 1595 matching lines @@
 
 // We should be able to extract a normal text field.
 TEST_F(FormAutofillTest, WebFormControlElementToFormField) {
   LoadHTML("<INPUT type='text' id='element' value='value'/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result1;
-  WebFormControlElementToFormField(element, EXTRACT_NONE, &result1);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_NONE, &result1);
 
   FormFieldData expected;
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("element");
   expected.value.clear();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
 
   FormFieldData result2;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result2);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result2);
 
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2);
 }
 
 // We should be able to extract a text field with autocomplete="off".
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompleteOff) {
   LoadHTML("<INPUT type='text' id='element' value='value'"
            "       autocomplete='off'/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   expected.form_control_type = "text";
   expected.autocomplete_attribute = "off";
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract a text field with maxlength specified.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMaxLength) {
   LoadHTML("<INPUT type='text' id='element' value='value'"
            "       maxlength='5'/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   expected.form_control_type = "text";
   expected.max_length = 5;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract a text field that has been autofilled.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutofilled) {
   LoadHTML("<INPUT type='text' id='element' value='value'/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebInputElement element = GetInputElementById("element");
   element.setAutofilled(true);
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract a radio or a checkbox field that has been
 // autofilled.
 TEST_F(FormAutofillTest, WebFormControlElementToClickableFormField) {
   LoadHTML("<INPUT type='checkbox' id='checkbox' value='mail' checked/>"
            "<INPUT type='radio' id='radio' value='male'/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebInputElement element = GetInputElementById("checkbox");
   element.setAutofilled(true);
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("checkbox");
   expected.value = ASCIIToUTF16("mail");
   expected.form_control_type = "checkbox";
   expected.is_autofilled = true;
   expected.check_status = FormFieldData::CHECKED;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
   element = GetInputElementById("radio");
   element.setAutofilled(true);
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("radio");
   expected.value = ASCIIToUTF16("male");
   expected.form_control_type = "radio";
   expected.is_autofilled = true;
   expected.check_status = FormFieldData::CHECKABLE_BUT_UNCHECKED;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract a <select> field.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldSelect) {
   LoadHTML("<SELECT id='element'/>"
            "  <OPTION value='CA'>California</OPTION>"
            "  <OPTION value='TX'>Texas</OPTION>"
            "</SELECT>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result1;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result1);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result1);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.max_length = 0;
   expected.form_control_type = "select-one";
 
   expected.value = ASCIIToUTF16("CA");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
 
   FormFieldData result2;
   WebFormControlElementToFormField(
-      element,
-      static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
-      &result2);
+      element, nullptr,
+      static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT), &result2);
   expected.value = ASCIIToUTF16("California");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2);
 
   FormFieldData result3;
-  WebFormControlElementToFormField(element, EXTRACT_OPTIONS, &result3);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_OPTIONS, &result3);
   expected.value.clear();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result3);
 
   ASSERT_EQ(2U, result3.option_values.size());
   ASSERT_EQ(2U, result3.option_contents.size());
   EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]);
   EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]);
   EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]);
   EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]);
 }
 
 // We copy extra attributes for the select field.
 TEST_F(FormAutofillTest,
        WebFormControlElementToFormFieldSelect_ExtraAttributes) {
   LoadHTML("<SELECT id='element' autocomplete='off'/>"
            "  <OPTION value='CA'>California</OPTION>"
            "  <OPTION value='TX'>Texas</OPTION>"
            "</SELECT>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   element.setAutofilled(true);
 
   FormFieldData result1;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result1);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result1);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.max_length = 0;
   expected.form_control_type = "select-one";
   // We check that the extra attributes have been copied to |result1|.
   expected.is_autofilled = true;
   expected.autocomplete_attribute = "off";
   expected.should_autocomplete = false;
   expected.is_focusable = true;
@@ skipping 12 matching lines @@
                                "%" PRIuS "</OPTION>", i, i);
   }
   html += "</SELECT>";
   LoadHTML(html.c_str());
 
   WebFrame* frame = GetMainFrame();
   ASSERT_TRUE(frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_OPTIONS, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_OPTIONS, &result);
 
   EXPECT_TRUE(result.option_values.empty());
   EXPECT_TRUE(result.option_contents.empty());
 }
 
 // We should be able to extract a <textarea> field.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldTextArea) {
   LoadHTML("<TEXTAREA id='element'>"
              "This element's value&#10;"
              "spans multiple lines."
            "</TEXTAREA>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result_sans_value;
-  WebFormControlElementToFormField(element, EXTRACT_NONE, &result_sans_value);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_NONE,
+                                   &result_sans_value);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.max_length = 0;
   expected.form_control_type = "textarea";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_sans_value);
 
   FormFieldData result_with_value;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result_with_value);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE,
+                                   &result_with_value);
   expected.value = ASCIIToUTF16("This element's value\n"
                                 "spans multiple lines.");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_with_value);
 }
 
 // We should be able to extract an <input type="month"> field.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMonthInput) {
   LoadHTML("<INPUT type='month' id='element' value='2011-12'>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result_sans_value;
-  WebFormControlElementToFormField(element, EXTRACT_NONE, &result_sans_value);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_NONE,
+                                   &result_sans_value);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.max_length = 0;
   expected.form_control_type = "month";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_sans_value);
 
   FormFieldData result_with_value;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result_with_value);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE,
+                                   &result_with_value);
   expected.value = ASCIIToUTF16("2011-12");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_with_value);
 }
 
 // We should not extract the value for non-text and non-select fields.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldInvalidType) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='hidden' id='hidden' value='apple'/>"
            "  <INPUT type='submit' id='submit' value='Send'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("hidden");
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.max_length = 0;
 
   expected.name = ASCIIToUTF16("hidden");
   expected.form_control_type = "hidden";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
   element = GetFormControlElementById("submit");
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("submit");
   expected.form_control_type = "submit";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract password fields.
 TEST_F(FormAutofillTest, WebFormControlElementToPasswordFormField) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='password' id='password' value='secret'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("password");
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.max_length = WebInputElement::defaultMaxLength();
   expected.name = ASCIIToUTF16("password");
   expected.form_control_type = "password";
   expected.value = ASCIIToUTF16("secret");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract the autocompletetype attribute.
@@ skipping 54 matching lines @@
     // Very long attribute values should be replaced by a default string, to
     // prevent malicious websites from DOSing the browser process.
     { "malicious", "text", "x-max-data-length-exceeded" },
   };
 
   WebDocument document = frame->document();
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     WebFormControlElement element =
         GetFormControlElementById(ASCIIToUTF16(test_cases[i].element_id));
     FormFieldData result;
-    WebFormControlElementToFormField(element, EXTRACT_NONE, &result);
+    WebFormControlElementToFormField(element, nullptr, EXTRACT_NONE, &result);
 
     FormFieldData expected;
     expected.name = ASCIIToUTF16(test_cases[i].element_id);
     expected.form_control_type = test_cases[i].form_control_type;
     expected.autocomplete_attribute = test_cases[i].autocomplete_attribute;
     if (test_cases[i].form_control_type == "text")
       expected.max_length = WebInputElement::defaultMaxLength();
     else
       expected.max_length = 0;
 
     SCOPED_TRACE(test_cases[i].element_id);
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
   }
 }
 
 TEST_F(FormAutofillTest, DetectTextDirectionFromDirectStyle) {
   LoadHTML("<STYLE>input{direction:rtl}</STYLE>"
            "<FORM>"
            "  <INPUT type='text' id='element'>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, DetectTextDirectionFromDirectDIRAttribute) {
   LoadHTML("<FORM>"
            "  <INPUT dir='rtl' type='text' id='element'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, DetectTextDirectionFromParentStyle) {
   LoadHTML("<STYLE>form{direction:rtl}</STYLE>"
            "<FORM>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, DetectTextDirectionFromParentDIRAttribute) {
   LoadHTML("<FORM dir='rtl'>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, DetectTextDirectionWhenStyleAndDIRAttributMixed) {
   LoadHTML("<STYLE>input{direction:ltr}</STYLE>"
            "<FORM dir='rtl'>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, TextAlignOverridesDirection) {
   // text-align: right
   LoadHTML("<STYLE>input{direction:ltr;text-align:right}</STYLE>"
            "<FORM>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 
   // text-align: left
   LoadHTML("<STYLE>input{direction:rtl;text-align:left}</STYLE>"
            "<FORM>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
   frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   element = GetFormControlElementById("element");
 
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest,
        DetectTextDirectionWhenParentHasBothDIRAttributeAndStyle) {
   LoadHTML("<STYLE>form{direction:ltr}</STYLE>"
            "<FORM dir='rtl'>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, DetectTextDirectionWhenAncestorHasInlineStyle) {
   LoadHTML("<FORM style='direction:ltr'>"
            "  <SPAN dir='rtl'>"
            "    <INPUT type='text' id='element'/>"
            "  </SPAN>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
-  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, WebFormElementToFormData) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <LABEL for='firstname'>First name:</LABEL>"
            "    <INPUT type='text' id='firstname' value='John'/>"
            "  <LABEL for='lastname'>Last name:</LABEL>"
            "    <INPUT type='text' id='lastname' value='Smith'/>"
            "  <LABEL for='street-address'>Address:</LABEL>"
@@ skipping 20 matching lines @@
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->document().forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   WebInputElement input_element = GetInputElementById("firstname");
 
   FormData form;
   FormFieldData field;
-  EXPECT_TRUE(WebFormElementToFormData(forms[0],
-                                       input_element,
-                                       EXTRACT_VALUE,
-                                       &form,
-                                       &field));
+  EXPECT_TRUE(WebFormElementToFormData(forms[0], input_element, nullptr,
+                                       EXTRACT_VALUE, &form, &field));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GetCanonicalOriginForDocument(frame->document()), form.origin);
   EXPECT_FALSE(form.origin.is_empty());
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(6U, fields.size());
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("firstname");
@@ skipping 49 matching lines @@
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form = frame->document().getElementById("form")
       .to<WebFormElement>();
   ASSERT_FALSE(web_form.isNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
-                                       EXTRACT_NONE, &form, nullptr));
+                                       nullptr, EXTRACT_NONE, &form, nullptr));
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(1U, fields.size());
   EXPECT_EQ(ASCIIToUTF16("firstname"), fields[0].name);
 }
 
 // TODO(crbug.com/616730) Flaky.
 #if defined(OS_CHROMEOS) || defined(OS_MACOSX)
 #define MAYBE_WebFormElementToFormDataTooManyFields \
   DISABLED_WebFormElementToFormDataTooManyFields
@@ skipping 15 matching lines @@
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->document().forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   WebInputElement input_element = GetInputElementById("firstname");
 
   FormData form;
   FormFieldData field;
-  EXPECT_FALSE(WebFormElementToFormData(forms[0],
-                                        input_element,
-                                        EXTRACT_VALUE,
-                                        &form,
-                                        &field));
+  EXPECT_FALSE(WebFormElementToFormData(forms[0], input_element, nullptr,
+                                        EXTRACT_VALUE, &form, &field));
 }
 
 // Tests that the |should_autocomplete| is set to false for all the fields when
 // an autocomplete='off' attribute is set for the form in HTML.
 TEST_F(FormAutofillTest, WebFormElementToFormData_AutocompleteOff_OnForm) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post' "
       "autocomplete='off'>"
       "  <LABEL for='firstname'>First name:</LABEL>"
       "    <INPUT type='text' id='firstname' value='John'/>"
       "  <LABEL for='lastname'>Last name:</LABEL>"
       "    <INPUT type='text' id='lastname' value='Smith'/>"
       "  <LABEL for='street-address'>Address:</LABEL>"
       "    <INPUT type='text' id='addressline1' value='123 Test st.'/>"
       "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->document().getElementById("form").to<WebFormElement>();
   ASSERT_FALSE(web_form.isNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
-                                       EXTRACT_NONE, &form, nullptr));
+                                       nullptr, EXTRACT_NONE, &form, nullptr));
 
   for (const FormFieldData& field : form.fields) {
     EXPECT_FALSE(field.should_autocomplete);
   }
 }
 
 // Tests that the |should_autocomplete| is set to false only for the field
 // which has an autocomplete='off' attribute set for it in HTML.
 TEST_F(FormAutofillTest, WebFormElementToFormData_AutocompleteOff_OnField) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post'>"
       "  <LABEL for='firstname'>First name:</LABEL>"
       "    <INPUT type='text' id='firstname' value='John' autocomplete='off'/>"
       "  <LABEL for='lastname'>Last name:</LABEL>"
       "    <INPUT type='text' id='lastname' value='Smith'/>"
       "  <LABEL for='street-address'>Address:</LABEL>"
       "    <INPUT type='text' id='addressline1' value='123 Test st.'/>"
       "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->document().getElementById("form").to<WebFormElement>();
   ASSERT_FALSE(web_form.isNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
-                                       EXTRACT_NONE, &form, nullptr));
+                                       nullptr, EXTRACT_NONE, &form, nullptr));
 
   ASSERT_EQ(3U, form.fields.size());
 
   EXPECT_FALSE(form.fields[0].should_autocomplete);
   EXPECT_TRUE(form.fields[1].should_autocomplete);
   EXPECT_TRUE(form.fields[2].should_autocomplete);
 }
 
 // Tests CSS classes are set.
 TEST_F(FormAutofillTest, WebFormElementToFormData_CssClasses) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post' "
       "autocomplete='off'>"
       "    <INPUT type='text' id='firstname' class='firstname_field' />"
       "    <INPUT type='text' id='lastname' class='lastname_field' />"
       "    <INPUT type='text' id='addressline1'  />"
       "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->document().getElementById("form").to<WebFormElement>();
   ASSERT_FALSE(web_form.isNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
-                                       EXTRACT_NONE, &form, nullptr));
+                                       nullptr, EXTRACT_NONE, &form, nullptr));
 
   EXPECT_EQ(3U, form.fields.size());
   EXPECT_EQ(ASCIIToUTF16("firstname_field"), form.fields[0].css_classes);
   EXPECT_EQ(ASCIIToUTF16("lastname_field"), form.fields[1].css_classes);
   EXPECT_EQ(base::string16(), form.fields[2].css_classes);
 }
 
 TEST_F(FormAutofillTest, ExtractForms) {
   ExpectJohnSmithLabels(
       "<FORM name='TestForm' action='http://cnn.com' method='post'>"
@@ skipping 267 matching lines @@
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     WebVector<WebFormElement> web_forms;
     web_frame->document().forms(web_forms);
     ASSERT_EQ(1U, web_forms.size());
     WebFormElement web_form = web_forms[0];
 
     FormData form;
     EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
-                                         EXTRACT_NONE, &form, nullptr));
+                                         nullptr, EXTRACT_NONE, &form,
+                                         nullptr));
   }
 }
 
 TEST_F(FormAutofillTest, FindFormForInputElement) {
   TestFindFormForInputElement(
       "<FORM name='TestForm' action='http://abc.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='John'/>"
       "  <INPUT type='text' id='lastname' value='Smith'/>"
       "  <INPUT type='text' id='email' value='john@example.com'"
       "autocomplete='off' />"
@@ skipping 1266 matching lines @@
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->document().forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   FormData form;
-  EXPECT_TRUE(WebFormElementToFormData(forms[0],
-                                       WebFormControlElement(),
-                                       EXTRACT_VALUE,
-                                       &form,
-                                       nullptr));
+  EXPECT_TRUE(WebFormElementToFormData(forms[0], WebFormControlElement(),
+                                       nullptr, EXTRACT_VALUE, &form, nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GetCanonicalOriginForDocument(frame->document()), form.origin);
   EXPECT_FALSE(form.origin.is_empty());
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(4U, fields.size());
 
   FormFieldData expected;
   expected.form_control_type = "text";
@@ skipping 33 matching lines @@
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->document().forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   FormData form;
-  EXPECT_TRUE(WebFormElementToFormData(forms[0],
-                                       WebFormControlElement(),
-                                       EXTRACT_VALUE,
-                                       &form,
-                                       nullptr));
+  EXPECT_TRUE(WebFormElementToFormData(forms[0], WebFormControlElement(),
+                                       nullptr, EXTRACT_VALUE, &form, nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GetCanonicalOriginForDocument(frame->document()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(6U, fields.size());
 
   FormFieldData expected;
   expected.form_control_type = "text";
 
@@ skipping 321 matching lines @@
   select_element.setValue(WebString::fromUTF8("AL"));
 
   WebVector<WebFormElement> forms;
   frame->document().forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   FormData form;
 
   // Extract the country select-one value as text.
   EXPECT_TRUE(WebFormElementToFormData(
-      forms[0], WebFormControlElement(),
+      forms[0], WebFormControlElement(), nullptr,
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT), &form,
       nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GetCanonicalOriginForDocument(frame->document()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
@@ skipping 14 matching lines @@
 
   expected.name = ASCIIToUTF16("country");
   expected.value = ASCIIToUTF16("Albania");
   expected.label.clear();
   expected.form_control_type = "select-one";
   expected.max_length = 0;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
 
   form.fields.clear();
   // Extract the country select-one value as value.
-  EXPECT_TRUE(WebFormElementToFormData(forms[0],
-                                       WebFormControlElement(),
-                                       EXTRACT_VALUE,
-                                       &form,
-                                       nullptr));
+  EXPECT_TRUE(WebFormElementToFormData(forms[0], WebFormControlElement(),
+                                       nullptr, EXTRACT_VALUE, &form, nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GetCanonicalOriginForDocument(frame->document()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   ASSERT_EQ(3U, fields.size());
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("John");
   expected.label = ASCIIToUTF16("John");
   expected.form_control_type = "text";
@@ skipping 227 matching lines @@
 
     if (test_case.has_extracted_form) {
       EXPECT_EQ(test_case.is_form_tag, forms[0].is_form_tag);
       EXPECT_EQ(test_case.is_formless_checkout, forms[0].is_formless_checkout);
     }
   }
 }
 
 }  // namespace form_util
 }  // namespace autofill