[Autofill] Update the autocomplete types implementation to match the current HTML spec.

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/string16.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 35 matching lines @@
 
 class FormAutofillTest : public ChromeRenderViewTest {
  public:
   FormAutofillTest() : ChromeRenderViewTest() {}
   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"));
+    std::vector<std::string> control_types(labels.size(), "text");
     ExpectLabelsAndTypes(html, labels, names, values, control_types);
   }
 
   void ExpectLabelsAndTypes(const char* html,
                             const std::vector<string16>& labels,
                             const std::vector<string16>& names,
                             const std::vector<string16>& values,
-                            const std::vector<string16>& control_types) {
+                            const std::vector<std::string>& control_types) {
     ASSERT_EQ(labels.size(), names.size());
     ASSERT_EQ(labels.size(), values.size());
     ASSERT_EQ(labels.size(), control_types.size());
 
     LoadHTML(html);
 
     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());
 
     const FormData& form = forms[0];
     EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
     EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
     const std::vector<FormFieldData>& fields = form.fields;
     ASSERT_EQ(labels.size(), fields.size());
     for (size_t i = 0; i < labels.size(); ++i) {
-      int max_length = control_types[i] == ASCIIToUTF16("text") ?
+      int max_length = control_types[i] == "text" ?
                        WebInputElement::defaultMaxLength() : 0;
       FormFieldData expected;
       expected.label = labels[i];
       expected.name = names[i];
       expected.value = values[i];
       expected.form_control_type = control_types[i];
       expected.max_length = max_length;
       SCOPED_TRACE(StringPrintf("i: %" PRIuS, i));
       EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[i]);
     }
@@ skipping 27 matching lines @@
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormFieldData result1;
   WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result1);
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("element");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
 
   FormFieldData result2;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result2);
 
   expected.name = ASCIIToUTF16("element");
@@ skipping 10 matching lines @@
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
-  expected.form_control_type = ASCIIToUTF16("text");
+  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(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
-  expected.form_control_type = ASCIIToUTF16("text");
+  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(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebInputElement element = web_element.to<WebInputElement>();
   element.setAutofilled(true);
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.value = ASCIIToUTF16("value");
-  expected.form_control_type = ASCIIToUTF16("text");
+  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 <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(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormFieldData result1;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result1);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.max_length = 0;
-  expected.form_control_type = ASCIIToUTF16("select-one");
+  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),
       &result2);
@@ skipping 29 matching lines @@
 
   WebElement web_element = frame->document().getElementById("hidden");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.max_length = 0;
 
   expected.name = ASCIIToUTF16("hidden");
-  expected.form_control_type = ASCIIToUTF16("hidden");
+  expected.form_control_type = "hidden";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
   web_element = frame->document().getElementById("password");
   element = web_element.to<WebFormControlElement>();
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("password");
-  expected.form_control_type = ASCIIToUTF16("password");
+  expected.form_control_type = "password";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
   web_element = frame->document().getElementById("checkbox");
   element = web_element.to<WebFormControlElement>();
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("checkbox");
-  expected.form_control_type = ASCIIToUTF16("checkbox");
+  expected.form_control_type = "checkbox";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
   web_element = frame->document().getElementById("radio");
   element = web_element.to<WebFormControlElement>();
   WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result);
   expected.name = ASCIIToUTF16("radio");
-  expected.form_control_type = ASCIIToUTF16("radio");
+  expected.form_control_type = "radio";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 
 
   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");
+  expected.form_control_type = "submit";
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
 }
 
 // We should be able to extract the autocompletetype attribute.
 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=\"empty\" autocomplete=\"\"/>"
+      "<INPUT type=\"text\" id=\"off\" autocomplete=\"off\"/>"
+      "<INPUT type=\"text\" id=\"regular\" autocomplete=\"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\"/>"
+      "       autocomplete=\"billing email\"/>"
+      "<INPUT type=\"text\" id=\"experimental\" x-autocompletetype=\"email\"/>"
+      "<SELECT id=\"select\" autocomplete=\"state\"/>"
       "  <OPTION value=\"CA\">California</OPTION>"
       "  <OPTION value=\"TX\">Texas</OPTION>"
       "</SELECT>";
   html +=
-      "<INPUT type=\"text\" id=\"malicious\" x-autocompletetype=\"" +
+      "<INPUT type=\"text\" id=\"malicious\" autocomplete=\"" +
       std::string(10000, 'x') + "\"/>";
   LoadHTML(html.c_str());
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
-  // An absent attribute is equivalent to an empty one.
-  WebElement web_element = frame->document().getElementById("absent");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
-  FormFieldData result1;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result1);
+  struct TestCase {
+    const std::string element_id;
+    const std::string form_control_type;
+    const std::string autocomplete_attribute;
+  };
+  TestCase test_cases[] = {
+    // An absent attribute is equivalent to an empty one.
+    { "absent", "text", "" },
+    // Make sure there are no issues parsing an empty attribute.
+    { "empty", "text", "" },
+    // Make sure there are no issues parsing an attribute value that isn't a
+    // type hint.
+    { "off", "text", "off" },
+    // Common case: exactly one type specified.
+    { "regular", "text", "email" },
+    // Verify that we correctly extract multiple tokens as well.
+    { "multi-valued", "text", "billing email" },
+    // We previously extracted this data from the experimental
+    // 'x-autocompletetype' attribute.  Now that the field type hints are part
+    // of the spec under the autocomplete attribute, we no longer support the
+    // experimental version.
+    { "experimental", "text", "" },
+    // <select> elements should behave no differently from text fields here.
+    { "select", "select-one", "state" },
+    // 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" },
+  };
 
-  FormFieldData expected;
-  expected.name = ASCIIToUTF16("absent");
-  expected.form_control_type = ASCIIToUTF16("text");
-  expected.autocomplete_type = string16();
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    WebElement web_element = frame->document().getElementById(
+        ASCIIToUTF16(test_cases[i].element_id));
+    WebFormControlElement element = web_element.to<WebFormControlElement>();
+    FormFieldData result;
+    WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result);
 
-  web_element = frame->document().getElementById("empty");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData result2;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result2);
-  expected.name = ASCIIToUTF16("empty");
-  expected.form_control_type = ASCIIToUTF16("text");
-  expected.autocomplete_type = string16();
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2);
+    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;
 
-  // The renderer should trim whitespace.
-  web_element = frame->document().getElementById("whitespace");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData result3;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result3);
-  expected.name = ASCIIToUTF16("whitespace");
-  expected.form_control_type = ASCIIToUTF16("text");
-  expected.autocomplete_type = string16();
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result3);
-
-  // Common case: exactly one type specified.
-  web_element = frame->document().getElementById("regular");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData result4;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result4);
-  expected.name = ASCIIToUTF16("regular");
-  expected.form_control_type = ASCIIToUTF16("text");
-  expected.autocomplete_type = ASCIIToUTF16("email");
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result4);
-
-  // Verify that we correctly extract fallback types as well.
-  web_element = frame->document().getElementById("multi-valued");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData result5;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result5);
-  expected.name = ASCIIToUTF16("multi-valued");
-  expected.form_control_type = ASCIIToUTF16("text");
-  expected.autocomplete_type = ASCIIToUTF16("x-confirm-email email");
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result5);
-
-  // The attribute is not yet part of the HTML standard, so we only recognize
-  // the prefixed version -- 'x-autocompletetype' -- and not the unprefixed one.
-  web_element = frame->document().getElementById("unprefixed");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData result6;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result6);
-  expected.name = ASCIIToUTF16("unprefixed");
-  expected.form_control_type = ASCIIToUTF16("text");
-  expected.autocomplete_type = string16();
-  expected.max_length = WebInputElement::defaultMaxLength();
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result6);
-
-  // <select> elements should behave no differently from text fields here.
-  web_element = frame->document().getElementById("select");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData result7;
-  WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result7);
-  expected.name = ASCIIToUTF16("select");
-  expected.form_control_type = ASCIIToUTF16("select-one");
-  expected.autocomplete_type = ASCIIToUTF16("state");
-  expected.max_length = 0;
-  EXPECT_FORM_FIELD_DATA_EQUALS(expected, result7);
-
-  // Very long attribute values should be replaced by a default string, to
-  // prevent malicious websites from DOSing the browser process.
-  web_element = frame->document().getElementById("malicious");
-  element = web_element.to<WebFormControlElement>();
-  FormFieldData 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_DATA_EQUALS(expected, result8);
+    SCOPED_TRACE(test_cases[i].element_id);
+    EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
+  }
 }
 
 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\"/>"
@@ skipping 30 matching lines @@
   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");
   expected.value = ASCIIToUTF16("John");
   expected.label = ASCIIToUTF16("First name:");
-  expected.form_control_type = ASCIIToUTF16("text");
+  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.label = ASCIIToUTF16("Last name:");
-  expected.form_control_type = ASCIIToUTF16("text");
+  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("CA");
   expected.label = ASCIIToUTF16("State:");
-  expected.form_control_type = ASCIIToUTF16("select-one");
+  expected.form_control_type = "select-one";
   expected.max_length = 0;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
 }
 
 // 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) {
     html += "<INPUT type=\"text\"/>";
@@ skipping 56 matching lines @@
   // First form.
   const FormData& form = forms[0];
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_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.form_control_type = ASCIIToUTF16("text");
+  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]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = ASCIIToUTF16("Smith");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
@@ skipping 94 matching lines @@
         autofill::EXTRACT_VALUE, &form, NULL));
 
     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 = ASCIIToUTF16("text");
+    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]);
 
@@ skipping 31 matching lines @@
   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<FormFieldData>& fields = form.fields;
   ASSERT_EQ(4U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  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(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<FormFieldData>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
-  expected.form_control_type = ASCIIToUTF16("text");
+  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]);
@@ skipping 36 matching lines @@
   EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field,
                                               autofill::REQUIRE_AUTOCOMPLETE));
   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(7U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
@@ skipping 106 matching lines @@
   EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field,
                                               autofill::REQUIRE_AUTOCOMPLETE));
   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 = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
@@ skipping 384 matching lines @@
       "  </TR>"
       "</TABLE>"
       "</FORM>",
       labels, names, values);
 }
 
 // <script>, <noscript> and <option> tags are excluded when the labels are
 // inferred.
 // Also <!-- comment --> is excluded.
 TEST_F(FormAutofillTest, LabelsInferredFromTableWithSpecialElements) {
-  std::vector<string16> labels, names, values, control_types;
+  std::vector<string16> labels, names, values;
+  std::vector<std::string> control_types;
 
   labels.push_back(ASCIIToUTF16("* First Name"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
-  control_types.push_back(ASCIIToUTF16("text"));
+  control_types.push_back("text");
 
   labels.push_back(ASCIIToUTF16("* Middle Name"));
   names.push_back(ASCIIToUTF16("middlename"));
   values.push_back(ASCIIToUTF16("Joe"));
-  control_types.push_back(ASCIIToUTF16("text"));
+  control_types.push_back("text");
 
   labels.push_back(ASCIIToUTF16("* Last Name"));
   names.push_back(ASCIIToUTF16("lastname"));
   values.push_back(ASCIIToUTF16("Smith"));
-  control_types.push_back(ASCIIToUTF16("text"));
+  control_types.push_back("text");
 
   labels.push_back(ASCIIToUTF16("* Country"));
   names.push_back(ASCIIToUTF16("country"));
   values.push_back(ASCIIToUTF16("US"));
-  control_types.push_back(ASCIIToUTF16("select-one"));
+  control_types.push_back("select-one");
 
   labels.push_back(ASCIIToUTF16("* Email"));
   names.push_back(ASCIIToUTF16("email"));
   values.push_back(ASCIIToUTF16("john@example.com"));
-  control_types.push_back(ASCIIToUTF16("text"));
+  control_types.push_back("text");
 
   ExpectLabelsAndTypes(
       "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
       "<TABLE>"
       "  <TR>"
       "    <TD>"
       "      <SPAN>*</SPAN>"
       "      <B>First Name</B>"
       "    </TD>"
       "    <TD>"
@@ skipping 500 matching lines @@
   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<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  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]);
@@ skipping 15 matching lines @@
   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<FormFieldData>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
-  expected.form_control_type = ASCIIToUTF16("text");
+  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;
@@ skipping 36 matching lines @@
   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<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  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]);
@@ skipping 56 matching lines @@
   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<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  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]);
@@ skipping 10 matching lines @@
   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<FormFieldData>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
 
-  expected.form_control_type = ASCIIToUTF16("text");
+  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]);
 
@@ skipping 34 matching lines @@
   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<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  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]);
 
@@ skipping 65 matching lines @@
                                        &form,
                                        NULL));
   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 = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.label = ASCIIToUTF16("Phone:");
   expected.name = ASCIIToUTF16("dayphone1");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
 
   expected.label = ASCIIToUTF16("-");
   expected.name = ASCIIToUTF16("dayphone2");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
@@ skipping 38 matching lines @@
                                        &form,
                                        NULL));
   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 = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
 
   expected.label = ASCIIToUTF16("Phone:");
   expected.name = ASCIIToUTF16("dayphone1");
   expected.max_length = 3;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
 
   expected.label = ASCIIToUTF16("-");
   expected.name = ASCIIToUTF16("dayphone2");
   expected.max_length = 3;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
@@ skipping 53 matching lines @@
   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<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  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 = string16();
   expected.is_autofilled = false;
@@ skipping 88 matching lines @@
   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<FormFieldData>& fields2 = form2.fields;
   ASSERT_EQ(4U, fields2.size());
 
   FormFieldData expected;
-  expected.form_control_type = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
 
   expected.name = ASCIIToUTF16("noAC");
   expected.value = string16();
+  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]);
 
   // Verify that the cursor position has been updated.
   EXPECT_EQ(0, firstname.selectionStart());
   EXPECT_EQ(0, firstname.selectionEnd());
 }
 
@@ skipping 44 matching lines @@
   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 = string16();
-  expected.form_control_type = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
 
   expected.name = ASCIIToUTF16("lastname");
   expected.value = string16();
-  expected.form_control_type = ASCIIToUTF16("text");
+  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 = ASCIIToUTF16("select-one");
+  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, ClearPreviewedFormWithElement) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
@@ skipping 296 matching lines @@
   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");
   expected.value = ASCIIToUTF16("John");
-  expected.form_control_type = ASCIIToUTF16("text");
+  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 = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("country");
   expected.value = ASCIIToUTF16("Albania");
-  expected.form_control_type = ASCIIToUTF16("select-one");
+  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,
                                        &form,
                                        NULL));
   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 = ASCIIToUTF16("text");
+  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 = ASCIIToUTF16("text");
+  expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
 
   expected.name = ASCIIToUTF16("country");
   expected.value = ASCIIToUTF16("AL");
-  expected.form_control_type = ASCIIToUTF16("select-one");
+  expected.form_control_type = "select-one";
   expected.max_length = 0;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
 }