Move forms/ out of webkit/.

chrome/browser/autofill/autofill_manager_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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/autofill/test_autofill_external_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/autofill/tab_autofill_manager_delegate.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tab_contents/test_tab_contents.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/form_data.h"
+#include "chrome/common/form_field_data.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_test_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAutofillClient.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
-#include "webkit/forms/form_data.h"
-#include "webkit/forms/form_field.h"
 
 using content::BrowserThread;
 using content::WebContents;
 using testing::_;
-using webkit::forms::FormData;
-using webkit::forms::FormField;
 
 namespace {
 
 // The page ID sent to the AutofillManager from the RenderView, used to send
 // an IPC message back to the renderer.
 const int kDefaultPageID = 137;
 
 typedef Tuple5<int,
                std::vector<string16>,
                std::vector<string16>,
@@ skipping 125 matching lines @@
 // Populates |form| with data corresponding to a simple address form.
 // Note that this actually appends fields to the form data, which can be useful
 // for building up more complex test forms.
 void CreateTestAddressFormData(FormData* form) {
   form->name = ASCIIToUTF16("MyForm");
   form->method = ASCIIToUTF16("POST");
   form->origin = GURL("http://myform.com/form.html");
   form->action = GURL("http://myform.com/submit.html");
   form->user_submitted = true;
 
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField(
       "First Name", "firstname", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Middle Name", "middlename", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Last Name", "lastname", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
@@ skipping 32 matching lines @@
   form->method = ASCIIToUTF16("POST");
   if (is_https) {
     form->origin = GURL("https://myform.com/form.html");
     form->action = GURL("https://myform.com/submit.html");
   } else {
     form->origin = GURL("http://myform.com/form.html");
     form->action = GURL("http://myform.com/submit.html");
   }
   form->user_submitted = true;
 
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField(
       "Name on Card", "nameoncard", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "", "text", &field);
   form->fields.push_back(field);
   if (use_month_type) {
     autofill_test::CreateTestFormField(
         "Expiration Date", "ccmonth", "", "month", &field);
     form->fields.push_back(field);
@@ skipping 29 matching lines @@
     EXPECT_EQ(expected_labels[i], labels[i]);
     EXPECT_EQ(expected_icons[i], icons[i]);
     EXPECT_EQ(expected_unique_ids[i], unique_ids[i]);
   }
 }
 
 void ExpectFilledField(const char* expected_label,
                        const char* expected_name,
                        const char* expected_value,
                        const char* expected_form_control_type,
-                       const webkit::forms::FormField& field) {
+                       const FormFieldData& field) {
   SCOPED_TRACE(expected_label);
   EXPECT_EQ(UTF8ToUTF16(expected_label), field.label);
   EXPECT_EQ(UTF8ToUTF16(expected_name), field.name);
   EXPECT_EQ(UTF8ToUTF16(expected_value), field.value);
   EXPECT_EQ(UTF8ToUTF16(expected_form_control_type), field.form_control_type);
 }
 
 // Verifies that the |filled_form| has been filled with the given data.
 // Verifies address fields if |has_address_fields| is true, and verifies
 // credit card fields if |has_credit_card_fields| is true. Verifies both if both
@@ skipping 301 matching lines @@
   virtual void TearDown() OVERRIDE {
     file_thread_.Stop();
     TabContentsTestHarness::TearDown();
   }
 
   void UpdatePasswordGenerationState(bool new_renderer) {
     autofill_manager_->UpdatePasswordGenerationState(NULL, new_renderer);
   }
 
   void GetAutofillSuggestions(int query_id,
-                              const webkit::forms::FormData& form,
-                              const webkit::forms::FormField& field) {
+                              const FormData& form,
+                              const FormFieldData& field) {
     autofill_manager_->OnQueryFormFieldAutofill(query_id,
                                                 form,
                                                 field,
                                                 gfx::Rect(),
                                                 false);
   }
 
-  void GetAutofillSuggestions(const webkit::forms::FormData& form,
-                              const webkit::forms::FormField& field) {
+  void GetAutofillSuggestions(const FormData& form,
+                              const FormFieldData& field) {
     GetAutofillSuggestions(kDefaultPageID, form, field);
   }
 
   void AutocompleteSuggestionsReturned(const std::vector<string16>& result) {
     AutocompleteHistoryManager::FromWebContents(web_contents())->
         SendSuggestions(&result);
   }
 
-  void FormsSeen(const std::vector<webkit::forms::FormData>& forms) {
+  void FormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks());
   }
 
   void FormSubmitted(const FormData& form) {
     if (autofill_manager_->OnFormSubmitted(form, base::TimeTicks::Now()))
       autofill_manager_->WaitForAsyncFormSubmit();
   }
 
   void FillAutofillFormData(int query_id,
-                            const webkit::forms::FormData& form,
-                            const webkit::forms::FormField& field,
+                            const FormData& form,
+                            const FormFieldData& field,
                             int unique_id) {
     autofill_manager_->OnFillAutofillFormData(query_id, form, field, unique_id);
   }
 
   int PackGUIDs(const GUIDPair& cc_guid, const GUIDPair& profile_guid) const {
     return autofill_manager_->PackGUIDs(cc_guid, profile_guid);
   }
 
   bool GetAutofillSuggestionsMessage(int* page_id,
                                      std::vector<string16>* values,
@@ skipping 84 matching lines @@
 
 // Test that we return all address profile suggestions when all form fields are
 // empty.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsEmptyValue) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 21 matching lines @@
 
 // Test that we return only matching address profile suggestions when the
 // selected form field has been partially filled out.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsMatchCharacter) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField("First Name", "firstname", "E", "text",
                                      &field);
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
@@ skipping 16 matching lines @@
 // Test that we return no suggestions when the form has no relevant fields.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsUnknownFields) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
   form.user_submitted = true;
 
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField("Username", "username", "", "text",
                                      &field);
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Password", "password", "", "password",
                                      &field);
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Quest", "quest", "", "quest", &field);
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Color", "color", "", "text", &field);
   form.fields.push_back(field);
@@ skipping 13 matching lines @@
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Add a duplicate profile.
   AutofillProfile* duplicate_profile =
       new AutofillProfile(
           *(autofill_manager_->GetProfileWithGUID(
               "00000000-0000-0000-0000-000000000001")));
   autofill_manager_->AddProfile(duplicate_profile);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 21 matching lines @@
 TEST_F(AutofillManagerTest, GetProfileSuggestionsAutofillDisabledByUser) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Disable Autofill.
   autofill_manager_->set_autofill_enabled(false);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we return a warning explaining that autofill suggestions are
 // unavailable when the form method is GET rather than POST.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsMethodGet) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 46 matching lines @@
 
 // Test that we return all credit card profile suggestions when all form fields
 // are empty.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsEmptyValue) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  FormField field = form.fields[1];
+  FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 22 matching lines @@
 
 // Test that we return only matching credit card profile suggestions when the
 // selected form field has been partially filled out.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsMatchCharacter) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "4", "text", &field);
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
@@ skipping 15 matching lines @@
 
 // Test that we return credit card profile suggestions when the selected form
 // field is not the credit card number field.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsNonCCNumber) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 22 matching lines @@
 
 // Test that we return a warning explaining that credit card profile suggestions
 // are unavailable when the form is not https.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsNonHTTPS) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 53 matching lines @@
                                    "04", "2012");
   credit_card->set_guid("00000000-0000-0000-0000-000000000007");
   autofill_manager_->AddCreditCard(credit_card);
 
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  FormField field = form.fields[1];
+  FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 29 matching lines @@
 
 // Test that we return profile and credit card suggestions for combined forms.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestions) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  FormField field = form.fields[0];
+  FormFieldData field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right address suggestions to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 53 matching lines @@
 // should return a warning explaining that credit card profile suggestions are
 // unavailable when the form is not https.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestionsNonHttps) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  FormField field = form.fields[0];
+  FormFieldData field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right address suggestions to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 46 matching lines @@
 }
 
 // Test that we correctly combine autofill and autocomplete suggestions.
 TEST_F(AutofillManagerTest, GetCombinedAutofillAndAutocompleteSuggestions) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions.
   // This triggers the combined message send.
   std::vector<string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
   // This suggestion is a duplicate, and should be trimmed.
   suggestions.push_back(ASCIIToUTF16("Elvis"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
@@ skipping 30 matching lines @@
 // already filled forms.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWhenFormIsAutofilled) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Mark one of the fields as filled.
   form.fields[2].is_autofilled = true;
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 12 matching lines @@
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that nothing breaks when there are autocomplete suggestions but no
 // autofill suggestions.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForAutocompleteOnly) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField(
       "Some Field", "somefield", "", "text", &field);
   form.fields.push_back(field);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions.
   // This triggers the combined message send.
@@ skipping 32 matching lines @@
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   autofill_test::SetProfileInfo(profile, "Elvis", "", "", "", "", "", "", "",
                                 "", "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
   autofill_manager_->AddProfile(profile);
 
-  FormField& field = form.fields[0];
+  FormFieldData& field = form.fields[0];
   field.is_autofilled = true;
   field.value = ASCIIToUTF16("Elvis");
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
@@ skipping 30 matching lines @@
   std::vector<string16> multi_values(2);
   multi_values[0] = ASCIIToUTF16("Elvis Presley");
   multi_values[1] = ASCIIToUTF16("Elena Love");
   profile->SetMultiInfo(NAME_FULL, multi_values);
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->AddProfile(profile);
 
   {
     // Get the first name field.
     // Start out with "E", hoping for either "Elvis" or "Elena.
-    FormField& field = form.fields[0];
+    FormFieldData& field = form.fields[0];
     field.value = ASCIIToUTF16("E");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
     // Trigger the |Send|.
     AutocompleteSuggestionsReturned(std::vector<string16>());
 
     // Test that we sent the right message to the renderer.
     int page_id = 0;
     std::vector<string16> values;
@@ skipping 14 matching lines @@
     int expected_unique_ids[] = { 1, 2 };
     ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                       kDefaultPageID, arraysize(expected_values),
                       expected_values, expected_labels, expected_icons,
                       expected_unique_ids);
   }
 
   {
     // Get the first name field.
     // This time, start out with "Ele", hoping for "Elena".
-    FormField& field = form.fields[0];
+    FormFieldData& field = form.fields[0];
     field.value = ASCIIToUTF16("Ele");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
     // Trigger the |Send|.
     AutocompleteSuggestionsReturned(std::vector<string16>());
 
     // Test that we sent the right message to the renderer.
     int page_id = 0;
     std::vector<string16> values;
@@ skipping 28 matching lines @@
   profile->set_guid("00000000-0000-0000-0000-000000000102");
   std::vector<string16> multi_values(3);
   multi_values[0] = ASCIIToUTF16("Travis Smith");
   multi_values[1] = ASCIIToUTF16("Cynthia Love");
   multi_values[2] = ASCIIToUTF16("Zac Mango");
   profile->SetMultiInfo(NAME_FULL, multi_values);
   autofill_manager_->AddProfile(profile);
 
   // Get the first name field.  And start out with "Travis", hoping for all the
   // multi-valued variants as suggestions.
-  FormField& field = form.fields[0];
+  FormFieldData& field = form.fields[0];
   field.value = ASCIIToUTF16("Travis");
   field.is_autofilled = true;
   GetAutofillSuggestions(form, field);
 
   // Trigger the |Send|.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
@@ skipping 25 matching lines @@
 
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid("00000000-0000-0000-0000-000000000103");
   std::vector<string16> multi_values(1);
   multi_values[0] = ASCIIToUTF16("Natty Bumppo");
   profile->SetMultiInfo(NAME_FULL, multi_values);
   multi_values[0] = ASCIIToUTF16("1800PRAIRIE");
   profile->SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, multi_values);
   autofill_manager_->AddProfile(profile);
 
-  const FormField& field = form.fields[9];
+  const FormFieldData& field = form.fields[9];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
   std::vector<string16> values;
   std::vector<string16> labels;
@@ skipping 271 matching lines @@
 TEST_F(AutofillManagerTest, FillFormWithAuthorSpecifiedSections) {
   // Create a form with a billing section and an unnamed section, interleaved.
   // The billing section includes both address and credit card fields.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("https://myform.com/form.html");
   form.action = GURL("https://myform.com/submit.html");
   form.user_submitted = true;
 
-  FormField field;
+  FormFieldData field;
 
   autofill_test::CreateTestFormField("", "country", "", "text", &field);
   field.autocomplete_type = ASCIIToUTF16("section-billing country");
   form.fields.push_back(field);
 
   autofill_test::CreateTestFormField("", "firstname", "", "text", &field);
   field.autocomplete_type = ASCIIToUTF16("given-name");
   form.fields.push_back(field);
 
   autofill_test::CreateTestFormField("", "lastname", "", "text", &field);
@@ skipping 133 matching lines @@
     ExpectFilledField("", "email", "", "text", results.fields[10]);
   }
 }
 
 // Test that we correctly fill a form that has a single logical section with
 // multiple email address fields.
 TEST_F(AutofillManagerTest, FillFormWithMultipleEmails) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField(
       "Confirm email", "email2", "", "text", &field);
   form.fields.push_back(field);
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Fill the form.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
@@ skipping 47 matching lines @@
 
   page_id = 0;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   {
     SCOPED_TRACE("Credit card 1");
     ExpectFilledCreditCardFormElvis(page_id, results, kPageID2, true);
   }
 
   // Now set the credit card fields to also be auto-filled, and try again to
   // fill the credit card data
-  for (std::vector<FormField>::iterator iter = form.fields.begin();
+  for (std::vector<FormFieldData>::iterator iter = form.fields.begin();
        iter != form.fields.end();
        ++iter) {
     iter->is_autofilled = true;
   }
 
   const int kPageID3 = 3;
   FillAutofillFormData(kPageID3, form, *form.fields.rbegin(),
                        PackGUIDs(guid2, empty));
 
   page_id = 0;
@@ skipping 76 matching lines @@
     size_t max_length;
     const char* autocomplete_type;
   } test_fields[] = {
     { "country code", "country_code", 1, "phone-country-code" },
     { "area code", "area_code", 3, "phone-area-code" },
     { "phone", "phone_prefix", 3, "phone-local-prefix" },
     { "-", "phone_suffix", 4, "phone-local-suffix" },
     { "Phone Extension", "ext", 3, "phone-extension" }
   };
 
-  FormField field;
+  FormFieldData field;
   const size_t default_max_length = field.max_length;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_fields); ++i) {
     autofill_test::CreateTestFormField(
         test_fields[i].label, test_fields[i].name, "", "text", &field);
     field.max_length = test_fields[i].max_length;
     field.autocomplete_type = string16();
     form_with_maxlength.fields.push_back(field);
 
     field.max_length = default_max_length;
     field.autocomplete_type = ASCIIToUTF16(test_fields[i].autocomplete_type);
@@ skipping 107 matching lines @@
   EXPECT_EQ(string16(), results5.fields[4].value);
 }
 
 // Test that we can still fill a form when a field has been removed from it.
 TEST_F(AutofillManagerTest, FormChangesRemoveField) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
 
   // Add a field -- we'll remove it again later.
-  FormField field;
+  FormFieldData field;
   autofill_test::CreateTestFormField("Some", "field", "", "text", &field);
   form.fields.insert(form.fields.begin() + 3, field);
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Now, after the call to |FormsSeen|, we remove the field before filling.
   form.fields.erase(form.fields.begin() + 3);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
@@ skipping 10 matching lines @@
 // Test that we can still fill a form when a field has been added to it.
 TEST_F(AutofillManagerTest, FormChangesAddField) {
   // The offset of the phone field in the address form.
   const int kPhoneFieldOffset = 9;
 
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
 
   // Remove the phone field -- we'll add it back later.
-  std::vector<FormField>::iterator pos =
+  std::vector<FormFieldData>::iterator pos =
       form.fields.begin() + kPhoneFieldOffset;
-  FormField field = *pos;
+  FormFieldData field = *pos;
   pos = form.fields.erase(pos);
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Now, after the call to |FormsSeen|, we restore the field before filling.
   form.fields.insert(pos, field);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
@@ skipping 78 matching lines @@
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Cache the expected form signature.
   std::string signature = FormStructure(form).FormSignature();
 
   // Change the structure of the form prior to submission.
   // Websites would typically invoke JavaScript either on page load or on form
   // submit to achieve this.
   form.fields.pop_back();
-  FormField field = form.fields[3];
+  FormFieldData field = form.fields[3];
   form.fields[3] = form.fields[7];
   form.fields[7] = field;
 
   // Simulate form submission.
   FormSubmitted(form);
   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
 }
 
 // Test that we do not save form data when submitted fields contain default
 // values.
@@ skipping 59 matching lines @@
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
   form.user_submitted = true;
 
   std::vector<FieldTypeSet> expected_types;
 
   // These fields should all match.
-  FormField field;
+  FormFieldData field;
   FieldTypeSet types;
   autofill_test::CreateTestFormField("", "1", "Elvis", "text", &field);
   types.clear();
   types.insert(NAME_FIRST);
   form.fields.push_back(field);
   expected_types.push_back(types);
 
   autofill_test::CreateTestFormField("", "2", "Aaron", "text", &field);
   types.clear();
   types.insert(NAME_MIDDLE);
@@ skipping 411 matching lines @@
 namespace {
 
 class MockAutofillExternalDelegate : public TestAutofillExternalDelegate {
  public:
   explicit MockAutofillExternalDelegate(TabContents* tab_contents,
                                         AutofillManager* autofill_manager)
       : TestAutofillExternalDelegate(tab_contents, autofill_manager) {}
   virtual ~MockAutofillExternalDelegate() {}
 
   MOCK_METHOD5(OnQuery, void(int query_id,
-                             const webkit::forms::FormData& form,
-                             const webkit::forms::FormField& field,
+                             const FormData& form,
+                             const FormFieldData& field,
                              const gfx::Rect& bounds,
                              bool display_warning));
 
   virtual void OnQueryPlatformSpecific(int query_id,
-                                       const webkit::forms::FormData& form,
-                                       const webkit::forms::FormField& field,
+                                       const FormData& form,
+                                       const FormFieldData& field,
                                        const gfx::Rect& bounds) OVERRIDE {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutofillExternalDelegate);
 };
 
 }  // namespace
 
 // Test our external delegate is called at the right time.
 TEST_F(AutofillManagerTest, TestExternalDelegate) {
   MockAutofillExternalDelegate external_delegate(tab_contents(),
                                                  autofill_manager_);
   EXPECT_CALL(external_delegate, OnQuery(_, _, _, _, _));
   autofill_manager_->SetExternalDelegate(&external_delegate);
 
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
-  const FormField& field = form.fields[0];
+  const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   autofill_manager_->SetExternalDelegate(NULL);
 }
 
 #if defined(OS_ANDROID) || defined(TOOLKIT_GTK)
 // OS_ANDROID defines an external delegate, but prerequisites for
 // landing autofill_external_delegate_android.cc in the Chromium tree
 // have not themselves landed.
 
 // Turn on the external delegate.  Recreate a WebContents.  Make sure
 // an external delegate was set in the proper structures.
 TEST_F(AutofillManagerTest, TestTabContentsWithExternalDelegate) {
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kExternalAutofillPopup);
 
   // Setting the contents creates a new TabContents.
   WebContents* contents = CreateTestWebContents();
   SetContents(contents);
 
   AutofillManager* autofill_manager = tab_contents()->autofill_manager();
   EXPECT_TRUE(autofill_manager->external_delegate());
 
   AutocompleteHistoryManager* autocomplete_history_manager =
       AutocompleteHistoryManager::FromWebContents(web_contents());
   EXPECT_TRUE(autocomplete_history_manager->external_delegate());
 }
 
 #endif  // OS_ANDROID