Autofill: Modify various utility function to deal with unowned form fields.

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 <vector>
 
 #include "base/format_macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 39 matching lines @@
   const char* const name;
   const char* const initial_value;
   const char* const autocomplete_attribute;  // The autocomplete attribute of
                                              // the element.
   bool should_be_autofilled;   // Whether the filed should be autofilled.
   const char* const autofill_value;  // The value being used to fill the field.
   const char* const expected_value;  // The expected value after Autofill
                                      // or Preview.
 };
 
-static const char kFormHtml[] =
+const char kFormHtml[] =
     "<FORM name='TestForm' action='http://buh.com' method='post'>"
     "  <INPUT type='text' id='firstname'/>"
     "  <INPUT type='text' id='lastname'/>"
     "  <INPUT type='hidden' id='imhidden'/>"
     "  <INPUT type='text' id='notempty' value='Hi'/>"
     "  <INPUT type='text' autocomplete='off' id='noautocomplete'/>"
     "  <INPUT type='text' disabled='disabled' id='notenabled'/>"
     "  <INPUT type='text' readonly id='readonly'/>"
     "  <INPUT type='text' style='visibility: hidden'"
     "         id='invisible'/>"
@@ skipping 11 matching lines @@
     "  </SELECT>"
     "  <SELECT id='select-unchanged'>"
     "    <OPTION value='CA' selected>California</OPTION>"
     "    <OPTION value='TX'>Texas</OPTION>"
     "  </SELECT>"
     "  <TEXTAREA id='textarea'></TEXTAREA>"
     "  <TEXTAREA id='textarea-nonempty'>Go&#10;away!</TEXTAREA>"
     "  <INPUT type='submit' name='reply-send' value='Send'/>"
     "</FORM>";
 
+const char kUnownedFormHtml[] =
+    "<INPUT type='text' id='firstname'/>"
+    "<INPUT type='text' id='lastname'/>"
+    "<INPUT type='hidden' id='imhidden'/>"
+    "<INPUT type='text' id='notempty' value='Hi'/>"
+    "<INPUT type='text' autocomplete='off' id='noautocomplete'/>"
+    "<INPUT type='text' disabled='disabled' id='notenabled'/>"
+    "<INPUT type='text' readonly id='readonly'/>"
+    "<INPUT type='text' style='visibility: hidden'"
+    "       id='invisible'/>"
+    "<INPUT type='text' style='display: none' id='displaynone'/>"
+    "<INPUT type='month' id='month'/>"
+    "<INPUT type='month' id='month-nonempty' value='2011-12'/>"
+    "<SELECT id='select'>"
+    "  <OPTION></OPTION>"
+    "  <OPTION value='CA'>California</OPTION>"
+    "  <OPTION value='TX'>Texas</OPTION>"
+    "</SELECT>"
+    "<SELECT id='select-nonempty'>"
+    "  <OPTION value='CA' selected>California</OPTION>"
+    "  <OPTION value='TX'>Texas</OPTION>"
+    "</SELECT>"
+    "<SELECT id='select-unchanged'>"
+    "  <OPTION value='CA' selected>California</OPTION>"
+    "  <OPTION value='TX'>Texas</OPTION>"
+    "</SELECT>"
+    "<TEXTAREA id='textarea'></TEXTAREA>"
+    "<TEXTAREA id='textarea-nonempty'>Go&#10;away!</TEXTAREA>"
+    "<INPUT type='submit' name='reply-send' value='Send'/>";
+
 std::string RetrievalMethodToString(
     const WebElementDescriptor::RetrievalMethod& method) {
   switch (method) {
     case WebElementDescriptor::CSS_SELECTOR:
       return "CSS_SELECTOR";
     case WebElementDescriptor::ID:
       return "ID";
     case WebElementDescriptor::NONE:
       return "NONE";
   }
@@ skipping 104 matching lines @@
     values.push_back(ASCIIToUTF16("john@example.com"));
 
     ExpectLabels(html, labels, names, values);
   }
 
   typedef void (*FillFormFunction)(const FormData& form,
                                    const WebFormControlElement& element);
 
   typedef WebString (*GetValueFunction)(WebFormControlElement element);
 
+  bool FindFormAndField(WebFrame* web_frame,
+                        const blink::WebFormControlElement& element,
+                        bool unowned,
+                        RequirementsMask requirement_mask,
+                        FormData* form,
+                        FormFieldData* field) {
+    if (!unowned) {
+      return FindFormAndFieldForFormControlElement(element,
+                                                   form,
+                                                   field,
+                                                   requirement_mask);
+    }
+
+    WebDocument document = web_frame->document();
+    std::vector<WebElement> fieldsets;
+    std::vector<WebFormControlElement> control_elements =
+        GetUnownedAutofillableFormFieldElements(document.all(), &fieldsets);
+    ExtractMask extract_mask =
+        static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
+    return UnownedFormElementsAndFieldSetsToFormData(fieldsets,
+                                                     control_elements,
+                                                     &element,
+                                                     document.url(),
+                                                     requirement_mask,
+                                                     extract_mask,
+                                                     form,
+                                                     field);
+  }
+
   // Test FormFillxxx functions.
   void TestFormFillFunctions(const char* html,
+                             bool unowned,
                              const AutofillFieldCase* field_cases,
                              size_t number_of_field_cases,
                              FillFormFunction fill_form_function,
                              GetValueFunction get_value_function) {
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache;
     std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Find the form that contains the input element.
     FormData form_data;
     FormFieldData field;
-    EXPECT_TRUE(FindFormAndFieldForFormControlElement(
-        input_element, &form_data, &field, autofill::REQUIRE_NONE));
-    EXPECT_EQ(ASCIIToUTF16("TestForm"), form_data.name);
-    EXPECT_EQ(GURL(web_frame->document().url()), form_data.origin);
-    EXPECT_EQ(GURL("http://buh.com"), form_data.action);
+    EXPECT_TRUE(FindFormAndField(
+        web_frame, input_element, unowned, REQUIRE_NONE, &form_data, &field));
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form_data.name);
+      EXPECT_EQ(GURL("http://buh.com"), form_data.action);
+    }
 
     const std::vector<FormFieldData>& fields = form_data.fields;
     ASSERT_EQ(number_of_field_cases, fields.size());
 
     FormFieldData expected;
     // Verify field's initial value.
     for (size_t i = 0; i < number_of_field_cases; ++i) {
       SCOPED_TRACE(base::StringPrintf("Verify initial value for field %s",
                                       field_cases[i].name));
       expected.form_control_type = field_cases[i].form_control_type;
@@ skipping 48 matching lines @@
   WebFormControlElement GetFormControlElementById(const WebString& id) {
     return GetMainFrame()->document().getElementById(
         id).to<WebFormControlElement>();
   }
 
   WebInputElement GetInputElementById(const WebString& id) {
     return GetMainFrame()->document().getElementById(
         id).to<WebInputElement>();
   }
 
+  void TestFillForm(const char* html, bool unowned) {
+    static const AutofillFieldCase field_cases[] = {
+      // fields: form_control_type, name, initial_value, autocomplete_attribute,
+      //         should_be_autofilled, autofill_value, expected_value
+
+      // Regular empty fields (firstname & lastname) should be autofilled.
+      {"text",
+        "firstname",
+        "",
+        "",
+        true,
+        "filled firstname",
+        "filled firstname"},
+      {"text", "lastname", "", "", true, "filled lastname", "filled lastname"},
+      // hidden fields should not be extracted to form_data.
+      // Non empty fields should not be autofilled.
+      {"text", "notempty", "Hi", "", false, "filled notempty", "Hi"},
+      {"text",
+        "noautocomplete",
+        "",
+        "off",
+        true,
+        "filled noautocomplete",
+        "filled noautocomplete"},
+      // Disabled fields should not be autofilled.
+      {"text", "notenabled", "", "", false, "filled notenabled", ""},
+      // Readonly fields should not be autofilled.
+      {"text", "readonly", "", "", false, "filled readonly", ""},
+      // Fields with "visibility: hidden" should not be autofilled.
+      {"text", "invisible", "", "", false, "filled invisible", ""},
+      // Fields with "display:none" should not be autofilled.
+      {"text", "displaynone", "", "", false, "filled displaynone", ""},
+      // Regular <input type="month"> should be autofilled.
+      {"month", "month", "", "", true, "2017-11", "2017-11"},
+      // Non-empty <input type="month"> should not be autofilled.
+      {"month", "month-nonempty", "2011-12", "", false, "2017-11", "2011-12"},
+      // Regular select fields should be autofilled.
+      {"select-one", "select", "", "", true, "TX", "TX"},
+      // Select fields should be autofilled even if they already have a
+      // non-empty value.
+      {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
+      // Select fields should not be autofilled if no new value is passed from
+      // autofill profile. The existing value should not be overriden.
+      {"select-one", "select-unchanged", "CA", "", false, "CA", "CA"},
+      // Regular textarea elements should be autofilled.
+      {"textarea",
+        "textarea",
+        "",
+        "",
+        true,
+        "some multi-\nline value",
+        "some multi-\nline value"},
+      // Non-empty textarea elements should not be autofilled.
+      {"textarea",
+        "textarea-nonempty",
+        "Go\naway!",
+        "",
+        false,
+        "some multi-\nline value",
+        "Go\naway!"},
+    };
+    TestFormFillFunctions(html, unowned, field_cases, arraysize(field_cases),
+                          FillForm, &GetValueWrapper);
+    // Verify preview selection.
+    WebInputElement firstname = GetInputElementById("firstname");
+    EXPECT_EQ(16, firstname.selectionStart());
+    EXPECT_EQ(16, firstname.selectionEnd());
+  }
+
+  void TestPreviewForm(const char* html, bool unowned) {
+    static const AutofillFieldCase field_cases[] = {
+      // Normal empty fields should be previewed.
+      {"text",
+        "firstname",
+        "",
+        "",
+        true,
+        "suggested firstname",
+        "suggested firstname"},
+      {"text",
+        "lastname",
+        "",
+        "",
+        true,
+        "suggested lastname",
+        "suggested lastname"},
+      // Hidden fields should not be extracted to form_data.
+      // Non empty fields should not be previewed.
+      {"text", "notempty", "Hi", "", false, "suggested notempty", ""},
+      {"text",
+        "noautocomplete",
+        "",
+        "off",
+        true,
+        "filled noautocomplete",
+        "filled noautocomplete"},
+      // Disabled fields should not be previewed.
+      {"text", "notenabled", "", "", false, "suggested notenabled", ""},
+      // Readonly fields should not be previewed.
+      {"text", "readonly", "", "", false, "suggested readonly", ""},
+      // Fields with "visibility: hidden" should not be previewed.
+      {"text", "invisible", "", "", false, "suggested invisible", ""},
+      // Fields with "display:none" should not previewed.
+      {"text", "displaynone", "", "", false, "suggested displaynone", ""},
+      // Regular <input type="month"> should be previewed.
+      {"month", "month", "", "", true, "2017-11", "2017-11"},
+      // Non-empty <input type="month"> should not be previewed.
+      {"month", "month-nonempty", "2011-12", "", false, "2017-11", ""},
+      // Regular select fields should be previewed.
+      {"select-one", "select", "", "", true, "TX", "TX"},
+      // Select fields should be previewed even if they already have a
+      // non-empty value.
+      {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
+      // Select fields should not be previewed if no suggestion is passed from
+      // autofill profile.
+      {"select-one", "select-unchanged", "CA", "", false, "", ""},
+      // Normal textarea elements should be previewed.
+      {"textarea",
+        "textarea",
+        "",
+        "",
+        true,
+        "suggested multi-\nline value",
+        "suggested multi-\nline value"},
+      // Nonempty textarea elements should not be previewed.
+      {"textarea",
+        "textarea-nonempty",
+        "Go\naway!",
+        "",
+        false,
+        "suggested multi-\nline value",
+        ""},
+    };
+    TestFormFillFunctions(html, unowned, field_cases, arraysize(field_cases),
+                          &PreviewForm, &GetSuggestedValueWrapper);
+
+    // Verify preview selection.
+    WebInputElement firstname = GetInputElementById("firstname");
+    EXPECT_EQ(0, firstname.selectionStart());
+    EXPECT_EQ(19, firstname.selectionEnd());
+  }
+
+  void TestFindFormForInputElement(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Get the input element we want to find.
+    WebInputElement input_element = GetInputElementById("firstname");
+
+    // Find the form and verify it's the correct form.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(4U, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("John");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Smith");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value = ASCIIToUTF16("john@example.com");
+    expected.autocomplete_attribute = "off";
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+    expected.autocomplete_attribute.clear();
+
+    expected.name = ASCIIToUTF16("phone");
+    expected.value = ASCIIToUTF16("1.800.555.1234");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
+
+    // Try again, but require autocomplete.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_AUTOCOMPLETE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
+      EXPECT_EQ(GURL("http://buh.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(3U, fields2.size());
+
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("John");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Smith");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
+
+    expected.name = ASCIIToUTF16("phone");
+    expected.value = ASCIIToUTF16("1.800.555.1234");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+  }
+
+  void TestFindFormForTextAreaElement(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Get the textarea element we want to find.
+    WebElement element = web_frame->document().getElementById("street-address");
+    WebTextAreaElement textarea_element = element.to<WebTextAreaElement>();
+
+    // Find the form and verify it's the correct form.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, textarea_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(4U, fields.size());
+
+    FormFieldData expected;
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("John");
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Smith");
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value = ASCIIToUTF16("john@example.com");
+    expected.autocomplete_attribute = "off";
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+    expected.autocomplete_attribute.clear();
+
+    expected.name = ASCIIToUTF16("street-address");
+    expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
+    expected.form_control_type = "textarea";
+    expected.max_length = 0;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
+
+    // Try again, but require autocomplete.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, textarea_element, unowned,
+                                 REQUIRE_AUTOCOMPLETE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
+      EXPECT_EQ(GURL("http://buh.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(3U, fields2.size());
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("John");
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Smith");
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
+
+    expected.name = ASCIIToUTF16("street-address");
+    expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
+    expected.form_control_type = "textarea";
+    expected.max_length = 0;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
+  }
+
+  void TestFillFormMaxLength(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Get the input element we want to find.
+    WebInputElement input_element = GetInputElementById("firstname");
+
+    // Find the form that contains the input element.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(3U, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.max_length = 5;
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.max_length = 7;
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.max_length = 9;
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+
+    // Fill the form.
+    form.fields[0].value = ASCIIToUTF16("Brother");
+    form.fields[1].value = ASCIIToUTF16("Jonathan");
+    form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
+    form.fields[0].is_autofilled = true;
+    form.fields[1].is_autofilled = true;
+    form.fields[2].is_autofilled = true;
+    FillForm(form, input_element);
+
+    // Find the newly-filled form that contains the input element.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
+      EXPECT_EQ(GURL("http://buh.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(3U, fields2.size());
+
+    expected.form_control_type = "text";
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("Broth");
+    expected.max_length = 5;
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Jonatha");
+    expected.max_length = 7;
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value = ASCIIToUTF16("brotherj@");
+    expected.max_length = 9;
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+  }
+
+  void TestFillFormNegativeMaxLength(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Get the input element we want to find.
+    WebInputElement input_element = GetInputElementById("firstname");
+
+    // Find the form that contains the input element.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(3U, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+
+    // Fill the form.
+    form.fields[0].value = ASCIIToUTF16("Brother");
+    form.fields[1].value = ASCIIToUTF16("Jonathan");
+    form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
+    FillForm(form, input_element);
+
+    // Find the newly-filled form that contains the input element.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
+      EXPECT_EQ(GURL("http://buh.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(3U, fields2.size());
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("Brother");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Jonathan");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value = ASCIIToUTF16("brotherj@example.com");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+  }
+
+  void TestFillFormEmptyName(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Get the input element we want to find.
+    WebInputElement input_element = GetInputElementById("firstname");
+
+    // Find the form that contains the input element.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(3U, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+
+    // Fill the form.
+    form.fields[0].value = ASCIIToUTF16("Wyatt");
+    form.fields[1].value = ASCIIToUTF16("Earp");
+    form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
+    FillForm(form, input_element);
+
+    // Find the newly-filled form that contains the input element.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
+      EXPECT_EQ(GURL("http://buh.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(3U, fields2.size());
+
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("Wyatt");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Earp");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value = ASCIIToUTF16("wyatt@example.com");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+  }
+
+  void TestFillFormEmptyFormNames(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    const size_t expected_size = unowned ? 1 : 2;
+    ASSERT_EQ(expected_size, forms.size());
+
+    // Get the input element we want to find.
+    WebInputElement input_element = GetInputElementById("apple");
+
+    // Find the form that contains the input element.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_TRUE(form.name.empty());
+      EXPECT_EQ(GURL("http://abc.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    const size_t unowned_offset = unowned ? 3 : 0;
+    ASSERT_EQ(unowned_offset + 3, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("apple");
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[unowned_offset]);
+
+    expected.name = ASCIIToUTF16("banana");
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[unowned_offset + 1]);
+
+    expected.name = ASCIIToUTF16("cantelope");
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[unowned_offset + 2]);
+
+    // Fill the form.
+    form.fields[unowned_offset + 0].value = ASCIIToUTF16("Red");
+    form.fields[unowned_offset + 1].value = ASCIIToUTF16("Yellow");
+    form.fields[unowned_offset + 2].value = ASCIIToUTF16("Also Yellow");
+    form.fields[unowned_offset + 0].is_autofilled = true;
+    form.fields[unowned_offset + 1].is_autofilled = true;
+    form.fields[unowned_offset + 2].is_autofilled = true;
+    FillForm(form, input_element);
+
+    // Find the newly-filled form that contains the input element.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_TRUE(form2.name.empty());
+      EXPECT_EQ(GURL("http://abc.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(unowned_offset + 3, fields2.size());
+
+    expected.name = ASCIIToUTF16("apple");
+    expected.value = ASCIIToUTF16("Red");
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 0]);
+
+    expected.name = ASCIIToUTF16("banana");
+    expected.value = ASCIIToUTF16("Yellow");
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 1]);
+
+    expected.name = ASCIIToUTF16("cantelope");
+    expected.value = ASCIIToUTF16("Also Yellow");
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 2]);
+  }
+
+  void TestFillFormNonEmptyField(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Get the input element we want to find.
+    WebInputElement input_element = GetInputElementById("firstname");
+
+    // Simulate typing by modifying the field value.
+    input_element.setValue(ASCIIToUTF16("Wy"));
+
+    // Find the form that contains the input element.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(3U, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("Wy");
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value.clear();
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value.clear();
+    expected.is_autofilled = false;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+
+    // Preview the form and verify that the cursor position has been updated.
+    form.fields[0].value = ASCIIToUTF16("Wyatt");
+    form.fields[1].value = ASCIIToUTF16("Earp");
+    form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
+    form.fields[0].is_autofilled = true;
+    form.fields[1].is_autofilled = true;
+    form.fields[2].is_autofilled = true;
+    PreviewForm(form, input_element);
+    EXPECT_EQ(2, input_element.selectionStart());
+    EXPECT_EQ(5, input_element.selectionEnd());
+
+    // Fill the form.
+    FillForm(form, input_element);
+
+    // Find the newly-filled form that contains the input element.
+    FormData form2;
+    FormFieldData field2;
+    EXPECT_TRUE(FindFormAndField(web_frame, input_element, unowned,
+                                 REQUIRE_NONE, &form2, &field2));
+    EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
+      EXPECT_EQ(GURL("http://buh.com"), form2.action);
+    }
+
+    const std::vector<FormFieldData>& fields2 = form2.fields;
+    ASSERT_EQ(3U, fields2.size());
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value = ASCIIToUTF16("Wyatt");
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value = ASCIIToUTF16("Earp");
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
+
+    expected.name = ASCIIToUTF16("email");
+    expected.value = ASCIIToUTF16("wyatt@example.com");
+    expected.is_autofilled = true;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+
+    // Verify that the cursor position has been updated.
+    EXPECT_EQ(5, input_element.selectionStart());
+    EXPECT_EQ(5, input_element.selectionEnd());
+  }
+
+  void TestClearFormWithNode(const char* html, bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Set the auto-filled attribute.
+    WebInputElement firstname = GetInputElementById("firstname");
+    firstname.setAutofilled(true);
+    WebInputElement lastname = GetInputElementById("lastname");
+    lastname.setAutofilled(true);
+    WebInputElement month = GetInputElementById("month");
+    month.setAutofilled(true);
+    WebInputElement textarea = GetInputElementById("textarea");
+    textarea.setAutofilled(true);
+
+    // Set the value of the disabled text input element.
+    WebInputElement notenabled = GetInputElementById("notenabled");
+    notenabled.setValue(WebString::fromUTF8("no clear"));
+
+    // Clear the form.
+    EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
+
+    // Verify that the auto-filled attribute has been turned off.
+    EXPECT_FALSE(firstname.isAutofilled());
+
+    // Verify the form is cleared.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, firstname, unowned, REQUIRE_NONE,
+                                 &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(9U, fields.size());
+
+    FormFieldData expected;
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value.clear();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value.clear();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("noAC");
+    expected.value = ASCIIToUTF16("one");
+    expected.autocomplete_attribute = "off";
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+    expected.autocomplete_attribute.clear();
+
+    expected.name = ASCIIToUTF16("notenabled");
+    expected.value = ASCIIToUTF16("no clear");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
+
+    expected.form_control_type = "month";
+    expected.max_length = 0;
+    expected.name = ASCIIToUTF16("month");
+    expected.value.clear();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[4]);
+
+    expected.name = ASCIIToUTF16("month-disabled");
+    expected.value = ASCIIToUTF16("2012-11");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]);
+
+    expected.form_control_type = "textarea";
+    expected.name = ASCIIToUTF16("textarea");
+    expected.value.clear();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[6]);
+
+    expected.name = ASCIIToUTF16("textarea-disabled");
+    expected.value = ASCIIToUTF16("    Banana!  ");
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[7]);
+
+    expected.name = ASCIIToUTF16("textarea-noAC");
+    expected.value = ASCIIToUTF16("Carrot?");
+    expected.autocomplete_attribute = "off";
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[8]);
+    expected.autocomplete_attribute.clear();
+
+    // Verify that the cursor position has been updated.
+    EXPECT_EQ(0, firstname.selectionStart());
+    EXPECT_EQ(0, firstname.selectionEnd());
+  }
+
+  void TestClearFormWithNodeContainingSelectOne(const char* html,
+                                                bool unowned) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Set the auto-filled attribute.
+    WebInputElement firstname = GetInputElementById("firstname");
+    firstname.setAutofilled(true);
+    WebInputElement lastname = GetInputElementById("lastname");
+    lastname.setAutofilled(true);
+
+    // Set the value and auto-filled attribute of the state element.
+    WebSelectElement state =
+        web_frame->document().getElementById("state").to<WebSelectElement>();
+    state.setValue(WebString::fromUTF8("AK"));
+    state.setAutofilled(true);
+
+    // Clear the form.
+    EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
+
+    // Verify that the auto-filled attribute has been turned off.
+    EXPECT_FALSE(firstname.isAutofilled());
+
+    // Verify the form is cleared.
+    FormData form;
+    FormFieldData field;
+    EXPECT_TRUE(FindFormAndField(web_frame, firstname, unowned, REQUIRE_NONE,
+                                 &form, &field));
+    EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
+    if (!unowned) {
+      EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
+      EXPECT_EQ(GURL("http://buh.com"), form.action);
+    }
+
+    const std::vector<FormFieldData>& fields = form.fields;
+    ASSERT_EQ(3U, fields.size());
+
+    FormFieldData expected;
+
+    expected.name = ASCIIToUTF16("firstname");
+    expected.value.clear();
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
+
+    expected.name = ASCIIToUTF16("lastname");
+    expected.value.clear();
+    expected.form_control_type = "text";
+    expected.max_length = WebInputElement::defaultMaxLength();
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
+
+    expected.name = ASCIIToUTF16("state");
+    expected.value = ASCIIToUTF16("?");
+    expected.form_control_type = "select-one";
+    expected.max_length = 0;
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+
+    // Verify that the cursor position has been updated.
+    EXPECT_EQ(0, firstname.selectionStart());
+    EXPECT_EQ(0, firstname.selectionEnd());
+  }
+
+  void TestClearPreviewedFormWithElement(const char* html) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Set the auto-filled attribute.
+    WebInputElement firstname = GetInputElementById("firstname");
+    firstname.setAutofilled(true);
+    WebInputElement lastname = GetInputElementById("lastname");
+    lastname.setAutofilled(true);
+    WebInputElement email = GetInputElementById("email");
+    email.setAutofilled(true);
+    WebInputElement email2 = GetInputElementById("email2");
+    email2.setAutofilled(true);
+    WebInputElement phone = GetInputElementById("phone");
+    phone.setAutofilled(true);
+
+    // Set the suggested values on two of the elements.
+    lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
+    email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
+    email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
+    phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
+
+    // Clear the previewed fields.
+    EXPECT_TRUE(ClearPreviewedFormWithElement(lastname, false));
+
+    // Fields with empty suggestions suggestions are not modified.
+    EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
+    EXPECT_TRUE(firstname.suggestedValue().isEmpty());
+    EXPECT_TRUE(firstname.isAutofilled());
+
+    // Verify the previewed fields are cleared.
+    EXPECT_TRUE(lastname.value().isEmpty());
+    EXPECT_TRUE(lastname.suggestedValue().isEmpty());
+    EXPECT_FALSE(lastname.isAutofilled());
+    EXPECT_TRUE(email.value().isEmpty());
+    EXPECT_TRUE(email.suggestedValue().isEmpty());
+    EXPECT_FALSE(email.isAutofilled());
+    EXPECT_TRUE(email2.value().isEmpty());
+    EXPECT_TRUE(email2.suggestedValue().isEmpty());
+    EXPECT_FALSE(email2.isAutofilled());
+    EXPECT_TRUE(phone.value().isEmpty());
+    EXPECT_TRUE(phone.suggestedValue().isEmpty());
+    EXPECT_FALSE(phone.isAutofilled());
+
+    // Verify that the cursor position has been updated.
+    EXPECT_EQ(0, lastname.selectionStart());
+    EXPECT_EQ(0, lastname.selectionEnd());
+  }
+
+  void TestClearPreviewedFormWithNonEmptyInitiatingNode(const char* html) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Set the auto-filled attribute.
+    WebInputElement firstname = GetInputElementById("firstname");
+    firstname.setAutofilled(true);
+    WebInputElement lastname = GetInputElementById("lastname");
+    lastname.setAutofilled(true);
+    WebInputElement email = GetInputElementById("email");
+    email.setAutofilled(true);
+    WebInputElement email2 = GetInputElementById("email2");
+    email2.setAutofilled(true);
+    WebInputElement phone = GetInputElementById("phone");
+    phone.setAutofilled(true);
+
+
+    // Set the suggested values on all of the elements.
+    firstname.setSuggestedValue(ASCIIToUTF16("Wyatt"));
+    lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
+    email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
+    email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
+    phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
+
+    // Clear the previewed fields.
+    EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, false));
+
+    // Fields with non-empty values are restored.
+    EXPECT_EQ(ASCIIToUTF16("W"), firstname.value());
+    EXPECT_TRUE(firstname.suggestedValue().isEmpty());
+    EXPECT_FALSE(firstname.isAutofilled());
+    EXPECT_EQ(1, firstname.selectionStart());
+    EXPECT_EQ(1, firstname.selectionEnd());
+
+    // Verify the previewed fields are cleared.
+    EXPECT_TRUE(lastname.value().isEmpty());
+    EXPECT_TRUE(lastname.suggestedValue().isEmpty());
+    EXPECT_FALSE(lastname.isAutofilled());
+    EXPECT_TRUE(email.value().isEmpty());
+    EXPECT_TRUE(email.suggestedValue().isEmpty());
+    EXPECT_FALSE(email.isAutofilled());
+    EXPECT_TRUE(email2.value().isEmpty());
+    EXPECT_TRUE(email2.suggestedValue().isEmpty());
+    EXPECT_FALSE(email2.isAutofilled());
+    EXPECT_TRUE(phone.value().isEmpty());
+    EXPECT_TRUE(phone.suggestedValue().isEmpty());
+    EXPECT_FALSE(phone.isAutofilled());
+  }
+
+  void TestClearPreviewedFormWithAutofilledInitiatingNode(const char* html) {
+    LoadHTML(html);
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Set the auto-filled attribute.
+    WebInputElement firstname = GetInputElementById("firstname");
+    firstname.setAutofilled(true);
+    WebInputElement lastname = GetInputElementById("lastname");
+    lastname.setAutofilled(true);
+    WebInputElement email = GetInputElementById("email");
+    email.setAutofilled(true);
+    WebInputElement email2 = GetInputElementById("email2");
+    email2.setAutofilled(true);
+    WebInputElement phone = GetInputElementById("phone");
+    phone.setAutofilled(true);
+
+    // Set the suggested values on all of the elements.
+    firstname.setSuggestedValue(ASCIIToUTF16("Wyatt"));
+    lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
+    email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
+    email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
+    phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
+
+    // Clear the previewed fields.
+    EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, true));
+
+    // Fields with non-empty values are restored.
+    EXPECT_EQ(ASCIIToUTF16("W"), firstname.value());
+    EXPECT_TRUE(firstname.suggestedValue().isEmpty());
+    EXPECT_TRUE(firstname.isAutofilled());
+    EXPECT_EQ(1, firstname.selectionStart());
+    EXPECT_EQ(1, firstname.selectionEnd());
+
+    // Verify the previewed fields are cleared.
+    EXPECT_TRUE(lastname.value().isEmpty());
+    EXPECT_TRUE(lastname.suggestedValue().isEmpty());
+    EXPECT_FALSE(lastname.isAutofilled());
+    EXPECT_TRUE(email.value().isEmpty());
+    EXPECT_TRUE(email.suggestedValue().isEmpty());
+    EXPECT_FALSE(email.isAutofilled());
+    EXPECT_TRUE(email2.value().isEmpty());
+    EXPECT_TRUE(email2.suggestedValue().isEmpty());
+    EXPECT_FALSE(email2.isAutofilled());
+    EXPECT_TRUE(phone.value().isEmpty());
+    EXPECT_TRUE(phone.suggestedValue().isEmpty());
+    EXPECT_FALSE(phone.isAutofilled());
+  }
+
+  void TestClearOnlyAutofilledFields(const char* html) {
+    LoadHTML(html);
+
+    WebFrame* web_frame = GetMainFrame();
+    ASSERT_NE(nullptr, web_frame);
+
+    FormCache form_cache;
+    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    ASSERT_EQ(1U, forms.size());
+
+    // Set the autofilled attribute.
+    WebInputElement firstname = GetInputElementById("firstname");
+    firstname.setAutofilled(false);
+    WebInputElement lastname = GetInputElementById("lastname");
+    lastname.setAutofilled(true);
+    WebInputElement email = GetInputElementById("email");
+    email.setAutofilled(true);
+    WebInputElement phone = GetInputElementById("phone");
+    phone.setAutofilled(true);
+
+    // Clear the fields.
+    EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
+
+    // Verify only autofilled fields are cleared.
+    EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
+    EXPECT_TRUE(firstname.suggestedValue().isEmpty());
+    EXPECT_FALSE(firstname.isAutofilled());
+    EXPECT_TRUE(lastname.value().isEmpty());
+    EXPECT_TRUE(lastname.suggestedValue().isEmpty());
+    EXPECT_FALSE(lastname.isAutofilled());
+    EXPECT_TRUE(email.value().isEmpty());
+    EXPECT_TRUE(email.suggestedValue().isEmpty());
+    EXPECT_FALSE(email.isAutofilled());
+    EXPECT_TRUE(phone.value().isEmpty());
+    EXPECT_TRUE(phone.suggestedValue().isEmpty());
+    EXPECT_FALSE(phone.isAutofilled());
+  }
+
   static void FillFormIncludingNonFocusableElementsWrapper(
       const FormData& form,
       const WebFormControlElement& element) {
     FillFormIncludingNonFocusableElements(form, element.form());
   }
 
   static WebString GetValueWrapper(WebFormControlElement element) {
     if (element.formControlType() == "textarea")
       return element.to<WebTextAreaElement>().value();
 
@@ skipping 19 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, autofill::EXTRACT_NONE, &result1);
+  WebFormControlElementToFormField(element, EXTRACT_NONE, &result1);
 
   FormFieldData expected;
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("element");
-  expected.value = base::string16();
+  expected.value.clear();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
 
   FormFieldData result2;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result2);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("checkbox");
   expected.value = ASCIIToUTF16("mail");
   expected.form_control_type = "checkbox";
   expected.is_autofilled = true;
   expected.is_checkable = true;
   expected.is_checked = true;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
   element = GetInputElementById("radio");
   element.setAutofilled(true);
-  WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("radio");
   expected.value = ASCIIToUTF16("male");
   expected.form_control_type = "radio";
   expected.is_autofilled = true;
   expected.is_checkable = true;
   expected.is_checked = false;
   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, autofill::EXTRACT_VALUE, &result1);
+  WebFormControlElementToFormField(element, 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<autofill::ExtractMask>(autofill::EXTRACT_VALUE |
-                                         autofill::EXTRACT_OPTION_TEXT),
+      static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
       &result2);
   expected.value = ASCIIToUTF16("California");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2);
 
   FormFieldData result3;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_OPTIONS,
-                                   &result3);
-  expected.value = base::string16();
+  WebFormControlElementToFormField(element, 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]);
 }
 
 // When faced with <select> field with *many* options, we should trim them to a
 // reasonable number.
 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldLongSelect) {
   std::string html = "<SELECT id='element'/>";
   for (size_t i = 0; i < 2 * kMaxListSize; ++i) {
     html += base::StringPrintf("<OPTION value='%" PRIuS "'>"
                                "%" PRIuS "</OPTION>", i, i);
   }
   html += "</SELECT>";
   LoadHTML(html.c_str());
 
   WebFrame* frame = GetMainFrame();
   ASSERT_TRUE(frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_OPTIONS, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_NONE,
-                                   &result_sans_value);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE,
-                                   &result_with_value);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_NONE,
-                                   &result_sans_value);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE,
-                                   &result_with_value);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_NONE, &result);
+    WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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, autofill::EXTRACT_VALUE, &result);
+  WebFormControlElementToFormField(element, 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 22 matching lines @@
   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,
-                                       autofill::REQUIRE_NONE,
-                                       autofill::EXTRACT_VALUE,
+                                       REQUIRE_NONE,
+                                       EXTRACT_VALUE,
                                        &form,
                                        &field));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->document().url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(6U, fields.size());
 
   FormFieldData expected;
@@ skipping 37 matching lines @@
   expected.label = ASCIIToUTF16("Card expiration:");
   expected.form_control_type = "month";
   expected.max_length = 0;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]);
 }
 
 // We should not be able to serialize a form with too many fillable fields.
 TEST_F(FormAutofillTest, WebFormElementToFormDataTooManyFields) {
   std::string html =
       "<FORM name='TestForm' action='http://cnn.com' method='post'>";
-  for (size_t i = 0; i < (autofill::kMaxParseableFields + 1); ++i) {
+  for (size_t i = 0; i < (kMaxParseableFields + 1); ++i) {
     html += "<INPUT type='text'/>";
   }
   html += "</FORM>";
   LoadHTML(html.c_str());
 
   WebFrame* frame = GetMainFrame();
   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,
-                                        autofill::REQUIRE_NONE,
-                                        autofill::EXTRACT_VALUE,
+                                        REQUIRE_NONE,
+                                        EXTRACT_VALUE,
                                         &form,
                                         &field));
 }
 
 TEST_F(FormAutofillTest, ExtractForms) {
   ExpectJohnSmithLabels(
       "<FORM name='TestForm' action='http://cnn.com' method='post'>"
       "  First name: <INPUT type='text' id='firstname' value='John'/>"
       "  Last name: <INPUT type='text' id='lastname' value='Smith'/>"
       "  Email: <INPUT type='text' id='email' value='john@example.com'/>"
@@ skipping 247 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(), autofill::REQUIRE_NONE,
-        autofill::EXTRACT_NONE, &form, NULL));
+        web_form, WebFormControlElement(), REQUIRE_NONE, EXTRACT_NONE, &form,
+        nullptr));
     EXPECT_FALSE(WebFormElementToFormData(
-        web_form, WebFormControlElement(), autofill::REQUIRE_AUTOCOMPLETE,
-        autofill::EXTRACT_NONE, &form, NULL));
+        web_form, WebFormControlElement(), REQUIRE_AUTOCOMPLETE, EXTRACT_NONE,
+        &form, nullptr));
   }
 
   {
     // The firstname element is not auto-completable due to autocomplete=off.
     LoadHTML("<FORM name='TestForm' action='http://abc.com' "
              "      method='post'>"
              "  <INPUT type='text' id='firstname' value='John'"
              "   autocomplete=off>"
              "  <INPUT type='text' id='middlename' value='Jack'/>"
              "  <INPUT type='text' id='lastname' value='Smith'/>"
              "  <INPUT type='text' id='email' value='john@example.com'/>"
              "  <INPUT type='submit' name='reply' value='Send'/>"
              "</FORM>");
 
     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(), autofill::REQUIRE_AUTOCOMPLETE,
-        autofill::EXTRACT_VALUE, &form, NULL));
+        web_form, WebFormControlElement(), REQUIRE_AUTOCOMPLETE, EXTRACT_VALUE,
+        &form, nullptr));
 
     EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
     EXPECT_EQ(GURL("http://abc.com"), form.action);
 
     const std::vector<FormFieldData>& fields = form.fields;
     ASSERT_EQ(3U, fields.size());
 
     FormFieldData expected;
     expected.form_control_type = "text";
     expected.max_length = WebInputElement::defaultMaxLength();
 
     expected.name = ASCIIToUTF16("middlename");
     expected.value = ASCIIToUTF16("Jack");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
 
     expected.name = ASCIIToUTF16("lastname");
     expected.value = ASCIIToUTF16("Smith");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
     expected.name = ASCIIToUTF16("email");
     expected.value = ASCIIToUTF16("john@example.com");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
   }
 }
 
 TEST_F(FormAutofillTest, FindFormForInputElement) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.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' />"
-           "  <INPUT type='text' id='phone' value='1.800.555.1234'/>"
-           "  <INPUT type='submit' name='reply-send' value='Send'/>"
-           "</FORM>");
+  TestFindFormForInputElement(
+      "<FORM name='TestForm' action='http://buh.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' />"
+      "  <INPUT type='text' id='phone' value='1.800.555.1234'/>"
+      "  <INPUT type='submit' name='reply-send' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Get the input element we want to find.
-  WebInputElement input_element = GetInputElementById("firstname");
-
-  // Find the form and verify it's the correct form.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(4U, fields.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("John");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Smith");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = ASCIIToUTF16("john@example.com");
-  expected.autocomplete_attribute = "off";
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-  expected.autocomplete_attribute = std::string();  // reset
-
-  expected.name = ASCIIToUTF16("phone");
-  expected.value = ASCIIToUTF16("1.800.555.1234");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
-
-  // Try again, but require autocomplete.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(
-      input_element,
-      &form2,
-      &field2,
-      autofill::REQUIRE_AUTOCOMPLETE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("John");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Smith");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("phone");
-  expected.value = ASCIIToUTF16("1.800.555.1234");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+TEST_F(FormAutofillTest, FindFormForInputElementForUnownedForm) {
+    TestFindFormForInputElement(
+        "<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' />"
+        "<INPUT type='text' id='phone' value='1.800.555.1234'/>"
+        "<INPUT type='submit' name='reply-send' value='Send'/>",
+        true);
 }
 
 TEST_F(FormAutofillTest, FindFormForTextAreaElement) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.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' />"
-           "  <TEXTAREA id='street-address'>"
-               "123 Fantasy Ln.&#10;"
-               "Apt. 42"
-             "</TEXTAREA>"
-           "  <INPUT type='submit' name='reply-send' value='Send'/>"
-           "</FORM>");
+  TestFindFormForTextAreaElement(
+      "<FORM name='TestForm' action='http://buh.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' />"
+      "  <TEXTAREA id='street-address'>"
+      "123 Fantasy Ln.&#10;"
+      "Apt. 42"
+      "</TEXTAREA>"
+      "  <INPUT type='submit' name='reply-send' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Get the textarea element we want to find.
-  WebElement element = web_frame->document().getElementById("street-address");
-  WebTextAreaElement textarea_element = element.to<WebTextAreaElement>();
-
-  // Find the form and verify it's the correct form.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(textarea_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(4U, fields.size());
-
-  FormFieldData expected;
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("John");
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Smith");
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = ASCIIToUTF16("john@example.com");
-  expected.autocomplete_attribute = "off";
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-  expected.autocomplete_attribute = std::string();  // reset
-
-  expected.name = ASCIIToUTF16("street-address");
-  expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
-  expected.form_control_type = "textarea";
-  expected.max_length = 0;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
-
-  // Try again, but require autocomplete.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(
-      textarea_element,
-      &form2,
-      &field2,
-      autofill::REQUIRE_AUTOCOMPLETE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("John");
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Smith");
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("street-address");
-  expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
-  expected.form_control_type = "textarea";
-  expected.max_length = 0;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
+TEST_F(FormAutofillTest, FindFormForTextAreaElementForUnownedForm) {
+  TestFindFormForTextAreaElement(
+      "<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' />"
+      "<TEXTAREA id='street-address'>"
+      "123 Fantasy Ln.&#10;"
+      "Apt. 42"
+      "</TEXTAREA>"
+      "<INPUT type='submit' name='reply-send' value='Send'/>",
+      true);
 }
 
 // Test regular FillForm function.
 TEST_F(FormAutofillTest, FillForm) {
-  static const AutofillFieldCase field_cases[] = {
-      // fields: form_control_type, name, initial_value, autocomplete_attribute,
-      //         should_be_autofilled, autofill_value, expected_value
+  TestFillForm(kFormHtml, false);
+}
 
-      // Regular empty fields (firstname & lastname) should be autofilled.
-      {"text",
-       "firstname",
-       "",
-       "",
-       true,
-       "filled firstname",
-       "filled firstname"},
-      {"text", "lastname", "", "", true, "filled lastname", "filled lastname"},
-      // hidden fields should not be extracted to form_data.
-      // Non empty fields should not be autofilled.
-      {"text", "notempty", "Hi", "", false, "filled notempty", "Hi"},
-      {"text",
-       "noautocomplete",
-       "",
-       "off",
-       true,
-       "filled noautocomplete",
-       "filled noautocomplete"},
-      // Disabled fields should not be autofilled.
-      {"text", "notenabled", "", "", false, "filled notenabled", ""},
-      // Readonly fields should not be autofilled.
-      {"text", "readonly", "", "", false, "filled readonly", ""},
-      // Fields with "visibility: hidden" should not be autofilled.
-      {"text", "invisible", "", "", false, "filled invisible", ""},
-      // Fields with "display:none" should not be autofilled.
-      {"text", "displaynone", "", "", false, "filled displaynone", ""},
-      // Regular <input type="month"> should be autofilled.
-      {"month", "month", "", "", true, "2017-11", "2017-11"},
-      // Non-empty <input type="month"> should not be autofilled.
-      {"month", "month-nonempty", "2011-12", "", false, "2017-11", "2011-12"},
-      // Regular select fields should be autofilled.
-      {"select-one", "select", "", "", true, "TX", "TX"},
-      // Select fields should be autofilled even if they already have a
-      // non-empty value.
-      {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
-      // Select fields should not be autofilled if no new value is passed from
-      // autofill profile. The existing value should not be overriden.
-      {"select-one", "select-unchanged", "CA", "", false, "CA", "CA"},
-      // Regular textarea elements should be autofilled.
-      {"textarea",
-       "textarea",
-       "",
-       "",
-       true,
-       "some multi-\nline value",
-       "some multi-\nline value"},
-      // Non-empty textarea elements should not be autofilled.
-      {"textarea",
-       "textarea-nonempty",
-       "Go\naway!",
-       "",
-       false,
-       "some multi-\nline value",
-       "Go\naway!"},
-  };
-  TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
-                        FillForm, &GetValueWrapper);
-  // Verify preview selection.
-  WebInputElement firstname = GetInputElementById("firstname");
-  EXPECT_EQ(16, firstname.selectionStart());
-  EXPECT_EQ(16, firstname.selectionEnd());
+TEST_F(FormAutofillTest, FillFormForUnownedForm) {
+  TestFillForm(kUnownedFormHtml, true);
 }
 
 TEST_F(FormAutofillTest, FillFormIncludingNonFocusableElements) {
   static const AutofillFieldCase field_cases[] = {
       // fields: form_control_type, name, initial_value, autocomplete_attribute,
       //         should_be_autofilled, autofill_value, expected_value
 
       // Regular empty fields (firstname & lastname) should be autofilled.
       {"text",
        "firstname",
@@ skipping 61 matching lines @@
        "some multi-\nline value"},
       // Nonempty textarea elements should be overridden.
       {"textarea",
        "textarea-nonempty",
        "Go\naway!",
        "",
        true,
        "some multi-\nline value",
        "some multi-\nline value"},
   };
-  TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
+  TestFormFillFunctions(kFormHtml, false, field_cases, arraysize(field_cases),
                         &FillFormIncludingNonFocusableElementsWrapper,
                         &GetValueWrapper);
 }
 
 TEST_F(FormAutofillTest, PreviewForm) {
-  static const AutofillFieldCase field_cases[] = {
-      // Normal empty fields should be previewed.
-      {"text",
-       "firstname",
-       "",
-       "",
-       true,
-       "suggested firstname",
-       "suggested firstname"},
-      {"text",
-       "lastname",
-       "",
-       "",
-       true,
-       "suggested lastname",
-       "suggested lastname"},
-      // Hidden fields should not be extracted to form_data.
-      // Non empty fields should not be previewed.
-      {"text", "notempty", "Hi", "", false, "suggested notempty", ""},
-      {"text",
-       "noautocomplete",
-       "",
-       "off",
-       true,
-       "filled noautocomplete",
-       "filled noautocomplete"},
-      // Disabled fields should not be previewed.
-      {"text", "notenabled", "", "", false, "suggested notenabled", ""},
-      // Readonly fields should not be previewed.
-      {"text", "readonly", "", "", false, "suggested readonly", ""},
-      // Fields with "visibility: hidden" should not be previewed.
-      {"text", "invisible", "", "", false, "suggested invisible", ""},
-      // Fields with "display:none" should not previewed.
-      {"text", "displaynone", "", "", false, "suggested displaynone", ""},
-      // Regular <input type="month"> should be previewed.
-      {"month", "month", "", "", true, "2017-11", "2017-11"},
-      // Non-empty <input type="month"> should not be previewed.
-      {"month", "month-nonempty", "2011-12", "", false, "2017-11", ""},
-      // Regular select fields should be previewed.
-      {"select-one", "select", "", "", true, "TX", "TX"},
-      // Select fields should be previewed even if they already have a
-      // non-empty value.
-      {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
-      // Select fields should not be previewed if no suggestion is passed from
-      // autofill profile.
-      {"select-one", "select-unchanged", "CA", "", false, "", ""},
-      // Normal textarea elements should be previewed.
-      {"textarea",
-       "textarea",
-       "",
-       "",
-       true,
-       "suggested multi-\nline value",
-       "suggested multi-\nline value"},
-      // Nonempty textarea elements should not be previewed.
-      {"textarea",
-       "textarea-nonempty",
-       "Go\naway!",
-       "",
-       false,
-       "suggested multi-\nline value",
-       ""},
-  };
-  TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
-                        &PreviewForm, &GetSuggestedValueWrapper);
+  TestPreviewForm(kFormHtml, false);
+}
 
-  // Verify preview selection.
-  WebInputElement firstname = GetInputElementById("firstname");
-  EXPECT_EQ(0, firstname.selectionStart());
-  EXPECT_EQ(19, firstname.selectionEnd());
+TEST_F(FormAutofillTest, PreviewFormForUnownedForm) {
+  TestPreviewForm(kUnownedFormHtml, true);
 }
 
 TEST_F(FormAutofillTest, Labels) {
   ExpectJohnSmithLabels(
       "<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='email'> Email: </LABEL>"
@@ skipping 843 matching lines @@
       "  <DT></DT>"
       "  <DD>"
       "    <INPUT type='submit' name='reply-send' value='Send'/>"
       "  </DD>"
       "</DL>"
       "</DIV>"
       "</FORM>");
 }
 
 TEST_F(FormAutofillTest, FillFormMaxLength) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname' maxlength='5'/>"
-           "  <INPUT type='text' id='lastname' maxlength='7'/>"
-           "  <INPUT type='text' id='email' maxlength='9'/>"
-           "  <INPUT type='submit' name='reply-send' value='Send'/>"
-           "</FORM>");
+  TestFillFormMaxLength(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname' maxlength='5'/>"
+      "  <INPUT type='text' id='lastname' maxlength='7'/>"
+      "  <INPUT type='text' id='email' maxlength='9'/>"
+      "  <INPUT type='submit' name='reply-send' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Get the input element we want to find.
-  WebInputElement input_element = GetInputElementById("firstname");
-
-  // Find the form that contains the input element.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(3U, fields.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.max_length = 5;
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.max_length = 7;
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.max_length = 9;
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-
-  // Fill the form.
-  form.fields[0].value = ASCIIToUTF16("Brother");
-  form.fields[1].value = ASCIIToUTF16("Jonathan");
-  form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
-  form.fields[0].is_autofilled = true;
-  form.fields[1].is_autofilled = true;
-  form.fields[2].is_autofilled = true;
-  FillForm(form, input_element);
-
-  // Find the newly-filled form that contains the input element.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.form_control_type = "text";
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("Broth");
-  expected.max_length = 5;
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Jonatha");
-  expected.max_length = 7;
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = ASCIIToUTF16("brotherj@");
-  expected.max_length = 9;
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+TEST_F(FormAutofillTest, FillFormMaxLengthForUnownedForm) {
+  TestFillFormMaxLength(
+      "<INPUT type='text' id='firstname' maxlength='5'/>"
+      "<INPUT type='text' id='lastname' maxlength='7'/>"
+      "<INPUT type='text' id='email' maxlength='9'/>"
+      "<INPUT type='submit' name='reply-send' value='Send'/>",
+      true);
 }
 
 // This test uses negative values of the maxlength attribute for input elements.
 // In this case, the maxlength of the input elements is set to the default
 // maxlength (defined in WebKit.)
 TEST_F(FormAutofillTest, FillFormNegativeMaxLength) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname' maxlength='-1'/>"
-           "  <INPUT type='text' id='lastname' maxlength='-10'/>"
-           "  <INPUT type='text' id='email' maxlength='-13'/>"
-           "  <INPUT type='submit' name='reply-send' value='Send'/>"
-           "</FORM>");
+  TestFillFormNegativeMaxLength(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname' maxlength='-1'/>"
+      "  <INPUT type='text' id='lastname' maxlength='-10'/>"
+      "  <INPUT type='text' id='email' maxlength='-13'/>"
+      "  <INPUT type='submit' name='reply-send' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Get the input element we want to find.
-  WebInputElement input_element = GetInputElementById("firstname");
-
-  // Find the form that contains the input element.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(3U, fields.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-
-  // Fill the form.
-  form.fields[0].value = ASCIIToUTF16("Brother");
-  form.fields[1].value = ASCIIToUTF16("Jonathan");
-  form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
-  FillForm(form, input_element);
-
-  // Find the newly-filled form that contains the input element.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("Brother");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Jonathan");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = ASCIIToUTF16("brotherj@example.com");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+TEST_F(FormAutofillTest, FillFormNegativeMaxLengthForUnownedForm) {
+  TestFillFormNegativeMaxLength(
+      "<INPUT type='text' id='firstname' maxlength='-1'/>"
+      "<INPUT type='text' id='lastname' maxlength='-10'/>"
+      "<INPUT type='text' id='email' maxlength='-13'/>"
+      "<INPUT type='submit' name='reply-send' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, FillFormEmptyName) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname'/>"
-           "  <INPUT type='text' id='lastname'/>"
-           "  <INPUT type='text' id='email'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>");
+  TestFillFormEmptyName(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname'/>"
+      "  <INPUT type='text' id='lastname'/>"
+      "  <INPUT type='text' id='email'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Get the input element we want to find.
-  WebInputElement input_element = GetInputElementById("firstname");
-
-  // Find the form that contains the input element.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(3U, fields.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-
-  // Fill the form.
-  form.fields[0].value = ASCIIToUTF16("Wyatt");
-  form.fields[1].value = ASCIIToUTF16("Earp");
-  form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
-  FillForm(form, input_element);
-
-  // Find the newly-filled form that contains the input element.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("Wyatt");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Earp");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = ASCIIToUTF16("wyatt@example.com");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
+TEST_F(FormAutofillTest, FillFormEmptyNameForUnownedForm) {
+  TestFillFormEmptyName(
+      "<INPUT type='text' id='firstname'/>"
+      "<INPUT type='text' id='lastname'/>"
+      "<INPUT type='text' id='email'/>"
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, FillFormEmptyFormNames) {
-  LoadHTML("<FORM action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname'/>"
-           "  <INPUT type='text' id='middlename'/>"
-           "  <INPUT type='text' id='lastname'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>"
-           "<FORM action='http://abc.com' method='post'>"
-           "  <INPUT type='text' id='apple'/>"
-           "  <INPUT type='text' id='banana'/>"
-           "  <INPUT type='text' id='cantelope'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>");
+  TestFillFormEmptyFormNames(
+      "<FORM action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname'/>"
+      "  <INPUT type='text' id='middlename'/>"
+      "  <INPUT type='text' id='lastname'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>"
+      "<FORM action='http://abc.com' method='post'>"
+      "  <INPUT type='text' id='apple'/>"
+      "  <INPUT type='text' id='banana'/>"
+      "  <INPUT type='text' id='cantelope'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(2U, forms.size());
-
-  // Get the input element we want to find.
-  WebInputElement input_element = GetInputElementById("apple");
-
-  // Find the form that contains the input element.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(base::string16(), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://abc.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(3U, fields.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("apple");
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("banana");
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("cantelope");
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-
-  // Fill the form.
-  form.fields[0].value = ASCIIToUTF16("Red");
-  form.fields[1].value = ASCIIToUTF16("Yellow");
-  form.fields[2].value = ASCIIToUTF16("Also Yellow");
-  form.fields[0].is_autofilled = true;
-  form.fields[1].is_autofilled = true;
-  form.fields[2].is_autofilled = true;
-  FillForm(form, input_element);
-
-  // Find the newly-filled form that contains the input element.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-
-  EXPECT_EQ(base::string16(), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://abc.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.name = ASCIIToUTF16("apple");
-  expected.value = ASCIIToUTF16("Red");
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-
-  expected.name = ASCIIToUTF16("banana");
-  expected.value = ASCIIToUTF16("Yellow");
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("cantelope");
-  expected.value = ASCIIToUTF16("Also Yellow");
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
+TEST_F(FormAutofillTest, FillFormEmptyFormNamesForUnownedForm) {
+  TestFillFormEmptyFormNames(
+      "<INPUT type='text' id='firstname'/>"
+      "<INPUT type='text' id='middlename'/>"
+      "<INPUT type='text' id='lastname'/>"
+      "<INPUT type='text' id='apple'/>"
+      "<INPUT type='text' id='banana'/>"
+      "<INPUT type='text' id='cantelope'/>"
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, ThreePartPhone) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  Phone:"
            "  <input type='text' name='dayphone1'>"
            "  -"
            "  <input type='text' name='dayphone2'>"
            "  -"
            "  <input type='text' name='dayphone3'>"
            "  ext.:"
            "  <input type='text' name='dayphone4'>"
            "  <input type='submit' name='reply-send' value='Send'>"
            "</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(),
-                                       autofill::REQUIRE_NONE,
-                                       autofill::EXTRACT_VALUE,
+                                       REQUIRE_NONE,
+                                       EXTRACT_VALUE,
                                        &form,
-                                       NULL));
+                                       nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->document().url()), form.origin);
   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";
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 35 matching lines @@
   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(),
-                                       autofill::REQUIRE_NONE,
-                                       autofill::EXTRACT_VALUE,
+                                       REQUIRE_NONE,
+                                       EXTRACT_VALUE,
                                        &form,
-                                       NULL));
+                                       nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->document().url()), 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 11 matching lines @@
   expected.name = ASCIIToUTF16("dayphone3");
   expected.max_length = 4;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
 
   expected.label = ASCIIToUTF16("ext.:");
   expected.name = ASCIIToUTF16("dayphone4");
   expected.max_length = 5;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
 
   // When unspecified |size|, default is returned.
-  expected.label = base::string16();
+  expected.label.clear();
   expected.name = ASCIIToUTF16("default1");
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[4]);
 
   // When invalid |size|, default is returned.
-  expected.label = base::string16();
+  expected.label.clear();
   expected.name = ASCIIToUTF16("invalid1");
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]);
 }
 
 // This test re-creates the experience of typing in a field then selecting a
 // profile from the Autofill suggestions popup.  The field that is being typed
 // into should be filled even though it's not technically empty.
 TEST_F(FormAutofillTest, FillFormNonEmptyField) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname'/>"
-           "  <INPUT type='text' id='lastname'/>"
-           "  <INPUT type='text' id='email'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>");
+  TestFillFormNonEmptyField(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname'/>"
+      "  <INPUT type='text' id='lastname'/>"
+      "  <INPUT type='text' id='email'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Get the input element we want to find.
-  WebInputElement input_element = GetInputElementById("firstname");
-
-  // Simulate typing by modifying the field value.
-  input_element.setValue(ASCIIToUTF16("Wy"));
-
-  // Find the form that contains the input element.
-  FormData form;
-  FormFieldData field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form,
-                                                    &field,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form.action);
-
-  const std::vector<FormFieldData>& fields = form.fields;
-  ASSERT_EQ(3U, fields.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("Wy");
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = base::string16();
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = base::string16();
-  expected.is_autofilled = false;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
-
-  // Preview the form and verify that the cursor position has been updated.
-  form.fields[0].value = ASCIIToUTF16("Wyatt");
-  form.fields[1].value = ASCIIToUTF16("Earp");
-  form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
-  form.fields[0].is_autofilled = true;
-  form.fields[1].is_autofilled = true;
-  form.fields[2].is_autofilled = true;
-  PreviewForm(form, input_element);
-  EXPECT_EQ(2, input_element.selectionStart());
-  EXPECT_EQ(5, input_element.selectionEnd());
-
-  // Fill the form.
-  FillForm(form, input_element);
-
-  // Find the newly-filled form that contains the input element.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = ASCIIToUTF16("Wyatt");
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = ASCIIToUTF16("Earp");
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("email");
-  expected.value = ASCIIToUTF16("wyatt@example.com");
-  expected.is_autofilled = true;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
-
-  // Verify that the cursor position has been updated.
-  EXPECT_EQ(5, input_element.selectionStart());
-  EXPECT_EQ(5, input_element.selectionEnd());
+TEST_F(FormAutofillTest, FillFormNonEmptyFieldForUnownedForm) {
+  TestFillFormNonEmptyField("<INPUT type='text' id='firstname'/>"
+                            "<INPUT type='text' id='lastname'/>"
+                            "<INPUT type='text' id='email'/>"
+                            "<INPUT type='submit' value='Send'/>",
+                            true);
 }
 
 TEST_F(FormAutofillTest, ClearFormWithNode) {
-  LoadHTML(
+  TestClearFormWithNode(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='Wyatt'/>"
       "  <INPUT type='text' id='lastname' value='Earp'/>"
       "  <INPUT type='text' autocomplete='off' id='noAC' value='one'/>"
       "  <INPUT type='text' id='notenabled' disabled='disabled'>"
       "  <INPUT type='month' id='month' value='2012-11'>"
       "  <INPUT type='month' id='month-disabled' value='2012-11'"
       "         disabled='disabled'>"
       "  <TEXTAREA id='textarea'>Apple.</TEXTAREA>"
       "  <TEXTAREA id='textarea-disabled' disabled='disabled'>"
       "    Banana!"
       "  </TEXTAREA>"
       "  <TEXTAREA id='textarea-noAC' autocomplete='off'>Carrot?</TEXTAREA>"
       "  <INPUT type='submit' value='Send'/>"
-      "</FORM>");
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Set the auto-filled attribute.
-  WebInputElement firstname = GetInputElementById("firstname");
-  firstname.setAutofilled(true);
-  WebInputElement lastname = GetInputElementById("lastname");
-  lastname.setAutofilled(true);
-  WebInputElement month = GetInputElementById("month");
-  month.setAutofilled(true);
-  WebInputElement textarea = GetInputElementById("textarea");
-  textarea.setAutofilled(true);
-
-  // Set the value of the disabled text input element.
-  WebInputElement notenabled = GetInputElementById("notenabled");
-  notenabled.setValue(WebString::fromUTF8("no clear"));
-
-  // Clear the form.
-  EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
-
-  // Verify that the auto-filled attribute has been turned off.
-  EXPECT_FALSE(firstname.isAutofilled());
-
-  // Verify the form is cleared.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(firstname,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(9U, fields2.size());
-
-  FormFieldData expected;
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = base::string16();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = base::string16();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("noAC");
-  expected.value = ASCIIToUTF16("one");
-  expected.autocomplete_attribute = "off";
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
-  expected.autocomplete_attribute = std::string();  // reset
-
-  expected.name = ASCIIToUTF16("notenabled");
-  expected.value = ASCIIToUTF16("no clear");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[3]);
-
-  expected.form_control_type = "month";
-  expected.max_length = 0;
-  expected.name = ASCIIToUTF16("month");
-  expected.value = base::string16();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[4]);
-
-  expected.name = ASCIIToUTF16("month-disabled");
-  expected.value = ASCIIToUTF16("2012-11");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[5]);
-
-  expected.form_control_type = "textarea";
-  expected.name = ASCIIToUTF16("textarea");
-  expected.value = base::string16();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[6]);
-
-  expected.name = ASCIIToUTF16("textarea-disabled");
-  expected.value = ASCIIToUTF16("    Banana!  ");
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[7]);
-
-  expected.name = ASCIIToUTF16("textarea-noAC");
-  expected.value = ASCIIToUTF16("Carrot?");
-  expected.autocomplete_attribute = "off";
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[8]);
-  expected.autocomplete_attribute = std::string();  // reset
-
-  // Verify that the cursor position has been updated.
-  EXPECT_EQ(0, firstname.selectionStart());
-  EXPECT_EQ(0, firstname.selectionEnd());
+TEST_F(FormAutofillTest, ClearFormWithNodeForUnownedForm) {
+  TestClearFormWithNode(
+      "  <!-- Indented on purpose //-->"
+      "  <INPUT type='text' id='firstname' value='Wyatt'/>"
+      "  <INPUT type='text' id='lastname' value='Earp'/>"
+      "  <INPUT type='text' autocomplete='off' id='noAC' value='one'/>"
+      "  <INPUT type='text' id='notenabled' disabled='disabled'>"
+      "  <INPUT type='month' id='month' value='2012-11'>"
+      "  <INPUT type='month' id='month-disabled' value='2012-11'"
+      "         disabled='disabled'>"
+      "  <TEXTAREA id='textarea'>Apple.</TEXTAREA>"
+      "  <TEXTAREA id='textarea-disabled' disabled='disabled'>"
+      "    Banana!"
+      "  </TEXTAREA>"
+      "  <TEXTAREA id='textarea-noAC' autocomplete='off'>Carrot?</TEXTAREA>"
+      "  <INPUT type='submit' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, ClearFormWithNodeContainingSelectOne) {
-  LoadHTML(
+  TestClearFormWithNodeContainingSelectOne(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='Wyatt'/>"
       "  <INPUT type='text' id='lastname' value='Earp'/>"
       "  <SELECT id='state' name='state'>"
       "    <OPTION selected>?</OPTION>"
       "    <OPTION>AA</OPTION>"
       "    <OPTION>AE</OPTION>"
       "    <OPTION>AK</OPTION>"
       "  </SELECT>"
       "  <INPUT type='submit' value='Send'/>"
-      "</FORM>");
+      "</FORM>",
+      false);
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Set the auto-filled attribute.
-  WebInputElement firstname = GetInputElementById("firstname");
-  firstname.setAutofilled(true);
-  WebInputElement lastname = GetInputElementById("lastname");
-  lastname.setAutofilled(true);
-
-  // Set the value and auto-filled attribute of the state element.
-  WebSelectElement state =
-      web_frame->document().getElementById("state").to<WebSelectElement>();
-  state.setValue(WebString::fromUTF8("AK"));
-  state.setAutofilled(true);
-
-  // Clear the form.
-  EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
-
-  // Verify that the auto-filled attribute has been turned off.
-  EXPECT_FALSE(firstname.isAutofilled());
-
-  // Verify the form is cleared.
-  FormData form2;
-  FormFieldData field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(firstname,
-                                                    &form2,
-                                                    &field2,
-                                                    autofill::REQUIRE_NONE));
-  EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
-  EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
-  EXPECT_EQ(GURL("http://buh.com"), form2.action);
-
-  const std::vector<FormFieldData>& fields2 = form2.fields;
-  ASSERT_EQ(3U, fields2.size());
-
-  FormFieldData expected;
-
-  expected.name = ASCIIToUTF16("firstname");
-  expected.value = base::string16();
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
-
-  expected.name = ASCIIToUTF16("lastname");
-  expected.value = base::string16();
-  expected.form_control_type = "text";
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
-
-  expected.name = ASCIIToUTF16("state");
-  expected.value = ASCIIToUTF16("?");
-  expected.form_control_type = "select-one";
-  expected.max_length = 0;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
-
-  // Verify that the cursor position has been updated.
-  EXPECT_EQ(0, firstname.selectionStart());
-  EXPECT_EQ(0, firstname.selectionEnd());
+TEST_F(FormAutofillTest, ClearFormWithNodeContainingSelectOneForUnownedForm) {
+  TestClearFormWithNodeContainingSelectOne(
+      "<INPUT type='text' id='firstname' value='Wyatt'/>"
+      "<INPUT type='text' id='lastname' value='Earp'/>"
+      "<SELECT id='state' name='state'>"
+      "  <OPTION selected>?</OPTION>"
+      "  <OPTION>AA</OPTION>"
+      "  <OPTION>AE</OPTION>"
+      "  <OPTION>AK</OPTION>"
+      "</SELECT>"
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithElement) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname' value='Wyatt'/>"
-           "  <INPUT type='text' id='lastname'/>"
-           "  <INPUT type='text' id='email'/>"
-           "  <INPUT type='email' id='email2'/>"
-           "  <INPUT type='tel' id='phone'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>");
+  TestClearPreviewedFormWithElement(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname' value='Wyatt'/>"
+      "  <INPUT type='text' id='lastname'/>"
+      "  <INPUT type='text' id='email'/>"
+      "  <INPUT type='email' id='email2'/>"
+      "  <INPUT type='tel' id='phone'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>");
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Set the auto-filled attribute.
-  WebInputElement firstname = GetInputElementById("firstname");
-  firstname.setAutofilled(true);
-  WebInputElement lastname = GetInputElementById("lastname");
-  lastname.setAutofilled(true);
-  WebInputElement email = GetInputElementById("email");
-  email.setAutofilled(true);
-  WebInputElement email2 = GetInputElementById("email2");
-  email2.setAutofilled(true);
-  WebInputElement phone = GetInputElementById("phone");
-  phone.setAutofilled(true);
-
-  // Set the suggested values on two of the elements.
-  lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
-  email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
-  email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
-  phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
-
-  // Clear the previewed fields.
-  EXPECT_TRUE(ClearPreviewedFormWithElement(lastname, false));
-
-  // Fields with empty suggestions suggestions are not modified.
-  EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
-  EXPECT_TRUE(firstname.suggestedValue().isEmpty());
-  EXPECT_TRUE(firstname.isAutofilled());
-
-  // Verify the previewed fields are cleared.
-  EXPECT_TRUE(lastname.value().isEmpty());
-  EXPECT_TRUE(lastname.suggestedValue().isEmpty());
-  EXPECT_FALSE(lastname.isAutofilled());
-  EXPECT_TRUE(email.value().isEmpty());
-  EXPECT_TRUE(email.suggestedValue().isEmpty());
-  EXPECT_FALSE(email.isAutofilled());
-  EXPECT_TRUE(email2.value().isEmpty());
-  EXPECT_TRUE(email2.suggestedValue().isEmpty());
-  EXPECT_FALSE(email2.isAutofilled());
-  EXPECT_TRUE(phone.value().isEmpty());
-  EXPECT_TRUE(phone.suggestedValue().isEmpty());
-  EXPECT_FALSE(phone.isAutofilled());
-
-  // Verify that the cursor position has been updated.
-  EXPECT_EQ(0, lastname.selectionStart());
-  EXPECT_EQ(0, lastname.selectionEnd());
+TEST_F(FormAutofillTest, ClearPreviewedFormWithElementForUnownedForm) {
+  TestClearPreviewedFormWithElement(
+      "<INPUT type='text' id='firstname' value='Wyatt'/>"
+      "<INPUT type='text' id='lastname'/>"
+      "<INPUT type='text' id='email'/>"
+      "<INPUT type='email' id='email2'/>"
+      "<INPUT type='tel' id='phone'/>"
+      "<INPUT type='submit' value='Send'/>");
 }
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithNonEmptyInitiatingNode) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname' value='W'/>"
-           "  <INPUT type='text' id='lastname'/>"
-           "  <INPUT type='text' id='email'/>"
-           "  <INPUT type='email' id='email2'/>"
-           "  <INPUT type='tel' id='phone'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>");
+  TestClearPreviewedFormWithNonEmptyInitiatingNode(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname' value='W'/>"
+      "  <INPUT type='text' id='lastname'/>"
+      "  <INPUT type='text' id='email'/>"
+      "  <INPUT type='email' id='email2'/>"
+      "  <INPUT type='tel' id='phone'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>");
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Set the auto-filled attribute.
-  WebInputElement firstname = GetInputElementById("firstname");
-  firstname.setAutofilled(true);
-  WebInputElement lastname = GetInputElementById("lastname");
-  lastname.setAutofilled(true);
-  WebInputElement email = GetInputElementById("email");
-  email.setAutofilled(true);
-  WebInputElement email2 = GetInputElementById("email2");
-  email2.setAutofilled(true);
-  WebInputElement phone = GetInputElementById("phone");
-  phone.setAutofilled(true);
-
-
-  // Set the suggested values on all of the elements.
-  firstname.setSuggestedValue(ASCIIToUTF16("Wyatt"));
-  lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
-  email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
-  email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
-  phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
-
-  // Clear the previewed fields.
-  EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, false));
-
-  // Fields with non-empty values are restored.
-  EXPECT_EQ(ASCIIToUTF16("W"), firstname.value());
-  EXPECT_TRUE(firstname.suggestedValue().isEmpty());
-  EXPECT_FALSE(firstname.isAutofilled());
-  EXPECT_EQ(1, firstname.selectionStart());
-  EXPECT_EQ(1, firstname.selectionEnd());
-
-  // Verify the previewed fields are cleared.
-  EXPECT_TRUE(lastname.value().isEmpty());
-  EXPECT_TRUE(lastname.suggestedValue().isEmpty());
-  EXPECT_FALSE(lastname.isAutofilled());
-  EXPECT_TRUE(email.value().isEmpty());
-  EXPECT_TRUE(email.suggestedValue().isEmpty());
-  EXPECT_FALSE(email.isAutofilled());
-  EXPECT_TRUE(email2.value().isEmpty());
-  EXPECT_TRUE(email2.suggestedValue().isEmpty());
-  EXPECT_FALSE(email2.isAutofilled());
-  EXPECT_TRUE(phone.value().isEmpty());
-  EXPECT_TRUE(phone.suggestedValue().isEmpty());
-  EXPECT_FALSE(phone.isAutofilled());
+TEST_F(FormAutofillTest,
+       ClearPreviewedFormWithNonEmptyInitiatingNodeForUnownedForm) {
+  TestClearPreviewedFormWithNonEmptyInitiatingNode(
+      "<INPUT type='text' id='firstname' value='W'/>"
+      "<INPUT type='text' id='lastname'/>"
+      "<INPUT type='text' id='email'/>"
+      "<INPUT type='email' id='email2'/>"
+      "<INPUT type='tel' id='phone'/>"
+      "<INPUT type='submit' value='Send'/>");
 }
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithAutofilledInitiatingNode) {
-  LoadHTML("<FORM name='TestForm' action='http://buh.com' method='post'>"
-           "  <INPUT type='text' id='firstname' value='W'/>"
-           "  <INPUT type='text' id='lastname'/>"
-           "  <INPUT type='text' id='email'/>"
-           "  <INPUT type='email' id='email2'/>"
-           "  <INPUT type='tel' id='phone'/>"
-           "  <INPUT type='submit' value='Send'/>"
-           "</FORM>");
+  TestClearPreviewedFormWithAutofilledInitiatingNode(
+      "<FORM name='TestForm' action='http://buh.com' method='post'>"
+      "  <INPUT type='text' id='firstname' value='W'/>"
+      "  <INPUT type='text' id='lastname'/>"
+      "  <INPUT type='text' id='email'/>"
+      "  <INPUT type='email' id='email2'/>"
+      "  <INPUT type='tel' id='phone'/>"
+      "  <INPUT type='submit' value='Send'/>"
+      "</FORM>");
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Set the auto-filled attribute.
-  WebInputElement firstname = GetInputElementById("firstname");
-  firstname.setAutofilled(true);
-  WebInputElement lastname = GetInputElementById("lastname");
-  lastname.setAutofilled(true);
-  WebInputElement email = GetInputElementById("email");
-  email.setAutofilled(true);
-  WebInputElement email2 = GetInputElementById("email2");
-  email2.setAutofilled(true);
-  WebInputElement phone = GetInputElementById("phone");
-  phone.setAutofilled(true);
-
-  // Set the suggested values on all of the elements.
-  firstname.setSuggestedValue(ASCIIToUTF16("Wyatt"));
-  lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
-  email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
-  email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
-  phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
-
-  // Clear the previewed fields.
-  EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, true));
-
-  // Fields with non-empty values are restored.
-  EXPECT_EQ(ASCIIToUTF16("W"), firstname.value());
-  EXPECT_TRUE(firstname.suggestedValue().isEmpty());
-  EXPECT_TRUE(firstname.isAutofilled());
-  EXPECT_EQ(1, firstname.selectionStart());
-  EXPECT_EQ(1, firstname.selectionEnd());
-
-  // Verify the previewed fields are cleared.
-  EXPECT_TRUE(lastname.value().isEmpty());
-  EXPECT_TRUE(lastname.suggestedValue().isEmpty());
-  EXPECT_FALSE(lastname.isAutofilled());
-  EXPECT_TRUE(email.value().isEmpty());
-  EXPECT_TRUE(email.suggestedValue().isEmpty());
-  EXPECT_FALSE(email.isAutofilled());
-  EXPECT_TRUE(email2.value().isEmpty());
-  EXPECT_TRUE(email2.suggestedValue().isEmpty());
-  EXPECT_FALSE(email2.isAutofilled());
-  EXPECT_TRUE(phone.value().isEmpty());
-  EXPECT_TRUE(phone.suggestedValue().isEmpty());
-  EXPECT_FALSE(phone.isAutofilled());
+TEST_F(FormAutofillTest,
+       ClearPreviewedFormWithAutofilledInitiatingNodeForUnownedForm) {
+  TestClearPreviewedFormWithAutofilledInitiatingNode(
+      "<INPUT type='text' id='firstname' value='W'/>"
+      "<INPUT type='text' id='lastname'/>"
+      "<INPUT type='text' id='email'/>"
+      "<INPUT type='email' id='email2'/>"
+      "<INPUT type='tel' id='phone'/>"
+      "<INPUT type='submit' value='Send'/>");
 }
 
 // Autofill's "Clear Form" should clear only autofilled fields
 TEST_F(FormAutofillTest, ClearOnlyAutofilledFields) {
-  // Load the form.
-  LoadHTML(
+  TestClearOnlyAutofilledFields(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='Wyatt'/>"
       "  <INPUT type='text' id='lastname' value='Earp'/>"
       "  <INPUT type='email' id='email' value='wyatt@earp.com'/>"
       "  <INPUT type='tel' id='phone' value='650-777-9999'/>"
       "  <INPUT type='submit' value='Send'/>"
       "</FORM>");
+}
 
-  WebFrame* web_frame = GetMainFrame();
-  ASSERT_NE(nullptr, web_frame);
-
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
-  ASSERT_EQ(1U, forms.size());
-
-  // Set the autofilled attribute.
-  WebInputElement firstname = GetInputElementById("firstname");
-  firstname.setAutofilled(false);
-  WebInputElement lastname = GetInputElementById("lastname");
-  lastname.setAutofilled(true);
-  WebInputElement email = GetInputElementById("email");
-  email.setAutofilled(true);
-  WebInputElement phone = GetInputElementById("phone");
-  phone.setAutofilled(true);
-
-  // Clear the fields.
-  EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
-
-  // Verify only autofilled fields are cleared.
-  EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
-  EXPECT_TRUE(firstname.suggestedValue().isEmpty());
-  EXPECT_FALSE(firstname.isAutofilled());
-  EXPECT_TRUE(lastname.value().isEmpty());
-  EXPECT_TRUE(lastname.suggestedValue().isEmpty());
-  EXPECT_FALSE(lastname.isAutofilled());
-  EXPECT_TRUE(email.value().isEmpty());
-  EXPECT_TRUE(email.suggestedValue().isEmpty());
-  EXPECT_FALSE(email.isAutofilled());
-  EXPECT_TRUE(phone.value().isEmpty());
-  EXPECT_TRUE(phone.suggestedValue().isEmpty());
-  EXPECT_FALSE(phone.isAutofilled());
+TEST_F(FormAutofillTest, ClearOnlyAutofilledFieldsForUnownedForm) {
+  TestClearOnlyAutofilledFields(
+      "<INPUT type='text' id='firstname' value='Wyatt'/>"
+      "<INPUT type='text' id='lastname' value='Earp'/>"
+      "<INPUT type='email' id='email' value='wyatt@earp.com'/>"
+      "<INPUT type='tel' id='phone' value='650-777-9999'/>"
+      "<INPUT type='submit' value='Send'/>");
 }
 
 // If we have multiple labels per id, the labels concatenated into label string.
 TEST_F(FormAutofillTest, MultipleLabelsPerElement) {
   std::vector<base::string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("First Name:"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
@@ skipping 21 matching lines @@
       labels, names, values);
 }
 
 TEST_F(FormAutofillTest, ClickElement) {
   LoadHTML("<BUTTON id='link'>Button</BUTTON>"
            "<BUTTON name='button'>Button</BUTTON>");
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   // Successful retrieval by id.
-  autofill::WebElementDescriptor clicker;
-  clicker.retrieval_method = autofill::WebElementDescriptor::ID;
+  WebElementDescriptor clicker;
+  clicker.retrieval_method = WebElementDescriptor::ID;
   clicker.descriptor = "link";
   EXPECT_TRUE(ClickElement(frame->document(), clicker));
 
   // Successful retrieval by css selector.
-  clicker.retrieval_method = autofill::WebElementDescriptor::CSS_SELECTOR;
+  clicker.retrieval_method = WebElementDescriptor::CSS_SELECTOR;
   clicker.descriptor = "button[name='button']";
   EXPECT_TRUE(ClickElement(frame->document(), clicker));
 
   // Unsuccessful retrieval due to invalid CSS selector.
   clicker.descriptor = "^*&";
   EXPECT_FALSE(ClickElement(frame->document(), clicker));
 
   // Unsuccessful retrieval because element does not exist.
   clicker.descriptor = "#junk";
   EXPECT_FALSE(ClickElement(frame->document(), clicker));
@@ skipping 20 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(), autofill::REQUIRE_NONE,
-      static_cast<autofill::ExtractMask>(
-          autofill::EXTRACT_VALUE | autofill::EXTRACT_OPTION_TEXT),
-      &form, NULL));
+      forms[0], WebFormControlElement(), REQUIRE_NONE,
+      static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
+      &form, nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->document().url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
 
   expected.name = ASCIIToUTF16("firstname");
@@ skipping 11 matching lines @@
   expected.name = ASCIIToUTF16("country");
   expected.value = ASCIIToUTF16("Albania");
   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(),
-                                       autofill::REQUIRE_NONE,
-                                       autofill::EXTRACT_VALUE,
+                                       REQUIRE_NONE,
+                                       EXTRACT_VALUE,
                                        &form,
-                                       NULL));
+                                       nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->document().url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   ASSERT_EQ(3U, fields.size());
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("John");
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 30 matching lines @@
            "  </FIELDSET>"
            "  <FIELDSET>"
            "    <LABEL for='email'>Email:</LABEL>"
            "    <INPUT type='text' id='email' value='john@example.com'/>"
            "  </FIELDSET>"
            "</DIV>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
-  control_elements = FormCache::GetUnownedAutofillableFormFieldElements(
+  control_elements = GetUnownedAutofillableFormFieldElements(
       frame->document().all(), &fieldsets);
   ASSERT_EQ(3U, control_elements.size());
   ASSERT_EQ(2U, fieldsets.size());
 
   FormData form;
   EXPECT_TRUE(UnownedFormElementsAndFieldSetsToFormData(
-      fieldsets, control_elements, dummy_origin, extract_mask, &form));
+      fieldsets, control_elements, nullptr, dummy_origin, REQUIRE_NONE,
+      extract_mask, &form, nullptr));
 
   EXPECT_TRUE(form.name.empty());
   EXPECT_EQ(dummy_origin, form.origin);
   EXPECT_FALSE(form.action.is_valid());
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
   expected.form_control_type = "text";
@@ skipping 31 matching lines @@
            "    <INPUT type='text' id='firstname' value='John'/>"
            "    <INPUT type='text' id='lastname' value='Smith'/>"
            "    <LABEL for='email'>Email:</LABEL>"
            "  </FIELDSET>"
            "  <INPUT type='text' id='email' value='john@example.com'/>"
            "</DIV>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
-  control_elements = FormCache::GetUnownedAutofillableFormFieldElements(
+  control_elements = GetUnownedAutofillableFormFieldElements(
       frame->document().all(), &fieldsets);
   ASSERT_EQ(3U, control_elements.size());
   ASSERT_EQ(1U, fieldsets.size());
 
   FormData form;
   EXPECT_TRUE(UnownedFormElementsAndFieldSetsToFormData(
-      fieldsets, control_elements, dummy_origin, extract_mask, &form));
+      fieldsets, control_elements, nullptr, dummy_origin, REQUIRE_NONE,
+      extract_mask, &form, nullptr));
 
   EXPECT_TRUE(form.name.empty());
   EXPECT_EQ(dummy_origin, form.origin);
   EXPECT_FALSE(form.action.is_valid());
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
   expected.form_control_type = "text";
@@ skipping 21 matching lines @@
 
   const ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
   const GURL dummy_origin("http://www.example.com");
 
   LoadHTML(kFormHtml);
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
-  control_elements = FormCache::GetUnownedAutofillableFormFieldElements(
+  control_elements = GetUnownedAutofillableFormFieldElements(
       frame->document().all(), &fieldsets);
-  ASSERT_EQ(0U, control_elements.size());
-  ASSERT_EQ(0U, fieldsets.size());
+  ASSERT_TRUE(control_elements.empty());
+  ASSERT_TRUE(fieldsets.empty());
 
   FormData form;
   EXPECT_FALSE(UnownedFormElementsAndFieldSetsToFormData(
-      fieldsets, control_elements, dummy_origin, extract_mask, &form));
+      fieldsets, control_elements, nullptr, dummy_origin, REQUIRE_NONE,
+      extract_mask, &form, nullptr));
 }
 
 }  // namespace autofill