Refactor webkit_glue::FormField to remove hacky methods

chrome/browser/webdata/autofill_table_unittest.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/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ skipping 121 matching lines @@
 TEST_F(AutofillTableTest, Autofill) {
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   Time t1 = Time::Now();
 
   // Simulate the submission of a handful of entries in a field called "Name",
   // some more often than others.
   AutofillChangeList changes;
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes));
+  FormField field;
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Superman");
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
   std::vector<string16> v;
   for (int i = 0; i < 5; i++) {
-    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-        FormField(string16(),
-                  ASCIIToUTF16("Name"),
-                  ASCIIToUTF16("Clark Kent"),
-                  string16(),
-                  0,
-                  false),
-        &changes));
+    field.value = ASCIIToUTF16("Clark Kent");
+    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
   }
   for (int i = 0; i < 3; i++) {
-    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-        FormField(string16(),
-                  ASCIIToUTF16("Name"),
-                  ASCIIToUTF16("Clark Sutter"),
-                  string16(),
-                  0,
-                  false),
-        &changes));
+    field.value = ASCIIToUTF16("Clark Sutter");
+    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
   }
   for (int i = 0; i < 2; i++) {
-    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-        FormField(string16(),
-                  ASCIIToUTF16("Favorite Color"),
-                  ASCIIToUTF16("Green"),
-                  string16(),
-                  0,
-                  false),
-        &changes));
+    field.name = ASCIIToUTF16("Favorite Color");
+    field.value = ASCIIToUTF16("Green");
+    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
   }
 
   int count = 0;
   int64 pair_id = 0;
 
   // We have added the name Clark Kent 5 times, so count should be 5 and pair_id
   // should be somthing non-zero.
-  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Clark Kent"),
-                string16(),
-                0,
-                false),
-      &pair_id, &count));
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Clark Kent");
+  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
+                                                                &count));
   EXPECT_EQ(5, count);
   EXPECT_NE(0, pair_id);
 
   // Storing in the data base should be case sensitive, so there should be no
   // database entry for clark kent lowercase.
-  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("clark kent"),
-                string16(),
-                0,
-                false),
-      &pair_id, &count));
+  field.value = ASCIIToUTF16("clark kent");
+  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
+                                                                &count));
   EXPECT_EQ(0, count);
 
-  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
-      FormField(string16(),
-                ASCIIToUTF16("Favorite Color"),
-                ASCIIToUTF16("Green"),
-                string16(),
-                0,
-                false),
-      &pair_id, &count));
+  field.name = ASCIIToUTF16("Favorite Color");
+  field.value = ASCIIToUTF16("Green");
+  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
+                                                                &count));
   EXPECT_EQ(2, count);
 
   // This is meant to get a list of suggestions for Name.  The empty prefix
   // in the second argument means it should return all suggestions for a name
   // no matter what they start with.  The order that the names occur in the list
   // should be decreasing order by count.
   EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
       ASCIIToUTF16("Name"), string16(), &v, 6));
   EXPECT_EQ(3U, v.size());
   if (v.size() == 3) {
@@ skipping 39 matching lines @@
                                ASCIIToUTF16("Clark Sutter"))),
     AutofillChange(AutofillChange::REMOVE,
                    AutofillKey(ASCIIToUTF16("Favorite Color"),
                                ASCIIToUTF16("Green"))),
   };
   EXPECT_EQ(arraysize(expected_changes), changes.size());
   for (size_t i = 0; i < arraysize(expected_changes); i++) {
     EXPECT_EQ(expected_changes[i], changes[i]);
   }
 
-  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Clark Kent"),
-                string16(),
-                0,
-                false),
-      &pair_id, &count));
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Clark Kent");
+  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(field, &pair_id,
+                                                                &count));
   EXPECT_EQ(0, count);
 
   EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
       ASCIIToUTF16("Name"), string16(), &v, 6));
   EXPECT_EQ(0U, v.size());
 
   // Now add some values with empty strings.
   const string16 kValue = ASCIIToUTF16("  toto   ");
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-      FormField(string16(),
-          ASCIIToUTF16("blank"),
-          string16(),
-          string16(),
-          0,
-          false),
-      &changes));
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-      FormField(string16(),
-          ASCIIToUTF16("blank"),
-          ASCIIToUTF16(" "),
-          string16(),
-          0,
-          false),
-      &changes));
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-      FormField(string16(),
-          ASCIIToUTF16("blank"),
-          ASCIIToUTF16("      "),
-          string16(),
-          0,
-          false),
-      &changes));
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-      FormField(string16(),
-          ASCIIToUTF16("blank"),
-          kValue,
-          string16(),
-          0,
-          false),
-      &changes));
+  field.name = ASCIIToUTF16("blank");
+  field.value = string16();
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
+  field.name = ASCIIToUTF16("blank");
+  field.value = ASCIIToUTF16(" ");
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
+  field.name = ASCIIToUTF16("blank");
+  field.value = ASCIIToUTF16("      ");
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
+  field.name = ASCIIToUTF16("blank");
+  field.value = kValue;
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
 
   // They should be stored normally as the DB layer does not check for empty
   // values.
   v.clear();
   EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
       ASCIIToUTF16("blank"), string16(), &v, 10));
   EXPECT_EQ(4U, v.size());
 
   // Now we'll check that ClearAutofillEmptyValueElements() works as expected.
   db.GetAutofillTable()->ClearAutofillEmptyValueElements();
 
   v.clear();
   EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
       ASCIIToUTF16("blank"), string16(), &v, 10));
   ASSERT_EQ(1U, v.size());
 
   EXPECT_EQ(kValue, v[0]);
 }
 
 TEST_F(AutofillTableTest, Autofill_RemoveBetweenChanges) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   TimeDelta one_day(TimeDelta::FromDays(1));
   Time t1 = Time::Now();
   Time t2 = t1 + one_day;
 
   AutofillChangeList changes;
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes,
-      t1));
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes,
-      t2));
+  FormField field;
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Superman");
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t1));
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t2));
 
   changes.clear();
   EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
       t1, t2, &changes));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
                            AutofillKey(ASCIIToUTF16("Name"),
                                        ASCIIToUTF16("Superman"))),
             changes[0]);
   changes.clear();
 
   EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
       t2, t2 + one_day, &changes));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ(AutofillChange(AutofillChange::REMOVE,
                            AutofillKey(ASCIIToUTF16("Name"),
                                        ASCIIToUTF16("Superman"))),
             changes[0]);
 }
 
 TEST_F(AutofillTableTest, Autofill_AddChanges) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   TimeDelta one_day(TimeDelta::FromDays(1));
   Time t1 = Time::Now();
   Time t2 = t1 + one_day;
 
   AutofillChangeList changes;
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes,
-      t1));
+  FormField field;
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Superman");
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t1));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ(AutofillChange(AutofillChange::ADD,
                            AutofillKey(ASCIIToUTF16("Name"),
                                        ASCIIToUTF16("Superman"))),
             changes[0]);
 
   changes.clear();
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes,
-      t2));
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t2));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
                            AutofillKey(ASCIIToUTF16("Name"),
                                        ASCIIToUTF16("Superman"))),
             changes[0]);
 }
 
 TEST_F(AutofillTableTest, Autofill_UpdateOneWithOneTimestamp) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, -1));
   std::vector<AutofillEntry> entries;
   entries.push_back(entry);
   ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
 
-  FormField field(string16(),
-                  ASCIIToUTF16("foo"),
-                  ASCIIToUTF16("bar"),
-                  string16(),
-                  0,
-                  false);
+  FormField field;
+  field.name = ASCIIToUTF16("foo");
+  field.value = ASCIIToUTF16("bar");
   int64 pair_id;
   int count;
   ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
       field, &pair_id, &count));
   EXPECT_LE(0, pair_id);
   EXPECT_EQ(1, count);
 
   std::vector<AutofillEntry> all_entries;
   ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
   ASSERT_EQ(1U, all_entries.size());
   EXPECT_TRUE(entry == all_entries[0]);
 }
 
 TEST_F(AutofillTableTest, Autofill_UpdateOneWithTwoTimestamps) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, 2));
   std::vector<AutofillEntry> entries;
   entries.push_back(entry);
   ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
 
-  FormField field(string16(),
-                  ASCIIToUTF16("foo"),
-                  ASCIIToUTF16("bar"),
-                  string16(),
-                  0,
-                  false);
+  FormField field;
+  field.name = ASCIIToUTF16("foo");
+  field.value = ASCIIToUTF16("bar");
   int64 pair_id;
   int count;
   ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
       field, &pair_id, &count));
   EXPECT_LE(0, pair_id);
   EXPECT_EQ(2, count);
 
   std::vector<AutofillEntry> all_entries;
   ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
   ASSERT_EQ(1U, all_entries.size());
@@ skipping 22 matching lines @@
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillEntry entry0(MakeAutofillEntry("foo", "bar0", 1, -1));
   AutofillEntry entry1(MakeAutofillEntry("foo", "bar1", 2, 3));
   std::vector<AutofillEntry> entries;
   entries.push_back(entry0);
   entries.push_back(entry1);
   ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
 
-  FormField field0(string16(),
-                   ASCIIToUTF16("foo"),
-                   ASCIIToUTF16("bar0"),
-                   string16(),
-                   0,
-                   false);
+  FormField field0;
+  field0.name = ASCIIToUTF16("foo");
+  field0.value = ASCIIToUTF16("bar0");
   int64 pair_id;
   int count;
   ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
       field0, &pair_id, &count));
   EXPECT_LE(0, pair_id);
   EXPECT_EQ(1, count);
 
-  FormField field1(string16(),
-                   ASCIIToUTF16("foo"),
-                   ASCIIToUTF16("bar1"),
-                   string16(),
-                   0,
-                   false);
+  FormField field1;
+  field1.name = ASCIIToUTF16("foo");
+  field1.value = ASCIIToUTF16("bar1");
   ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
       field1, &pair_id, &count));
   EXPECT_LE(0, pair_id);
   EXPECT_EQ(2, count);
 }
 
 TEST_F(AutofillTableTest, Autofill_UpdateReplace) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillChangeList changes;
   // Add a form field.  This will be replaced.
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes));
+  FormField field;
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Superman");
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
 
   AutofillEntry entry(MakeAutofillEntry("Name", "Superman", 1, 2));
   std::vector<AutofillEntry> entries;
   entries.push_back(entry);
   ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
 
   std::vector<AutofillEntry> all_entries;
   ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
   ASSERT_EQ(1U, all_entries.size());
   EXPECT_TRUE(entry == all_entries[0]);
 }
 
 TEST_F(AutofillTableTest, Autofill_UpdateDontReplace) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   Time t = Time::Now();
   AutofillEntry existing(
       MakeAutofillEntry("Name", "Superman", t.ToTimeT(), -1));
 
   AutofillChangeList changes;
   // Add a form field.  This will NOT be replaced.
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                existing.key().name(),
-                existing.key().value(),
-                string16(),
-                0,
-                false),
-      &changes,
-      t));
+  FormField field;
+  field.name = existing.key().name();
+  field.value = existing.key().value();
+  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(field, &changes, t));
   AutofillEntry entry(MakeAutofillEntry("Name", "Clark Kent", 1, 2));
   std::vector<AutofillEntry> entries;
   entries.push_back(entry);
   ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
 
   std::vector<AutofillEntry> all_entries;
   ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
   ASSERT_EQ(2U, all_entries.size());
   AutofillEntrySet expected_entries(all_entries.begin(),
                                     all_entries.end(),
                                     CompareAutofillEntries);
   EXPECT_EQ(1U, expected_entries.count(existing));
   EXPECT_EQ(1U, expected_entries.count(entry));
 }
 
 TEST_F(AutofillTableTest, Autofill_AddFormFieldValues) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   Time t = Time::Now();
 
   // Add multiple values for "firstname" and "lastname" names.  Test that only
   // first value of each gets added. Related to security issue:
   // http://crbug.com/51727.
   std::vector<FormField> elements;
-  elements.push_back(FormField(string16(),
-                               ASCIIToUTF16("firstname"),
-                               ASCIIToUTF16("Joe"),
-                               string16(),
-                               0,
-                               false));
-  elements.push_back(FormField(string16(),
-                               ASCIIToUTF16("firstname"),
-                               ASCIIToUTF16("Jane"),
-                               string16(),
-                               0,
-                               false));
-  elements.push_back(FormField(string16(),
-                               ASCIIToUTF16("lastname"),
-                               ASCIIToUTF16("Smith"),
-                               string16(),
-                               0,
-                               false));
-  elements.push_back(FormField(string16(),
-                               ASCIIToUTF16("lastname"),
-                               ASCIIToUTF16("Jones"),
-                               string16(),
-                               0,
-                               false));
+  FormField field;

[dhollowa, 2011/08/08 21:40:39]

nit: Again, some visual separation would be helpful.

[Ilya Sherman, 2011/08/09 00:13:43]

Done.

+  field.name = ASCIIToUTF16("firstname");
+  field.value = ASCIIToUTF16("Joe");
+  elements.push_back(field);
+  field.name = ASCIIToUTF16("firstname");
+  field.value = ASCIIToUTF16("Jane");
+  elements.push_back(field);
+  field.name = ASCIIToUTF16("lastname");
+  field.value = ASCIIToUTF16("Smith");
+  elements.push_back(field);
+  field.name = ASCIIToUTF16("lastname");
+  field.value = ASCIIToUTF16("Jones");
+  elements.push_back(field);
 
   std::vector<AutofillChange> changes;
   db.GetAutofillTable()->AddFormFieldValuesTime(elements, &changes, t);
 
   ASSERT_EQ(2U, changes.size());
   EXPECT_EQ(changes[0], AutofillChange(AutofillChange::ADD,
                                        AutofillKey(ASCIIToUTF16("firstname"),
                                        ASCIIToUTF16("Joe"))));
   EXPECT_EQ(changes[1], AutofillChange(AutofillChange::ADD,
                                        AutofillKey(ASCIIToUTF16("lastname"),
@@ skipping 809 matching lines @@
 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_OneResult) {
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillChangeList changes;
   std::map<std::string, std::vector<Time> > name_value_times_map;
 
   time_t start = 0;
   std::vector<Time> timestamps1;
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes,
-      Time::FromTimeT(start)));
+  FormField field;
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Superman");
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
+                                                   Time::FromTimeT(start)));
   timestamps1.push_back(Time::FromTimeT(start));
   std::string key1("NameSuperman");
   name_value_times_map.insert(std::pair<std::string,
     std::vector<Time> > (key1, timestamps1));
 
   AutofillEntrySet expected_entries(CompareAutofillEntries);
   AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
   AutofillEntry ae1(ak1, timestamps1);
 
   expected_entries.insert(ae1);
@@ skipping 16 matching lines @@
 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoDistinct) {
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillChangeList changes;
   std::map<std::string, std::vector<Time> > name_value_times_map;
   time_t start = 0;
 
   std::vector<Time> timestamps1;
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Superman"),
-                string16(),
-                0,
-                false),
-      &changes,
-      Time::FromTimeT(start)));
+  FormField field;
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Superman");
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
+                                                   Time::FromTimeT(start)));
   timestamps1.push_back(Time::FromTimeT(start));
   std::string key1("NameSuperman");
   name_value_times_map.insert(std::pair<std::string,
     std::vector<Time> > (key1, timestamps1));
 
   start++;
   std::vector<Time> timestamps2;
-  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-      FormField(string16(),
-                ASCIIToUTF16("Name"),
-                ASCIIToUTF16("Clark Kent"),
-                string16(),
-                0,
-                false),
-      &changes,
-      Time::FromTimeT(start)));
+  field.name = ASCIIToUTF16("Name");
+  field.value = ASCIIToUTF16("Clark Kent");
+  EXPECT_TRUE(
+      db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
+                                                   Time::FromTimeT(start)));
   timestamps2.push_back(Time::FromTimeT(start));
   std::string key2("NameClark Kent");
   name_value_times_map.insert(std::pair<std::string,
     std::vector<Time> > (key2, timestamps2));
 
   AutofillEntrySet expected_entries(CompareAutofillEntries);
   AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
   AutofillKey ak2(ASCIIToUTF16("Name"), ASCIIToUTF16("Clark Kent"));
   AutofillEntry ae1(ak1, timestamps1);
   AutofillEntry ae2(ak2, timestamps2);
@@ skipping 20 matching lines @@
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   AutofillChangeList changes;
   std::map<std::string, std::vector<Time> > name_value_times_map;
 
   time_t start = 0;
   std::vector<Time> timestamps;
   for (int i = 0; i < 2; i++) {
-    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
-        FormField(string16(),
-                  ASCIIToUTF16("Name"),
-                  ASCIIToUTF16("Superman"),
-                  string16(),
-                  0,
-                  false),
-        &changes,
-        Time::FromTimeT(start)));
+    FormField field;
+    field.name = ASCIIToUTF16("Name");
+    field.value = ASCIIToUTF16("Superman");
+    EXPECT_TRUE(
+        db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
+                                                     Time::FromTimeT(start)));
     timestamps.push_back(Time::FromTimeT(start));
     start++;
   }
 
   std::string key("NameSuperman");
   name_value_times_map.insert(std::pair<std::string,
       std::vector<Time> > (key, timestamps));
 
   AutofillEntrySet expected_entries(CompareAutofillEntries);
   AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
   AutofillEntry ae1(ak1, timestamps);
 
   expected_entries.insert(ae1);
 
   std::vector<AutofillEntry> entries;
   ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
   AutofillEntrySet entry_set(entries.begin(), entries.end(),
     CompareAutofillEntries);
 
   // make sure the lists of entries match
   ASSERT_EQ(expected_entries.size(), entry_set.size());
   AutofillEntrySetIterator it;
   for (it = entry_set.begin(); it != entry_set.end(); it++) {
     expected_entries.erase(*it);
   }
 
   EXPECT_EQ(0U, expected_entries.size());
 }