Don't ask the browser for Autofill suggestions for non-autofillable form fields.

chrome/renderer/autofill/form_autofill_browsertest.cc

 // Copyright (c) 2011 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/string16.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 20 matching lines @@
 using WebKit::WebFormElement;
 using WebKit::WebFrame;
 using WebKit::WebInputElement;
 using WebKit::WebSelectElement;
 using WebKit::WebNode;
 using WebKit::WebString;
 using WebKit::WebVector;
 
 using autofill::ClearPreviewedFormWithElement;
 using autofill::FillForm;
-using autofill::FindFormAndFieldForFormControlElement;
+using autofill::FindFormAndFieldForInputElement;
 using autofill::FormWithElementIsAutofilled;
 using autofill::FormCache;
 using autofill::PreviewForm;
 using autofill::WebFormControlElementToFormField;
 
 using webkit_glue::FormData;
 using webkit_glue::FormField;
 
-class FormManagerTest : public RenderViewTest {
+class FormAutofillTest : public RenderViewTest {
  public:
-  FormManagerTest() : RenderViewTest() {}
-  virtual ~FormManagerTest() {}
+  FormAutofillTest() : RenderViewTest() {}
+  virtual ~FormAutofillTest() {}
 
   void ExpectLabels(const char* html,
                     const std::vector<string16>& labels,
                     const std::vector<string16>& names,
                     const std::vector<string16>& values) {
     std::vector<string16> control_types(labels.size(), ASCIIToUTF16("text"));
     ExpectLabelsAndTypes(html, labels, names, values, control_types);
   }
 
   void ExpectLabelsAndTypes(const char* html,
@@ skipping 48 matching lines @@
     values.push_back(ASCIIToUTF16("Smith"));
 
     labels.push_back(ASCIIToUTF16("Email:"));
     names.push_back(ASCIIToUTF16("email"));
     values.push_back(ASCIIToUTF16("john@example.com"));
 
     ExpectLabels(html, labels, names, values);
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FormManagerTest);
+  DISALLOW_COPY_AND_ASSIGN(FormAutofillTest);
 };
 
 // We should be able to extract a normal text field.
-TEST_F(FormManagerTest, WebFormControlElementToFormField) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormField) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormField result1;
   WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result1);
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("element");
   expected.value = string16();
   EXPECT_FORM_FIELD_EQUALS(expected, result1);
 
   FormField result2;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result2);
 
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   EXPECT_FORM_FIELD_EQUALS(expected, result2);
 }
 
 // We should be able to extract a text field with autocomplete="off".
-TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutocompleteOff) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompleteOff) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\""
            "       autocomplete=\"off\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormField result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormField expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_EQUALS(expected, result);
 }
 
 // We should be able to extract a text field with maxlength specified.
-TEST_F(FormManagerTest, WebFormControlElementToFormFieldMaxLength) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMaxLength) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\""
            "       maxlength=\"5\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormField result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormField expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = 5;
   EXPECT_FORM_FIELD_EQUALS(expected, result);
 }
 
 // We should be able to extract a text field that has been autofilled.
-TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutofilled) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutofilled) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebInputElement element = web_element.to<WebInputElement>();
   element.setAutofilled(true);
   FormField result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormField expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, result);
 }
 
 // We should be able to extract a <select> field.
-TEST_F(FormManagerTest, WebFormControlElementToFormFieldSelect) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormFieldSelect) {
   LoadHTML("<SELECT id=\"element\"/>"
            "  <OPTION value=\"CA\">California</OPTION>"
            "  <OPTION value=\"TX\">Texas</OPTION>"
            "</SELECT>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
@@ skipping 25 matching lines @@
 
   ASSERT_EQ(2U, result3.option_values.size());
   ASSERT_EQ(2U, result3.option_contents.size());
   EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]);
   EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]);
   EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]);
   EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]);
 }
 
 // We should not extract the value for non-text and non-select fields.
-TEST_F(FormManagerTest, WebFormControlElementToFormFieldInvalidType) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormFieldInvalidType) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  <INPUT type=\"hidden\" id=\"hidden\" value=\"apple\"/>"
            "  <INPUT type=\"password\" id=\"password\" value=\"secret\"/>"
            "  <INPUT type=\"checkbox\" id=\"checkbox\" value=\"mail\"/>"
            "  <INPUT type=\"radio\" id=\"radio\" value=\"male\"/>"
            "  <INPUT type=\"submit\" id=\"submit\" value=\"Send\"/>"
            "</FORM>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
@@ skipping 34 matching lines @@
 
   web_element = frame->document().getElementById("submit");
   element = web_element.to<WebFormControlElement>();
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("submit");
   expected.form_control_type = ASCIIToUTF16("submit");
   EXPECT_FORM_FIELD_EQUALS(expected, result);
 }
 
 // We should be able to extract the autocompletetype attribute.
-TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutocompletetype) {
+TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompletetype) {
   std::string html =
       "<INPUT type=\"text\" id=\"absent\"/>"
       "<INPUT type=\"text\" id=\"empty\" x-autocompletetype=\"\"/>"
       "<INPUT type=\"text\" id=\"whitespace\" x-autocompletetype=\"  \"/>"
       "<INPUT type=\"text\" id=\"regular\" x-autocompletetype=\"email\"/>"
       "<INPUT type=\"text\" id=\"multi-valued\" "
       "       x-autocompletetype=\"x-confirm-email email\"/>"
       "<INPUT type=\"text\" id=\"unprefixed\" autocompletetype=\"email\"/>"
       "<SELECT id=\"select\" x-autocompletetype=\"state\"/>"
       "  <OPTION value=\"CA\">California</OPTION>"
@@ skipping 92 matching lines @@
   element = web_element.to<WebFormControlElement>();
   FormField result8;
   WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result8);
   expected.name = ASCIIToUTF16("malicious");
   expected.form_control_type = ASCIIToUTF16("text");
   expected.autocomplete_type = ASCIIToUTF16("x-max-data-length-exceeded");
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_EQUALS(expected, result8);
 }
 
-TEST_F(FormManagerTest, WebFormElementToFormData) {
+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=\"state\">State:</LABEL>"
            "  <SELECT id=\"state\"/>"
            "    <OPTION value=\"CA\">California</OPTION>"
            "    <OPTION value=\"TX\">Texas</OPTION>"
            "  </SELECT>"
@@ skipping 46 matching lines @@
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("state");
   expected.value = ASCIIToUTF16("CA");
   expected.label = ASCIIToUTF16("State:");
   expected.form_control_type = ASCIIToUTF16("select-one");
   expected.max_length = 0;
   EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
-TEST_F(FormManagerTest, ExtractForms) {
+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\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, ExtractMultipleForms) {
+TEST_F(FormAutofillTest, ExtractMultipleForms) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.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\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>"
            "<FORM name=\"TestForm2\" action=\"http://zoo.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"Jack\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Adams\"/>"
            "  <INPUT type=\"text\" id=\"email\" value=\"jack@example.com\"/>"
@@ skipping 49 matching lines @@
   expected.name = ASCIIToUTF16("lastname");
   expected.value = ASCIIToUTF16("Adams");
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
 
   expected.name = ASCIIToUTF16("email");
   expected.value = ASCIIToUTF16("jack@example.com");
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[2]);
 }
 
 // We should not extract a form if it has too few fillable fields.
-TEST_F(FormManagerTest, ExtractFormsTooFewFields) {
+TEST_F(FormAutofillTest, ExtractFormsTooFewFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   EXPECT_EQ(0U, forms.size());
 }
 
-TEST_F(FormManagerTest, WebFormElementToFormDataAutocomplete) {
+TEST_F(FormAutofillTest, WebFormElementToFormDataAutocomplete) {
   {
     // Form is not auto-completable due to autocomplete=off.
     LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\""
              " autocomplete=off>"
              "  <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
              "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
              "  <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
              "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
              "</FORM>");
 
@@ skipping 57 matching lines @@
     expected.name = ASCIIToUTF16("lastname");
     expected.value = ASCIIToUTF16("Smith");
     EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
     expected.name = ASCIIToUTF16("email");
     expected.value = ASCIIToUTF16("john@example.com");
     EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
   }
 }
 
-TEST_F(FormManagerTest, FindForm) {
+TEST_F(FormAutofillTest, FindForm) {
   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\"/>"
+           "  <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>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form and verify it's the correct form.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
-  ASSERT_EQ(3U, fields.size());
+  ASSERT_EQ(4U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("John");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
   EXPECT_FORM_FIELD_EQUALS(expected, field);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = ASCIIToUTF16("Smith");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("email");
   expected.value = ASCIIToUTF16("john@example.com");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
+
+  expected.name = ASCIIToUTF16("phone");
+  expected.value = ASCIIToUTF16("1.800.555.1234");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
+
+  // Try again, but require autocomplete.
+  FormData form2;
+  FormField field2;
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
+  ASSERT_EQ(3U, fields2.size());
+
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("John");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
+  EXPECT_FORM_FIELD_EQUALS(expected, field);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Smith");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
+
+  expected.name = ASCIIToUTF16("phone");
+  expected.value = ASCIIToUTF16("1.800.555.1234");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[2]);
 }
 
-TEST_F(FormManagerTest, FillForm) {
+TEST_F(FormAutofillTest, FillForm) {
   LoadHTML("<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\"/>"
            "  <INPUT type=\"text\" style=\"display: none\" id=\"displaynone\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
   ASSERT_EQ(8U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 85 matching lines @@
   EXPECT_FALSE(invisible.isAutofilled());
   EXPECT_TRUE(invisible.value().isEmpty());
 
   // |display:none| fields are not filled.
   WebInputElement display_none =
       document.getElementById("displaynone").to<WebInputElement>();
   EXPECT_FALSE(display_none.isAutofilled());
   EXPECT_TRUE(display_none.value().isEmpty());
 }
 
-TEST_F(FormManagerTest, PreviewForm) {
+TEST_F(FormAutofillTest, PreviewForm) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
            "  <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>"
            "  <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>"
            "  <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
   ASSERT_EQ(5U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 52 matching lines @@
   EXPECT_FALSE(noautocomplete.isAutofilled());
   EXPECT_TRUE(noautocomplete.suggestedValue().isEmpty());
 
   // Disabled fields are not previewed.
   WebInputElement notenabled =
       document.getElementById("notenabled").to<WebInputElement>();
   EXPECT_FALSE(notenabled.isAutofilled());
   EXPECT_TRUE(notenabled.suggestedValue().isEmpty());
 }
 
-TEST_F(FormManagerTest, Labels) {
+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>"
       "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsWithSpans) {
+TEST_F(FormAutofillTest, LabelsWithSpans) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "  <LABEL for=\"firstname\"><span>First name: </span></LABEL>"
       "    <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
       "  <LABEL for=\"lastname\"><span>Last name: </span></LABEL>"
       "    <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
       "  <LABEL for=\"email\"><span>Email: </span></LABEL>"
       "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-// This test is different from FormManagerTest.Labels in that the label elements
-// for= attribute is set to the name of the form control element it is a label
-// for instead of the id of the form control element.  This is invalid because
-// the for= attribute must be set to the id of the form control element;
+// This test is different from FormAutofillTest.Labels in that the label
+// elements for= attribute is set to the name of the form control element it is
+// a label for instead of the id of the form control element.  This is invalid
+// because the for= attribute must be set to the id of the form control element;
 // however, current label parsing code will extract the text from the previous
 // label element and apply it to the following input field.
-TEST_F(FormManagerTest, InvalidLabels) {
+TEST_F(FormAutofillTest, InvalidLabels) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "  <LABEL for=\"firstname\"> First name: </LABEL>"
       "    <INPUT type=\"text\" name=\"firstname\" value=\"John\"/>"
       "  <LABEL for=\"lastname\"> Last name: </LABEL>"
       "    <INPUT type=\"text\" name=\"lastname\" value=\"Smith\"/>"
       "  <LABEL for=\"email\"> Email: </LABEL>"
       "    <INPUT type=\"text\" name=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
 // This test has three form control elements, only one of which has a label
 // element associated with it.
-TEST_F(FormManagerTest, OneLabelElement) {
+TEST_F(FormAutofillTest, OneLabelElement) {
   ExpectJohnSmithLabels(
            "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  First name:"
            "    <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <LABEL for=\"lastname\">Last name: </LABEL>"
            "    <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  Email:"
            "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromText) {
+TEST_F(FormAutofillTest, LabelsInferredFromText) {
   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\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromParagraph) {
+TEST_F(FormAutofillTest, LabelsInferredFromParagraph) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "  <P>First name:</P><INPUT type=\"text\" "
       "                           id=\"firstname\" value=\"John\"/>"
       "  <P>Last name:</P>"
       "    <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
       "  <P>Email:</P>"
       "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromBold) {
+TEST_F(FormAutofillTest, LabelsInferredFromBold) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "  <B>First name:</B><INPUT type=\"text\" "
       "                           id=\"firstname\" value=\"John\"/>"
       "  <B>Last name:</B>"
       "    <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
       "  <B>Email:</B>"
       "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredPriorToImgOrBr) {
+TEST_F(FormAutofillTest, LabelsInferredPriorToImgOrBr) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "  First name:<IMG/><INPUT type=\"text\" "
       "                          id=\"firstname\" value=\"John\"/>"
       "  Last name:<IMG/>"
       "    <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
       "  Email:<BR/>"
       "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromTableCell) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableCell) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<TABLE>"
       "  <TR>"
       "    <TD>First name:</TD>"
       "    <TD><INPUT type=\"text\" id=\"firstname\" value=\"John\"/></TD>"
       "  </TR>"
       "  <TR>"
       "    <TD>Last name:</TD>"
       "    <TD><INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/></TD>"
       "  </TR>"
       "  <TR>"
       "    <TD>Email:</TD>"
       "    <TD><INPUT type=\"text\" id=\"email\""
       "               value=\"john@example.com\"/></TD>"
       "  </TR>"
       "  <TR>"
       "    <TD></TD>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromTableCellTH) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableCellTH) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<TABLE>"
       "  <TR>"
       "    <TH>First name:</TH>"
       "    <TD><INPUT type=\"text\" id=\"firstname\" value=\"John\"/></TD>"
       "  </TR>"
       "  <TR>"
       "    <TH>Last name:</TH>"
       "    <TD><INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/></TD>"
       "  </TR>"
       "  <TR>"
       "    <TH>Email:</TH>"
       "    <TD><INPUT type=\"text\" id=\"email\""
       "               value=\"john@example.com\"/></TD>"
       "  </TR>"
       "  <TR>"
       "    <TD></TD>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromTableCellNested) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableCellNested) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("First name: Bogus"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("Last name:"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 47 matching lines @@
       "    <TD></TD>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromTableEmptyTDs) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableEmptyTDs) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("* First Name"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("* Last Name"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 38 matching lines @@
       "    <TD></TD>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromPreviousTD) {
+TEST_F(FormAutofillTest, LabelsInferredFromPreviousTD) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("* First Name"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("* Last Name"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 31 matching lines @@
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>",
       labels, names, values);
 }
 
 // <script>, <noscript> and <option> tags are excluded when the labels are
 // inferred.
 // Also <!-- comment --> is excluded.
-TEST_F(FormManagerTest, LabelsInferredFromTableWithSpecialElements) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableWithSpecialElements) {
   std::vector<string16> labels, names, values, control_types;
 
   labels.push_back(ASCIIToUTF16("* First Name"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
   control_types.push_back(ASCIIToUTF16("text"));
 
   labels.push_back(ASCIIToUTF16("* Middle Name"));
   names.push_back(ASCIIToUTF16("middlename"));
   values.push_back(ASCIIToUTF16("Joe"));
@@ skipping 76 matching lines @@
       "    <TD></TD>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>",
       labels, names, values, control_types);
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromTableLabels) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableLabels) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<TABLE>"
       "  <TR>"
       "    <TD>"
       "      <LABEL>First name:</LABEL>"
       "      <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
       "    </TD>"
       "  </TR>"
       "  <TR>"
       "    <TD>"
       "      <LABEL>Last name:</LABEL>"
       "      <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
       "    </TD>"
       "  </TR>"
       "  <TR>"
       "    <TD>"
       "      <LABEL>Email:</LABEL>"
       "      <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "<INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromTableTDInterveningElements) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableTDInterveningElements) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<TABLE>"
       "  <TR>"
       "    <TD>"
       "      First name:"
       "      <BR>"
       "      <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
       "    </TD>"
       "  </TR>"
@@ skipping 11 matching lines @@
       "      <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "<INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>");
 }
 
 // Verify that we correctly infer labels when the label text spans multiple
 // adjacent HTML elements, not separated by whitespace.
-TEST_F(FormManagerTest, LabelsInferredFromTableAdjacentElements) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableAdjacentElements) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("*First Name"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("*Last Name"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 33 matching lines @@
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>",
       labels, names, values);
 }
 
 // Verify that we correctly infer labels when the label text resides in the
 // previous row.
-TEST_F(FormManagerTest, LabelsInferredFromTableRow) {
+TEST_F(FormAutofillTest, LabelsInferredFromTableRow) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("*First Name *Last Name *Email"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("*First Name *Last Name *Email"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 23 matching lines @@
       "  <TR>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>",
       labels, names, values);
 }
 
 // Verify that we correctly infer labels when enclosed within a list item.
-TEST_F(FormManagerTest, LabelsInferredFromListItem) {
+TEST_F(FormAutofillTest, LabelsInferredFromListItem) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("* Home Phone"));
   names.push_back(ASCIIToUTF16("areacode"));
   values.push_back(ASCIIToUTF16("415"));
 
   labels.push_back(ASCIIToUTF16("* Home Phone"));
   names.push_back(ASCIIToUTF16("prefix"));
   values.push_back(ASCIIToUTF16("555"));
 
@@ skipping 14 matching lines @@
       "    <INPUT type=\"text\" id=\"suffix\" value=\"1212\"/>"
       "  </LI>"
       "  <LI>"
       "    <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "  </LI>"
       "</DIV>"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromDefinitionList) {
+TEST_F(FormAutofillTest, LabelsInferredFromDefinitionList) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("* First name: Bogus"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("Last name:"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 42 matching lines @@
       "  </DD>"
       "  <DT></DT>"
       "  <DD>"
       "    <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "  </DD>"
       "</DL>"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, LabelsInferredWithSameName) {
+TEST_F(FormAutofillTest, LabelsInferredWithSameName) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("Address Line 1:"));
   names.push_back(ASCIIToUTF16("Address"));
   values.push_back(string16());
 
   labels.push_back(ASCIIToUTF16("Address Line 2:"));
   names.push_back(ASCIIToUTF16("Address"));
   values.push_back(string16());
 
   labels.push_back(ASCIIToUTF16("Address Line 3:"));
   names.push_back(ASCIIToUTF16("Address"));
   values.push_back(string16());
 
   ExpectLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "  Address Line 1:"
       "    <INPUT type=\"text\" name=\"Address\"/>"
       "  Address Line 2:"
       "    <INPUT type=\"text\" name=\"Address\"/>"
       "  Address Line 3:"
       "    <INPUT type=\"text\" name=\"Address\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, LabelsInferredWithImageTags) {
+TEST_F(FormAutofillTest, LabelsInferredWithImageTags) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("Phone:"));
   names.push_back(ASCIIToUTF16("dayphone1"));
   values.push_back(string16());
 
   labels.push_back(ASCIIToUTF16("-"));
   names.push_back(ASCIIToUTF16("dayphone2"));
   values.push_back(string16());
 
@@ skipping 22 matching lines @@
       "  <img/>"
       "  <input type=\"text\" name=\"dayphone3\">"
       "  ext.:"
       "  <input type=\"text\" name=\"dayphone4\">"
       "  <input type=\"text\" name=\"dummy\">"
       "  <input type=\"submit\" name=\"reply-send\" value=\"Send\">"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromDivTable) {
+TEST_F(FormAutofillTest, LabelsInferredFromDivTable) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<DIV>First name:<BR>"
       "  <SPAN>"
       "    <INPUT type=\"text\" name=\"firstname\" value=\"John\">"
       "  </SPAN>"
       "</DIV>"
       "<DIV>Last name:<BR>"
       "  <SPAN>"
       "    <INPUT type=\"text\" name=\"lastname\" value=\"Smith\">"
       "  </SPAN>"
       "</DIV>"
       "<DIV>Email:<BR>"
       "  <SPAN>"
       "    <INPUT type=\"text\" name=\"email\" value=\"john@example.com\">"
       "  </SPAN>"
       "</DIV>"
       "<input type=\"submit\" name=\"reply-send\" value=\"Send\">"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromDivSiblingTable) {
+TEST_F(FormAutofillTest, LabelsInferredFromDivSiblingTable) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<DIV>First name:</DIV>"
       "<DIV>"
       "  <SPAN>"
       "    <INPUT type=\"text\" name=\"firstname\" value=\"John\">"
       "  </SPAN>"
       "</DIV>"
       "<DIV>Last name:</DIV>"
       "<DIV>"
       "  <SPAN>"
       "    <INPUT type=\"text\" name=\"lastname\" value=\"Smith\">"
       "  </SPAN>"
       "</DIV>"
       "<DIV>Email:</DIV>"
       "<DIV>"
       "  <SPAN>"
       "    <INPUT type=\"text\" name=\"email\" value=\"john@example.com\">"
       "  </SPAN>"
       "</DIV>"
       "<input type=\"submit\" name=\"reply-send\" value=\"Send\">"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, LabelsInferredFromDefinitionListRatherThanDivTable) {
+TEST_F(FormAutofillTest, LabelsInferredFromDefinitionListRatherThanDivTable) {
   ExpectJohnSmithLabels(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<DIV>This is not a label.<BR>"
       "<DL>"
       "  <DT>"
       "    <SPAN>"
       "      First name:"
       "    </SPAN>"
       "  </DT>"
       "  <DD>"
@@ skipping 23 matching lines @@
       "  </DD>"
       "  <DT></DT>"
       "  <DD>"
       "    <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "  </DD>"
       "</DL>"
       "</DIV>"
       "</FORM>");
 }
 
-TEST_F(FormManagerTest, FillFormMaxLength) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
 
@@ skipping 14 matching lines @@
 
   // 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;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.form_control_type = ASCIIToUTF16("text");
 
@@ skipping 12 matching lines @@
   expected.name = ASCIIToUTF16("email");
   expected.value = ASCIIToUTF16("brotherj@");
   expected.max_length = 9;
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[2]);
 }
 
 // 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(FormManagerTest, FillFormNegativeMaxLength) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("email");
   EXPECT_FORM_FIELD_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;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("Brother");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = ASCIIToUTF16("Jonathan");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("email");
   expected.value = ASCIIToUTF16("brotherj@example.com");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
-TEST_F(FormManagerTest, FillFormEmptyName) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("email");
   EXPECT_FORM_FIELD_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;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("Wyatt");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = ASCIIToUTF16("Earp");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("email");
   expected.value = ASCIIToUTF16("wyatt@example.com");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
-TEST_F(FormManagerTest, FillFormEmptyFormNames) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(2U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("apple");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field,
+                                              autofill::REQUIRE_NONE));
   EXPECT_EQ(string16(), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
   EXPECT_EQ(GURL("http://abc.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 12 matching lines @@
 
   // Fill the form.
   form.fields[0].value = ASCIIToUTF16("Red");
   form.fields[1].value = ASCIIToUTF16("Yellow");
   form.fields[2].value = ASCIIToUTF16("Also Yellow");
   FillForm(form, input_element);
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2,
+                                              autofill::REQUIRE_NONE));
 
   EXPECT_EQ(string16(), form2.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
   EXPECT_EQ(GURL("http://abc.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.name = ASCIIToUTF16("apple");
   expected.value = ASCIIToUTF16("Red");
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
 
   expected.name = ASCIIToUTF16("banana");
   expected.value = ASCIIToUTF16("Yellow");
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
 
   expected.name = ASCIIToUTF16("cantelope");
   expected.value = ASCIIToUTF16("Also Yellow");
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[2]);
 }
 
-TEST_F(FormManagerTest, ThreePartPhone) {
+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\">"
@@ skipping 36 matching lines @@
   expected.label = ASCIIToUTF16("-");
   expected.name = ASCIIToUTF16("dayphone3");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 
   expected.label = ASCIIToUTF16("ext.:");
   expected.name = ASCIIToUTF16("dayphone4");
   EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
 }
 
 
-TEST_F(FormManagerTest, MaxLengthFields) {
+TEST_F(FormAutofillTest, MaxLengthFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  Phone:"
            "  <input type=\"text\" maxlength=\"3\" name=\"dayphone1\">"
            "  -"
            "  <input type=\"text\" maxlength=\"3\" name=\"dayphone2\">"
            "  -"
            "  <input type=\"text\" maxlength=\"4\" size=\"5\""
            "         name=\"dayphone3\">"
            "  ext.:"
            "  <input type=\"text\" maxlength=\"5\" name=\"dayphone4\">"
@@ skipping 55 matching lines @@
   // When invalid |size|, default is returned.
   expected.label = string16();
   expected.name = ASCIIToUTF16("invalid1");
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_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(FormManagerTest, FillFormNonEmptyField) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms;
   form_cache.ExtractForms(*web_frame, &forms);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Simulate typing by modifying the field value.
   input_element.setValue(ASCIIToUTF16("Wy"));
 
   // Find the form that contains the input element.
   FormData form;
   FormField field;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form,
-                                                    &field));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 20 matching lines @@
   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;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("Wyatt");
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = ASCIIToUTF16("Earp");
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
 
   expected.name = ASCIIToUTF16("email");
   expected.value = ASCIIToUTF16("wyatt@example.com");
   expected.is_autofilled = true;
   EXPECT_FORM_FIELD_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(FormManagerTest, ClearFormWithNode) {
+TEST_F(FormAutofillTest, ClearFormWithNode) {
   LoadHTML(
       "<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=\"submit\" value=\"Send\"/>"
       "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
@@ skipping 16 matching lines @@
 
   // 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;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(firstname, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
   ASSERT_EQ(4U, fields2.size());
 
   FormField expected;
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
@@ skipping 12 matching lines @@
 
   expected.name = ASCIIToUTF16("notenabled");
   expected.value = ASCIIToUTF16("no clear");
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[3]);
 
   // Verify that the cursor position has been updated.
   EXPECT_EQ(0, firstname.selectionStart());
   EXPECT_EQ(0, firstname.selectionEnd());
 }
 
-TEST_F(FormManagerTest, ClearFormWithNodeContainingSelectOne) {
+TEST_F(FormAutofillTest, ClearFormWithNodeContainingSelectOne) {
   LoadHTML(
       "<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>"
@@ skipping 20 matching lines @@
 
   // 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;
   FormField field2;
-  EXPECT_TRUE(FindFormAndFieldForFormControlElement(firstname, &form2,
-                                                    &field2));
+  EXPECT_TRUE(FindFormAndFieldForInputElement(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<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
   FormField expected;
 
   expected.name = ASCIIToUTF16("firstname");
@@ skipping 12 matching lines @@
   expected.value = ASCIIToUTF16("?");
   expected.form_control_type = ASCIIToUTF16("select-one");
   expected.max_length = 0;
   EXPECT_FORM_FIELD_EQUALS(expected, fields2[2]);
 
   // Verify that the cursor position has been updated.
   EXPECT_EQ(0, firstname.selectionStart());
   EXPECT_EQ(0, firstname.selectionEnd());
 }
 
-TEST_F(FormManagerTest, ClearPreviewedFormWithElement) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
@@ skipping 47 matching lines @@
   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(FormManagerTest, ClearPreviewedFormWithNonEmptyInitiatingNode) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
@@ skipping 47 matching lines @@
   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(FormManagerTest, ClearPreviewedFormWithAutofilledInitiatingNode) {
+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>");
 
   WebFrame* web_frame = GetMainFrame();
@@ skipping 46 matching lines @@
   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(FormManagerTest, FormWithNodeIsAutofilled) {
+TEST_F(FormAutofillTest, FormWithNodeIsAutofilled) {
   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>");
 
   WebFrame* web_frame = GetMainFrame();
@@ skipping 10 matching lines @@
   // Auto-filled attribute not set yet.
   EXPECT_FALSE(FormWithElementIsAutofilled(firstname));
 
   // Set the auto-filled attribute.
   firstname.setAutofilled(true);
 
   EXPECT_TRUE(FormWithElementIsAutofilled(firstname));
 }
 
 // If we have multiple labels per id, the labels concatenated into label string.
-TEST_F(FormManagerTest, MultipleLabelsPerElement) {
+TEST_F(FormAutofillTest, MultipleLabelsPerElement) {
   std::vector<string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("First Name:"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
   labels.push_back(ASCIIToUTF16("Last Name:"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
 
@@ skipping 10 matching lines @@
       "  <LABEL for=\"lastname\"> Last Name: </LABEL>"
       "    <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
       "  <LABEL for=\"email\"> Email: </LABEL>"
       "  <LABEL for=\"email\"> xxx@yyy.com </LABEL>"
       "    <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
       "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "</FORM>",
       labels, names, values);
 }
 
-TEST_F(FormManagerTest, SelectOneAsText) {
+TEST_F(FormAutofillTest, SelectOneAsText) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  <SELECT id=\"country\">"
            "    <OPTION value=\"AF\">Afghanistan</OPTION>"
            "    <OPTION value=\"AL\">Albania</OPTION>"
            "    <OPTION value=\"DZ\">Algeria</OPTION>"
            "  </SELECT>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>");
@@ skipping 70 matching lines @@
   expected.form_control_type = ASCIIToUTF16("text");
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("country");
   expected.value = ASCIIToUTF16("AL");
   expected.form_control_type = ASCIIToUTF16("select-one");
   expected.max_length = 0;
   EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }