Move forms/ out of webkit/.

chrome/browser/webdata/autofill_table_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/autofill/autofill_type.h"
 #include "chrome/browser/autofill/credit_card.h"
 #include "chrome/browser/password_manager/encryptor.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
 #include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/form_field_data.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/forms/form_field.h"
 
 using base::Time;
 using base::TimeDelta;
-using webkit::forms::FormField;
 
 // So we can compare AutofillKeys with EXPECT_EQ().
 std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
   return os << UTF16ToASCII(key.name()) << ", " << UTF16ToASCII(key.value());
 }
 
 // So we can compare AutofillChanges with EXPECT_EQ().
 std::ostream& operator<<(std::ostream& os, const AutofillChange& change) {
   switch (change.type()) {
     case AutofillChange::ADD: {
@@ skipping 85 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;
-  FormField field;
+  FormFieldData field;
   field.name = ASCIIToUTF16("Name");
   field.value = ASCIIToUTF16("Superman");
   base::Time now = base::Time::Now();
   base::TimeDelta two_seconds = base::TimeDelta::FromSeconds(2);
   EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(field, &changes));
   std::vector<string16> v;
   for (int i = 0; i < 5; i++) {
     field.value = ASCIIToUTF16("Clark Kent");
     EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(field, &changes,
         now + i * two_seconds));
@@ skipping 137 matching lines @@
 
 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;
-  FormField field;
+  FormFieldData 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));
@@ skipping 15 matching lines @@
 
 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;
-  FormField field;
+  FormFieldData 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(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;
+  FormFieldData 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;
+  FormFieldData 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;
@@ skipping 24 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;
+  FormFieldData 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;
+  FormFieldData 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.
-  FormField field;
+  FormFieldData 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.
-  FormField field;
+  FormFieldData 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;
-  FormField field;
+  std::vector<FormFieldData> elements;
+  FormFieldData field;
   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");
@@ skipping 778 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;
-  FormField field;
+  FormFieldData 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));
 
@@ skipping 21 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;
-  FormField field;
+  FormFieldData 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));
 
@@ skipping 37 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++) {
-    FormField field;
+    FormFieldData 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");
@@ skipping 13 matching lines @@
 
   // 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());
 }