Refactor webkit_glue::FormField to remove hacky methods

chrome/renderer/autofill/form_manager_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"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/autofill/form_manager.h"
 #include "chrome/test/base/render_view_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
@@ skipping 54 matching lines @@
     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<FormField>& 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") ?
                        WebInputElement::defaultMaxLength() : 0;
-      FormField expected = FormField(labels[i],
-                                     names[i],
-                                     values[i],
-                                     control_types[i],
-                                     max_length,
-                                     false);
-      EXPECT_TRUE(fields[i].StrictlyEqualsHack(expected))
-          << "Expected \"" << expected << "\", got \"" << fields[i] << "\"";
+      FormField 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_EQUALS(expected, fields[i]);
     }
   }
 
   void ExpectJohnSmithLabels(const char* html) {
     std::vector<string16> labels, names, values;
 
     labels.push_back(ASCIIToUTF16("First name:"));
     names.push_back(ASCIIToUTF16("firstname"));
     values.push_back(ASCIIToUTF16("John"));
 
@@ skipping 18 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>();
   FormField result1;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_NONE,
                                                 &result1);
-  EXPECT_TRUE(result1.StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("element"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  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;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result2);
-  EXPECT_TRUE(result2.StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("element"),
-                ASCIIToUTF16("value"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  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) {
   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;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("element"),
-                ASCIIToUTF16("value"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  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) {
   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;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
-                                                  ASCIIToUTF16("element"),
-                                                  ASCIIToUTF16("value"),
-                                                  ASCIIToUTF16("text"),
-                                                  5,
-                                                  false)));
+
+  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) {
   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;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("element"),
-                ASCIIToUTF16("value"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                true)));
+
+  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) {
   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>();
   FormField result1;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result1);
-  EXPECT_TRUE(result1.StrictlyEqualsHack(FormField(string16(),
-                                                   ASCIIToUTF16("element"),
-                                                   ASCIIToUTF16("CA"),
-                                                   ASCIIToUTF16("select-one"),
-                                                   0,
-                                                   false)));
+
+  FormField expected;
+  expected.name = ASCIIToUTF16("element");
+  expected.max_length = 0;
+  expected.form_control_type = ASCIIToUTF16("select-one");
+
+  expected.value = ASCIIToUTF16("CA");
+  EXPECT_FORM_FIELD_EQUALS(expected, result1);
+
   FormField result2;
   FormManager::WebFormControlElementToFormField(
       element,
       static_cast<FormManager::ExtractMask>(FormManager::EXTRACT_VALUE |
                                             FormManager::EXTRACT_OPTION_TEXT),
       &result2);
-  EXPECT_TRUE(result2.StrictlyEqualsHack(FormField(string16(),
-                                                   ASCIIToUTF16("element"),
-                                                   ASCIIToUTF16("California"),
-                                                   ASCIIToUTF16("select-one"),
-                                                   0,
-                                                   false)));
+  expected.value = ASCIIToUTF16("California");
+  EXPECT_FORM_FIELD_EQUALS(expected, result2);
+
   FormField result3;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_OPTIONS,
                                                 &result3);
-  EXPECT_TRUE(result3.StrictlyEqualsHack(FormField(string16(),
-                                                   ASCIIToUTF16("element"),
-                                                   string16(),
-                                                   ASCIIToUTF16("select-one"),
-                                                   0,
-                                                   false)));
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, result3);
+
   ASSERT_EQ(2U, result3.option_values.size());
   ASSERT_EQ(2U, result3.option_contents.size());
   EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]);
   EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]);
   EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]);
   EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]);
 }
 
-// We should be not extract the value for non-text and non-select fields.
+// We should not extract the value for non-text and non-select fields.
 TEST_F(FormManagerTest, 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);
 
   WebElement web_element = frame->document().getElementById("hidden");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormField result;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
-                                                  ASCIIToUTF16("hidden"),
-                                                  string16(),
-                                                  ASCIIToUTF16("hidden"),
-                                                  0,
-                                                  false)));
+
+  FormField expected;
+  expected.max_length = 0;
+
+  expected.name = ASCIIToUTF16("hidden");
+  expected.form_control_type = ASCIIToUTF16("hidden");
+  EXPECT_FORM_FIELD_EQUALS(expected, result);
 
   web_element = frame->document().getElementById("password");
   element = web_element.to<WebFormControlElement>();
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
-                                                  ASCIIToUTF16("password"),
-                                                  string16(),
-                                                  ASCIIToUTF16("password"),
-                                                  0,
-                                                  false)));
+  expected.name = ASCIIToUTF16("password");
+  expected.form_control_type = ASCIIToUTF16("password");
+  EXPECT_FORM_FIELD_EQUALS(expected, result);
 
   web_element = frame->document().getElementById("checkbox");
   element = web_element.to<WebFormControlElement>();
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
-                                                  ASCIIToUTF16("checkbox"),
-                                                  string16(),
-                                                  ASCIIToUTF16("checkbox"),
-                                                  0,
-                                                  false)));
+  expected.name = ASCIIToUTF16("checkbox");
+  expected.form_control_type = ASCIIToUTF16("checkbox");
+  EXPECT_FORM_FIELD_EQUALS(expected, result);
 
   web_element = frame->document().getElementById("radio");
   element = web_element.to<WebFormControlElement>();
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
-                                                  ASCIIToUTF16("radio"),
-                                                  string16(),
-                                                  ASCIIToUTF16("radio"),
-                                                  0,
-                                                  false)));
+  expected.name = ASCIIToUTF16("radio");
+  expected.form_control_type = ASCIIToUTF16("radio");
+  EXPECT_FORM_FIELD_EQUALS(expected, result);
+
 
   web_element = frame->document().getElementById("submit");
   element = web_element.to<WebFormControlElement>();
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
-  EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
-                                                  ASCIIToUTF16("submit"),
-                                                  string16(),
-                                                  ASCIIToUTF16("submit"),
-                                                  0,
-                                                  false)));
+  expected.name = ASCIIToUTF16("submit");
+  expected.form_control_type = ASCIIToUTF16("submit");
+  EXPECT_FORM_FIELD_EQUALS(expected, result);
 }
 
 TEST_F(FormManagerTest, WebFormElementToFormData) {
   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=\"state\"/>"
            "    <OPTION value=\"CA\">California</OPTION>"
            "    <OPTION value=\"TX\">Texas</OPTION>"
            "  </SELECT>"
@@ skipping 14 matching lines @@
   EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
                                                     FormManager::REQUIRE_NONE,
                                                     FormManager::EXTRACT_VALUE,
                                                     &form));
   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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("John"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Smith"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("state"),
-                ASCIIToUTF16("CA"),
-                ASCIIToUTF16("select-one"),
-                0,
-                false)));
+
+  FormField expected;
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("John");
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Smith");
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("state");
+  expected.value = ASCIIToUTF16("CA");
+  expected.form_control_type = ASCIIToUTF16("select-one");
+  expected.max_length = 0;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
 TEST_F(FormManagerTest, 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>");
@@ skipping 22 matching lines @@
   ASSERT_EQ(2U, forms.size());
 
   // 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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      ASCIIToUTF16("John"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      ASCIIToUTF16("Smith"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      ASCIIToUTF16("john@example.com"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  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]);
+
+  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]);
 
   // Second form.
   const FormData& form2 = forms[1];
   EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
   EXPECT_EQ(GURL("http://zoo.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      ASCIIToUTF16("Jack"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      ASCIIToUTF16("Adams"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      ASCIIToUTF16("jack@example.com"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Jack");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
+
+  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) {
   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>");
 
@@ skipping 48 matching lines @@
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
     WebVector<WebFormElement> web_forms;
     web_frame->document().forms(web_forms);
     ASSERT_EQ(1U, web_forms.size());
     WebFormElement web_form = web_forms[0];
 
     FormData form;
     EXPECT_TRUE(FormManager::WebFormElementToFormData(
-        web_form, FormManager::REQUIRE_AUTOCOMPLETE, FormManager::EXTRACT_NONE,
+        web_form, FormManager::REQUIRE_AUTOCOMPLETE, FormManager::EXTRACT_VALUE,
         &form));
 
     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<FormField>& fields = form.fields;
     ASSERT_EQ(3U, fields.size());
-    EXPECT_EQ(FormField(string16(),
-                        ASCIIToUTF16("middlename"),
-                        ASCIIToUTF16("Jack"),
-                        ASCIIToUTF16("text"),
-                        WebInputElement::defaultMaxLength(),
-                        false),
-              fields[0]);
-    EXPECT_EQ(FormField(string16(),
-                        ASCIIToUTF16("lastname"),
-                        ASCIIToUTF16("Smith"),
-                        ASCIIToUTF16("text"),
-                        WebInputElement::defaultMaxLength(),
-                        false),
-              fields[1]);
-    EXPECT_EQ(FormField(string16(),
-                        ASCIIToUTF16("email"),
-                        ASCIIToUTF16("john@example.com"),
-                        ASCIIToUTF16("text"),
-                        WebInputElement::defaultMaxLength(),
-                        false),
-              fields[2]);
+
+    FormField expected;
+    expected.form_control_type = ASCIIToUTF16("text");
+    expected.max_length = WebInputElement::defaultMaxLength();
+
+    expected.name = ASCIIToUTF16("middlename");
+    expected.value = ASCIIToUTF16("Jack");
+    EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+    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, WebFormElementToFormDataEnabled) {
   // The firstname element is not enabled due to disabled being set.
   LoadHTML("<FORM name=\"TestForm\" action=\"http://xyz.com\" method=\"post\">"
            "  <INPUT disabled type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"middlename\" value=\"Jack\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  <INPUT type=\"text\" id=\"email\" value=\"jack@example.com\"/>"
            "  <INPUT type=\"submit\" name=\"submit\" value=\"Send\"/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
 
   WebVector<WebFormElement> web_forms;
   web_frame->document().forms(web_forms);
   ASSERT_EQ(1U, web_forms.size());
   WebFormElement web_form = web_forms[0];
 
   FormData form;
   EXPECT_TRUE(FormManager::WebFormElementToFormData(
-      web_form, FormManager::REQUIRE_ENABLED, FormManager::EXTRACT_NONE,
+      web_form, FormManager::REQUIRE_ENABLED, FormManager::EXTRACT_VALUE,
       &form));
 
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
   EXPECT_EQ(GURL("http://xyz.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("middlename"),
-                      ASCIIToUTF16("Jack"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      ASCIIToUTF16("Smith"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      ASCIIToUTF16("jack@example.com"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("middlename");
+  expected.value = ASCIIToUTF16("Jack");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Smith");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("email");
+  expected.value = ASCIIToUTF16("jack@example.com");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
 TEST_F(FormManagerTest, 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=\"submit\" name=\"reply-send\" value=\"Send\"/>"
            "</FORM>");
 
@@ skipping 12 matching lines @@
   // Find the form and verify it's the correct form.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      ASCIIToUTF16("John"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      ASCIIToUTF16("Smith"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      ASCIIToUTF16("john@example.com"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  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]);
+
+  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, 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\"/>"
@@ skipping 19 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("notempty"),
-                      ASCIIToUTF16("Hi"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("noautocomplete"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[3]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("notenabled"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[4]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("readonly"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[5]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("invisible"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[6]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("displaynone"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[7]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("notempty");
+  expected.value = ASCIIToUTF16("Hi");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
+
+  expected.name = ASCIIToUTF16("noautocomplete");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
+
+  expected.name = ASCIIToUTF16("notenabled");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[4]);
+
+  expected.name = ASCIIToUTF16("readonly");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[5]);
+
+  expected.name = ASCIIToUTF16("invisible");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[6]);
+
+  expected.name = ASCIIToUTF16("displaynone");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[7]);
 
   // Fill the form.
   form.fields[0].value = ASCIIToUTF16("Wyatt");
   form.fields[1].value = ASCIIToUTF16("Earp");
   form.fields[2].value = ASCIIToUTF16("Alpha");
   form.fields[3].value = ASCIIToUTF16("Beta");
   form.fields[4].value = ASCIIToUTF16("Gamma");
   form.fields[5].value = ASCIIToUTF16("Delta");
   form.fields[6].value = ASCIIToUTF16("Epsilon");
   form.fields[7].value = ASCIIToUTF16("Zeta");
@@ skipping 75 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("notempty"),
-                      ASCIIToUTF16("Hi"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("noautocomplete"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[3]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("notenabled"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[4]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("notempty");
+  expected.value = ASCIIToUTF16("Hi");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
+
+  expected.name = ASCIIToUTF16("noautocomplete");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
+
+  expected.name = ASCIIToUTF16("notenabled");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[4]);
 
   // Preview the form.
   form.fields[0].value = ASCIIToUTF16("Wyatt");
   form.fields[1].value = ASCIIToUTF16("Earp");
   form.fields[2].value = ASCIIToUTF16("Alpha");
   form.fields[3].value = ASCIIToUTF16("Beta");
   form.fields[4].value = ASCIIToUTF16("Gamma");
   form_manager.PreviewForm(form, input_element);
 
   // Verify the previewed elements.
@@ skipping 187 matching lines @@
       "  </TR>"
       "  <TR>"
       "    <TD></TD>"
       "    <TD>"
       "      <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
       "    </TD>"
       "  </TR>"
       "</TABLE>"
       "</FORM>");
 }
+
 TEST_F(FormManagerTest, 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 703 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      5,
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      7,
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      9,
-                      false),
-            fields[2]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.max_length = 5;
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.max_length = 7;
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("email");
+  expected.max_length = 9;
+  expected.is_autofilled = false;
+  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");
   form_manager.FillForm(form, WebNode());
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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());
-  EXPECT_TRUE(fields2[0].StrictlyEqualsHack(FormField(string16(),
-                                                      ASCIIToUTF16("firstname"),
-                                                      ASCIIToUTF16("Broth"),
-                                                      ASCIIToUTF16("text"),
-                                                      5,
-                                                      false)));
-  EXPECT_TRUE(fields2[1].StrictlyEqualsHack(FormField(string16(),
-                                                      ASCIIToUTF16("lastname"),
-                                                      ASCIIToUTF16("Jonatha"),
-                                                      ASCIIToUTF16("text"),
-                                                      7,
-                                                      false)));
-  EXPECT_TRUE(fields2[2].StrictlyEqualsHack(FormField(string16(),
-                                                      ASCIIToUTF16("email"),
-                                                      ASCIIToUTF16("brotherj@"),
-                                                      ASCIIToUTF16("text"),
-                                                      9,
-                                                      false)));
+
+  expected.form_control_type = ASCIIToUTF16("text");
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Broth");
+  expected.max_length = 5;
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Jonatha");
+  expected.max_length = 7;
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
+
+  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) {
   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\"/>"
@@ skipping 15 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  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");
   form_manager.FillForm(form, WebNode());
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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());
-  EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("Brother"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Jonathan"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("email"),
-                ASCIIToUTF16("brotherj@example.com"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  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]);
 }
 
 // This test sends a FormData object to FillForm with more fields than are in
 // the cached WebFormElement.  In this case, we only fill out the fields that
 // match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormMoreFormDataFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
@@ skipping 11 matching lines @@
   // After the field modification, the fields in |form| will look like:
   //  prefix
   //  firstname
   //  hidden
   //  middlename
   //  second
   //  lastname
   //  postfix
   FormData* form = &forms[0];
 
-  FormField field1(string16(),
-                   ASCIIToUTF16("prefix"),
-                   string16(),
-                   ASCIIToUTF16("text"),
-                   WebInputElement::defaultMaxLength(),
-                   false);
+  FormField field1;
+  field1.name = ASCIIToUTF16("prefix");
+  field1.form_control_type = ASCIIToUTF16("text");
+  field1.max_length = WebInputElement::defaultMaxLength();
   form->fields.insert(form->fields.begin(), field1);
 
-  FormField field2(string16(),
-                   ASCIIToUTF16("hidden"),
-                   string16(),
-                   ASCIIToUTF16("text"),
-                   WebInputElement::defaultMaxLength(),
-                   false);
+  FormField field2;
+  field2.name = ASCIIToUTF16("hidden");
+  field2.form_control_type = ASCIIToUTF16("text");
+  field2.max_length = WebInputElement::defaultMaxLength();
   form->fields.insert(form->fields.begin() + 2, field2);
 
-  FormField field3(string16(),
-                   ASCIIToUTF16("second"),
-                   string16(),
-                   ASCIIToUTF16("text"),
-                   WebInputElement::defaultMaxLength(),
-                   false);
+  FormField field3;
+  field3.name = ASCIIToUTF16("second");
+  field3.form_control_type = ASCIIToUTF16("text");
+  field3.max_length = WebInputElement::defaultMaxLength();
   form->fields.insert(form->fields.begin() + 4, field3);
 
-  FormField field4(string16(),
-                   ASCIIToUTF16("postfix"),
-                   string16(),
-                   ASCIIToUTF16("text"),
-                   WebInputElement::defaultMaxLength(),
-                   false);
+  FormField field4;
+  field4.name = ASCIIToUTF16("postfix");
+  field4.form_control_type = ASCIIToUTF16("text");
+  field4.max_length = WebInputElement::defaultMaxLength();
   form->fields.insert(form->fields.begin() + 6, field4);
 
   // Fill the form.
   form->fields[0].value = ASCIIToUTF16("Alpha");
   form->fields[1].value = ASCIIToUTF16("Brother");
   form->fields[2].value = ASCIIToUTF16("Abracadabra");
   form->fields[3].value = ASCIIToUTF16("Joseph");
   form->fields[4].value = ASCIIToUTF16("Beta");
   form->fields[5].value = ASCIIToUTF16("Jonathan");
   form->fields[6].value = ASCIIToUTF16("Omega");
   form_manager.FillForm(*form, WebNode());
 
   // Get the input element we want to find.
   WebElement element = web_frame->document().getElementById("firstname");
   WebInputElement input_element = element.to<WebInputElement>();
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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>& fields = form2.fields;
   ASSERT_EQ(3U, fields.size());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("Brother"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("middlename"),
-                ASCIIToUTF16("Joseph"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Jonathan"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  expected.is_autofilled = true;
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Brother");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("middlename");
+  expected.value = ASCIIToUTF16("Joseph");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Jonathan");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
 // This test sends a FormData object to FillForm with fewer fields than are in
 // the cached WebFormElement.  In this case, we only fill out the fields that
 // match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormFewerFormDataFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"prefix\"/>"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"hidden\"/>"
@@ skipping 35 matching lines @@
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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>& fields = form2.fields;
   ASSERT_EQ(7U, fields.size());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("prefix"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("Brother"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("hidden"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[3].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("middlename"),
-                ASCIIToUTF16("Joseph"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[4].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("second"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[5].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Jonathan"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[6].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("postfix"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("prefix");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Brother");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("hidden");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
+
+  expected.name = ASCIIToUTF16("middlename");
+  expected.value = ASCIIToUTF16("Joseph");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
+
+  expected.name = ASCIIToUTF16("second");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[4]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Jonathan");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[5]);
+
+  expected.name = ASCIIToUTF16("postfix");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[6]);
 }
 
 // This test sends a FormData object to FillForm with a field changed from
 // those in the cached WebFormElement.  In this case, we only fill out the
 // fields that match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormChangedFormDataFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
@@ skipping 32 matching lines @@
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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>& fields = form2.fields;
   ASSERT_EQ(3U, fields.size());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
-                                           ASCIIToUTF16("firstname"),
-                                           ASCIIToUTF16("Brother"),
-                                           ASCIIToUTF16("text"),
-                                           WebInputElement::defaultMaxLength(),
-                                           false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
-                                           ASCIIToUTF16("middlename"),
-                                           string16(),
-                                           ASCIIToUTF16("text"),
-                                           WebInputElement::defaultMaxLength(),
-                                           false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
-                                           ASCIIToUTF16("lastname"),
-                                           ASCIIToUTF16("Jonathan"),
-                                           ASCIIToUTF16("text"),
-                                           WebInputElement::defaultMaxLength(),
-                                           false)));
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Brother");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("middlename");
+  expected.value = ASCIIToUTF16("");
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Jonathan");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 }
 
 // This test sends a FormData object to FillForm with fewer fields than are in
 // the cached WebFormElement.  In this case, we only fill out the fields that
 // match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormExtraFieldInCache) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
@@ skipping 29 matching lines @@
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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>& fields = form2.fields;
   ASSERT_EQ(4U, fields.size());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("Brother"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("middlename"),
-                ASCIIToUTF16("Joseph"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Jonathan"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[3].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("postfix"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Brother");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("middlename");
+  expected.value = ASCIIToUTF16("Joseph");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Jonathan");
+  expected.is_autofilled = true;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
+
+  expected.name = ASCIIToUTF16("postfix");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
 }
 
 TEST_F(FormManagerTest, 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>");
 
@@ skipping 12 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  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");
   form_manager.FillForm(form, WebNode());
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      ASCIIToUTF16("Wyatt"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      ASCIIToUTF16("Earp"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      ASCIIToUTF16("wyatt@example.com"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[2]);
+
+  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) {
   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\">"
@@ skipping 18 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("apple"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("banana"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("cantelope"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("apple");
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("banana");
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("cantelope");
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 
   // Fill the form.
   form.fields[0].value = ASCIIToUTF16("Red");
   form.fields[1].value = ASCIIToUTF16("Yellow");
   form.fields[2].value = ASCIIToUTF16("Also Yellow");
   form_manager.FillForm(form, WebNode());
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("apple"),
-                      ASCIIToUTF16("Red"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("banana"),
-                      ASCIIToUTF16("Yellow"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("cantelope"),
-                      ASCIIToUTF16("Also Yellow"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[2]);
+
+  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) {
   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\">"
@@ skipping 14 matching lines @@
   EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
                                                     FormManager::REQUIRE_NONE,
                                                     FormManager::EXTRACT_VALUE,
                                                     &form));
   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<FormField>& fields = form.fields;
   ASSERT_EQ(4U, fields.size());
-  EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"),
-                      ASCIIToUTF16("dayphone1"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(ASCIIToUTF16("-"),
-                      ASCIIToUTF16("dayphone2"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(ASCIIToUTF16("-"),
-                      ASCIIToUTF16("dayphone3"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
-  EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"),
-                      ASCIIToUTF16("dayphone4"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[3]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.label = ASCIIToUTF16("Phone:");
+  expected.name = ASCIIToUTF16("dayphone1");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.label = ASCIIToUTF16("-");
+  expected.name = ASCIIToUTF16("dayphone2");
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  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) {
   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\">"
            "  -"
@@ skipping 17 matching lines @@
   EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
                                                     FormManager::REQUIRE_NONE,
                                                     FormManager::EXTRACT_VALUE,
                                                     &form));
   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<FormField>& fields = form.fields;
   ASSERT_EQ(6U, fields.size());
-  EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"),
-                      ASCIIToUTF16("dayphone1"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      3,
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(ASCIIToUTF16("-"),
-                      ASCIIToUTF16("dayphone2"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      3,
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(ASCIIToUTF16("-"),
-                      ASCIIToUTF16("dayphone3"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      4,
-                      false),
-            fields[2]);
-  EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"),
-                      ASCIIToUTF16("dayphone4"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      5,
-                      false),
-            fields[3]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+
+  expected.label = ASCIIToUTF16("Phone:");
+  expected.name = ASCIIToUTF16("dayphone1");
+  expected.max_length = 3;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.label = ASCIIToUTF16("-");
+  expected.name = ASCIIToUTF16("dayphone2");
+  expected.max_length = 3;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.label = ASCIIToUTF16("-");
+  expected.name = ASCIIToUTF16("dayphone3");
+  expected.max_length = 4;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
+
+  expected.label = ASCIIToUTF16("ext.:");
+  expected.name = ASCIIToUTF16("dayphone4");
+  expected.max_length = 5;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[3]);
+
   // When unspecified |size|, default is returned.
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("default1"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[4]);
+  expected.label = string16();
+  expected.name = ASCIIToUTF16("default1");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[4]);
+
   // When invalid |size|, default is returned.
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("invalid1"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[5]);
+  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) {
   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\"/>"
@@ skipping 18 matching lines @@
   // Find the form that contains the input element.
   FormData form;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      string16(),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields[2]);
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("Wy");
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[1]);
+
+  expected.name = ASCIIToUTF16("email");
+  expected.value = string16();
+  expected.is_autofilled = false;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 
   // Preview the form and verify that the cursor position has been updated.
   form.fields[0].value = ASCIIToUTF16("Wyatt");
   form.fields[1].value = ASCIIToUTF16("Earp");
   form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
   form_manager.PreviewForm(form, input_element);
   EXPECT_EQ(2, input_element.selectionStart());
   EXPECT_EQ(5, input_element.selectionEnd());
 
   // Fill the form.
   form_manager.FillForm(form, input_element);
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
                                                           &form2));
   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());
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("firstname"),
-                      ASCIIToUTF16("Wyatt"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[0]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("lastname"),
-                      ASCIIToUTF16("Earp"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[1]);
-  EXPECT_EQ(FormField(string16(),
-                      ASCIIToUTF16("email"),
-                      ASCIIToUTF16("wyatt@example.com"),
-                      ASCIIToUTF16("text"),
-                      WebInputElement::defaultMaxLength(),
-                      false),
-            fields2[2]);
+
+  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) {
   LoadHTML(
       "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
       "  <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
@@ skipping 29 matching lines @@
 
   // Verify the form is cleared.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(firstname, &form2));
   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());
-  EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("noAC"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[3].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("notenabled"),
-                ASCIIToUTF16("no clear"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
+
+  FormField expected;
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
+
+  expected.name = ASCIIToUTF16("noAC");
+  expected.value = string16();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[2]);
+
+  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) {
   LoadHTML(
       "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
       "  <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
@@ skipping 33 matching lines @@
 
   // Verify the form is cleared.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(firstname, &form2));
   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());
-  EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                string16(),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("state"),
-                ASCIIToUTF16("?"),
-                ASCIIToUTF16("select-one"),
-                0,
-                false)));
+
+  FormField expected;
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = string16();
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = string16();
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields2[1]);
+
+  expected.name = ASCIIToUTF16("state");
+  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, ClearPreviewedFormWithNode) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
@@ skipping 309 matching lines @@
       forms[0], FormManager::REQUIRE_NONE,
       static_cast<FormManager::ExtractMask>(FormManager::EXTRACT_VALUE |
           FormManager::EXTRACT_OPTION_TEXT),
           &form));
   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<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("John"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Smith"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("country"),
-                ASCIIToUTF16("Albania"),
-                ASCIIToUTF16("select-one"),
-                0,
-                false)));
+
+  FormField expected;
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("John");
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Smith");
+  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("Albania");
+  expected.form_control_type = ASCIIToUTF16("select-one");
+  expected.max_length = 0;
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[2]);
 
   form.fields.clear();
   // Extract the country select-one value as value.
   EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
                                                     FormManager::REQUIRE_NONE,
                                                     FormManager::EXTRACT_VALUE,
                                                     &form));
   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());
-  EXPECT_TRUE(fields[0].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("firstname"),
-                ASCIIToUTF16("John"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[1].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("lastname"),
-                ASCIIToUTF16("Smith"),
-                ASCIIToUTF16("text"),
-                WebInputElement::defaultMaxLength(),
-                false)));
-  EXPECT_TRUE(fields[2].StrictlyEqualsHack(
-      FormField(string16(),
-                ASCIIToUTF16("country"),
-                ASCIIToUTF16("AL"),
-                ASCIIToUTF16("select-one"),
-                0,
-                false)));
+
+  expected.name = ASCIIToUTF16("firstname");
+  expected.value = ASCIIToUTF16("John");
+  expected.form_control_type = ASCIIToUTF16("text");
+  expected.max_length = WebInputElement::defaultMaxLength();
+  EXPECT_FORM_FIELD_EQUALS(expected, fields[0]);
+
+  expected.name = ASCIIToUTF16("lastname");
+  expected.value = ASCIIToUTF16("Smith");
+  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]);
 }