Begin abstracting sending of IPC from autofill core code.

components/autofill/core/browser/autofill_manager_unittest.cc

 // Copyright 2013 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/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 225 matching lines @@
   form->action = GURL("http://myform.com/submit.html");
   form->user_submitted = true;
 
   FormFieldData field;
   test::CreateTestFormField("Shipping1", "option", "option1", "radio", &field);
   form->fields.push_back(field);
   test::CreateTestFormField("Shipping2", "option", "option2", "radio", &field);
   form->fields.push_back(field);
 }
 
-// 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;
-
-  FormFieldData field;
-  test::CreateTestFormField("First Name", "firstname", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Middle Name", "middlename", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Last Name", "lastname", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Address Line 1", "addr1", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Address Line 2", "addr2", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("City", "city", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("State", "state", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Postal Code", "zipcode", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Country", "country", "", "text", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Phone Number", "phonenumber", "", "tel", &field);
-  form->fields.push_back(field);
-  test::CreateTestFormField("Email", "email", "", "email", &field);
-  form->fields.push_back(field);
-}
-
 // Populates |form| with data corresponding to a simple credit card form.
 // Note that this actually appends fields to the form data, which can be useful
 // for building up more complex test forms.
 void CreateTestCreditCardFormData(FormData* form,
                                   bool is_https,
                                   bool use_month_type) {
   form->name = ASCIIToUTF16("MyForm");
   form->method = ASCIIToUTF16("POST");
   if (is_https) {
     form->origin = GURL("https://myform.com/form.html");
@@ skipping 193 matching lines @@
   MockAutocompleteHistoryManager(AutofillDriver* driver,
                                  AutofillManagerDelegate* delegate)
       : AutocompleteHistoryManager(driver, delegate) {}
 
   MOCK_METHOD1(OnFormSubmitted, void(const FormData& form));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteHistoryManager);
 };
 
+class MockAutofillDriver : public TestAutofillDriver {
+ public:
+  explicit MockAutofillDriver(content::WebContents* web_contents)
+      : TestAutofillDriver(web_contents) {}
+
+  // Mock methods to enable testability.
+  MOCK_METHOD2(SendFormDataToRenderer, void(int query_id,
+                                            const FormData& data));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
+};
+
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
                       autofill::AutofillManagerDelegate* delegate,
                       TestPersonalDataManager* personal_data)
       : AutofillManager(driver, delegate, personal_data),
         personal_data_(personal_data),
         autofill_enabled_(true) {}
   virtual ~TestAutofillManager() {}
 
@@ skipping 176 matching lines @@
     profile->CreateRequestContext();
     browser_context_.reset(profile);
     autofill::PersonalDataManagerFactory::GetInstance()->SetTestingFactory(
         profile, TestPersonalDataManager::Build);
 
     ChromeRenderViewHostTestHarness::SetUp();
 
     autofill::TabAutofillManagerDelegate::CreateForWebContents(web_contents());
 
     personal_data_.SetBrowserContext(profile);
-    autofill_driver_.reset(new TestAutofillDriver(web_contents()));
+    autofill_driver_.reset(new MockAutofillDriver(web_contents()));
     autofill_manager_.reset(new TestAutofillManager(
         autofill_driver_.get(),
         autofill::TabAutofillManagerDelegate::FromWebContents(web_contents()),
         &personal_data_));
   }
 
   virtual void TearDown() OVERRIDE {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed. Also, a real
     // AutofillManager is tied to the lifetime of the WebContents, so it must
@@ skipping 52 matching lines @@
       autofill_manager_->WaitForAsyncFormSubmit();
   }
 
   void FillAutofillFormData(int query_id,
                             const FormData& form,
                             const FormFieldData& field,
                             int unique_id) {
     autofill_manager_->OnFillAutofillFormData(query_id, form, field, unique_id);
   }
 
+  // Calls |autofill_manager_->OnFillAutofillFormData()| with the specified
+  // input parameters after setting up the expectation that the mock driver's
+  // |SendFormDataToRenderer()| method will be called and saving the parameters
+  // of that call into the |response_query_id| and |response_data| output
+  // parameters.
+  void FillAutofillFormDataAndSaveResults(int input_query_id,
+                                          const FormData& input_form,
+                                          const FormFieldData& input_field,
+                                          int unique_id,
+                                          int* response_query_id,
+                                          FormData* response_data) {
+    EXPECT_CALL(*autofill_driver_, SendFormDataToRenderer(_, _)).
+        WillOnce((DoAll(testing::SaveArg<0>(response_query_id),
+                        testing::SaveArg<1>(response_data))));
+    FillAutofillFormData(input_query_id, input_form, input_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<base::string16>* values,
                                      std::vector<base::string16>* labels,
                                      std::vector<base::string16>* icons,
                                      std::vector<int>* unique_ids) {
     const uint32 kMsgID = AutofillMsg_SuggestionsReturned::ID;
@@ skipping 20 matching lines @@
     return true;
   }
 
   bool HasSeenAutofillGetAllFormsMessage() {
     const uint32 kMsgID = AutofillMsg_GetAllForms::ID;
     const IPC::Message* message =
         process()->sink().GetFirstMessageMatching(kMsgID);
     return message != NULL;
   }
 
-  bool GetAutofillFormDataFilledMessage(int* page_id, FormData* results) {
-    const uint32 kMsgID = AutofillMsg_FormDataFilled::ID;
-    const IPC::Message* message =
-        process()->sink().GetFirstMessageMatching(kMsgID);
-    if (!message)
-      return false;
-    Tuple2<int, FormData> autofill_param;
-    AutofillMsg_FormDataFilled::Read(message, &autofill_param);
-    if (page_id)
-      *page_id = autofill_param.a;
-    if (results)
-      *results = autofill_param.b;
-
-    process()->sink().ClearMessages();
-    return true;
-  }
-
  protected:
-  scoped_ptr<TestAutofillDriver> autofill_driver_;
+  scoped_ptr<MockAutofillDriver> autofill_driver_;
   scoped_ptr<TestAutofillManager> autofill_manager_;
   TestPersonalDataManager personal_data_;
 
   // Used when we want an off the record profile. This will store the original
   // profile from which the off the record profile is derived.
   scoped_ptr<Profile> other_browser_context_;
 };
 
 class TestFormStructure : public FormStructure {
  public:
@@ skipping 16 matching lines @@
     UpdateAutofillCount();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestFormStructure);
 };
 
 // Test that browser asks for all forms when Autocheckout is enabled.
 TEST_F(AutofillManagerTest, GetAllForms) {
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   // Enable autocheckout.
   autofill_manager_->set_autocheckout_url_prefix("test-prefix");
 
   PartialFormsSeen(forms);
 
   ASSERT_TRUE(HasSeenAutofillGetAllFormsMessage());
 }
 
 // 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);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   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<base::string16>());
 
@@ skipping 23 matching lines @@
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that in the case of Autocheckout, forms seen are in order supplied.
 TEST_F(AutofillManagerTest, AutocheckoutFormsSeen) {
   FormData shipping_options;
   CreateTestShippingOptionsFormData(&shipping_options);
   FormData user_supplied;
   CreateTestFormWithAutocompleteAttribute(&user_supplied);
   FormData address;
-  CreateTestAddressFormData(&address);
+  test::CreateTestAddressFormData(&address);
 
   // Push user_supplied before address and observe order changing when
   // Autocheckout is not enabled..
   std::vector<FormData> forms;
   forms.push_back(shipping_options);
   forms.push_back(user_supplied);
   forms.push_back(address);
 
   // Test without enabling Autocheckout. FormStructure should only contain
   // form1. Shipping Options form will not qualify as parsable form.
@@ skipping 16 matching lines @@
   EXPECT_EQ("/form.html", form_structures[2]->source_url().path());
 }
 
 // Test that in the case of Autocheckout, forms seen are in order supplied.
 TEST_F(AutofillManagerTest, DynamicFormsSeen) {
   FormData shipping_options;
   CreateTestShippingOptionsFormData(&shipping_options);
   FormData user_supplied;
   CreateTestFormWithAutocompleteAttribute(&user_supplied);
   FormData address;
-  CreateTestAddressFormData(&address);
+  test::CreateTestAddressFormData(&address);
 
   autofill_manager_->set_autocheckout_url_prefix("test-prefix");
   // Push user_supplied only
   std::vector<FormData> forms;
   forms.push_back(user_supplied);
 
   // Make sure normal form is handled correctly.
   FormsSeen(forms);
   std::vector<FormStructure*> form_structures;
   form_structures = autofill_manager_->GetFormStructures();
@@ skipping 13 matching lines @@
   EXPECT_EQ("/userspecified.html", form_structures[0]->source_url().path());
   EXPECT_EQ("/shipping.html", form_structures[1]->source_url().path());
   EXPECT_EQ("/form.html", form_structures[2]->source_url().path());
 }
 
 // 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);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field;
   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<base::string16>());
@@ skipping 40 matching lines @@
   FormsSeen(forms);
 
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we cull duplicate profile suggestions.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsWithDuplicates) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   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);
 
@@ skipping 25 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);
 }
 
 // Test that we return no suggestions when autofill is disabled.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsAutofillDisabledByUser) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Disable Autofill.
   autofill_manager_->set_autofill_enabled(false);
 
   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);
+  test::CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   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<base::string16>());
@@ skipping 297 matching lines @@
   };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // 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);
+  test::CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   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<base::string16>());
@@ skipping 53 matching lines @@
                     expected_labels2, expected_icons2, expected_unique_ids2);
 }
 
 // Test that for non-https forms with both address and credit card fields, we
 // only return address suggestions. Instead of credit card suggestions, we
 // 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);
+  test::CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   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<base::string16>());
@@ skipping 46 matching lines @@
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we correctly combine autofill and autocomplete suggestions.
 TEST_F(AutofillManagerTest, GetCombinedAutofillAndAutocompleteSuggestions) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions.
   // This triggers the combined message send.
   std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
@@ skipping 29 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return autocomplete-like suggestions when trying to autofill
 // already filled forms.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWhenFormIsAutofilled) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Mark one of the fields as filled.
   form.fields[2].is_autofilled = true;
   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.
@@ skipping 17 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     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);
+  test::CreateTestAddressFormData(&form);
   FormFieldData field;
   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 21 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we do not return duplicate values drawn from multiple profiles when
 // filling an already filled field.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWithDuplicateValues) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   test::SetProfileInfo(
       profile, "Elvis", "", "", "", "", "", "", "", "", "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
   autofill_manager_->AddProfile(profile);
 
@@ skipping 22 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that a non-default value is suggested for multi-valued profile, on an
 // unfilled form.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForMultiValuedProfileUnfilled) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   test::SetProfileInfo(profile, "Elvis", "", "Presley", "me@x.com", "",
                        "", "", "", "", "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
   std::vector<base::string16> multi_values(2);
   multi_values[0] = ASCIIToUTF16("Elvis Presley");
@@ skipping 66 matching lines @@
                       expected_values, expected_labels, expected_icons,
                       expected_unique_ids);
   }
 }
 
 // Test that all values are suggested for multi-valued profile, on a filled
 // form.  This is the per-field "override" case.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForMultiValuedProfileFilled) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid("00000000-0000-0000-0000-000000000102");
   std::vector<base::string16> multi_values(3);
   multi_values[0] = ASCIIToUTF16("Travis Smith");
   multi_values[1] = ASCIIToUTF16("Cynthia Love");
   multi_values[2] = ASCIIToUTF16("Zac Mango");
@@ skipping 30 matching lines @@
                                       base::string16() };
   int expected_unique_ids[] = { 1, 2, 3 };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 TEST_F(AutofillManagerTest, GetProfileSuggestionsFancyPhone) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid("00000000-0000-0000-0000-000000000103");
   std::vector<base::string16> multi_values(1);
   multi_values[0] = ASCIIToUTF16("Natty Bumppo");
   profile->SetRawMultiInfo(NAME_FULL, multi_values);
   multi_values[0] = ASCIIToUTF16("1800PRAIRIE");
   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, multi_values);
@@ skipping 32 matching lines @@
   int expected_unique_ids[] = {1, 2, 3};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we correctly fill an address form.
 TEST_F(AutofillManagerTest, FillAddressForm) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 }
 
 // Test that we correctly fill an address form from an auxiliary profile.
 TEST_F(AutofillManagerTest, FillAddressFormFromAuxiliaryProfile) {
   personal_data_.ClearAutofillProfiles();
   PrefService* prefs = user_prefs::UserPrefs::Get(profile());
   prefs->SetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, true);
   personal_data_.CreateTestAuxiliaryProfiles();
 
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 }
 
 // Test that we correctly fill a credit card form.
 TEST_F(AutofillManagerTest, FillCreditCardForm) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000004", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, *form.fields.begin(),
-                       PackGUIDs(guid, empty));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledCreditCardFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
+      PackGUIDs(guid, empty), &response_page_id, &response_data);
+  ExpectFilledCreditCardFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 1. year empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardFormNoYearNoMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
   personal_data_.CreateTestCreditCardsYearAndMonth("", "");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, *form.fields.begin(),
-                       PackGUIDs(guid, empty));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
+      PackGUIDs(guid, empty), &response_page_id, &response_data);
+  ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
       kDefaultPageID, false, "", "");
 }
 
 
 // Test that we correctly fill a credit card form with month input type.
 // 2. year empty, month non-empty
 TEST_F(AutofillManagerTest, FillCreditCardFormNoYearMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
   personal_data_.CreateTestCreditCardsYearAndMonth("", "04");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, *form.fields.begin(),
-                       PackGUIDs(guid, empty));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
+      PackGUIDs(guid, empty), &response_page_id, &response_data);
+  ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
       kDefaultPageID, false, "", "04");
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 3. year non-empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardFormYearNoMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
   personal_data_.CreateTestCreditCardsYearAndMonth("2012", "");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, *form.fields.begin(),
-                       PackGUIDs(guid, empty));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
+      PackGUIDs(guid, empty), &response_page_id, &response_data);
+  ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
       kDefaultPageID, false, "2012", "");
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 4. year non-empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardFormYearMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
   personal_data_.ClearCreditCards();
   personal_data_.CreateTestCreditCardsYearAndMonth("2012", "04");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, *form.fields.begin(),
-                       PackGUIDs(guid, empty));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
+      PackGUIDs(guid, empty), &response_page_id, &response_data);
+  ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
       kDefaultPageID, false, "2012", "04");
 }
 
 // Test that we correctly fill a combined address and credit card form.
 TEST_F(AutofillManagerTest, FillAddressAndCreditCardForm) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // First fill the address data.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  int response_page_id = 0;
+  FormData response_data;
   {
     SCOPED_TRACE("Address");
-    ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, true);
+    FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+        PackGUIDs(empty, guid), &response_page_id, &response_data);
+    ExpectFilledAddressFormElvis(
+        response_page_id, response_data, kDefaultPageID, true);
   }
 
   // Now fill the credit card data.
   const int kPageID2 = 2;
   GUIDPair guid2("00000000-0000-0000-0000-000000000004", 0);
-  FillAutofillFormData(kPageID2, form, form.fields.back(),
-                       PackGUIDs(guid2, empty));
-
-  page_id = 0;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  response_page_id = 0;
   {
+    FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
+        PackGUIDs(guid2, empty), &response_page_id, &response_data);
     SCOPED_TRACE("Credit card");
-    ExpectFilledCreditCardFormElvis(page_id, results, kPageID2, true);
+    ExpectFilledCreditCardFormElvis(
+        response_page_id, response_data, kPageID2, true);
   }
 }
 
 // Test that we correctly fill a form that has multiple logical sections, e.g.
 // both a billing and a shipping address.
 TEST_F(AutofillManagerTest, FillFormWithMultipleSections) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   const size_t kAddressFormSize = form.fields.size();
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
     // Make sure the fields have distinct names.
     form.fields[i].name = form.fields[i].name + ASCIIToUTF16("_");
   }
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Fill the first section.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address 1");
-
     // The second address section should be empty.
-    ASSERT_EQ(results.fields.size(), 2*kAddressFormSize);
+    ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
     for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
-      EXPECT_EQ(base::string16(), results.fields[i].value);
+      EXPECT_EQ(base::string16(), response_data.fields[i].value);
     }
 
     // The first address section should be filled with Elvis's data.
-    results.fields.resize(kAddressFormSize);
-    ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+    response_data.fields.resize(kAddressFormSize);
+    ExpectFilledAddressFormElvis(
+        response_page_id, response_data, kDefaultPageID, false);
   }
 
   // Fill the second section, with the initiating field somewhere in the middle
   // of the section.
   const int kPageID2 = 2;
   GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
   ASSERT_LT(9U, kAddressFormSize);
-  FillAutofillFormData(kPageID2, form, form.fields[kAddressFormSize + 9],
-                       PackGUIDs(empty, guid2));
-
-  page_id = 0;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  response_page_id = 0;
+  FillAutofillFormDataAndSaveResults(
+      kPageID2, form, form.fields[kAddressFormSize + 9],
+      PackGUIDs(empty, guid2), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address 2");
-    ASSERT_EQ(results.fields.size(), form.fields.size());
+    ASSERT_EQ(response_data.fields.size(), form.fields.size());
 
     // The first address section should be empty.
-    ASSERT_EQ(results.fields.size(), 2*kAddressFormSize);
+    ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
-      EXPECT_EQ(base::string16(), results.fields[i].value);
+      EXPECT_EQ(base::string16(), response_data.fields[i].value);
     }
 
     // The second address section should be filled with Elvis's data.
-    FormData secondSection = results;
+    FormData secondSection = response_data;
     secondSection.fields.erase(secondSection.fields.begin(),
                                secondSection.fields.begin() + kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
       // Restore the expected field names.
       base::string16 name = secondSection.fields[i].name;
       base::string16 original_name = name.substr(0, name.size() - 1);
       secondSection.fields[i].name = original_name;
     }
-    ExpectFilledAddressFormElvis(page_id, secondSection, kPageID2, false);
+    ExpectFilledAddressFormElvis(
+        response_page_id, secondSection, kPageID2, false);
   }
 }
 
 // Test that we correctly fill a form that has author-specified sections, which
 // might not match our expected section breakdown.
 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");
@@ skipping 47 matching lines @@
   test::CreateTestFormField("", "email", "", "text", &field);
   field.autocomplete_attribute = "email";
   form.fields.push_back(field);
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Fill the unnamed section.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[1],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[1],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Unnamed section");
-    EXPECT_EQ(kDefaultPageID, page_id);
-    EXPECT_EQ(ASCIIToUTF16("MyForm"), results.name);
-    EXPECT_EQ(ASCIIToUTF16("POST"), results.method);
-    EXPECT_EQ(GURL("https://myform.com/form.html"), results.origin);
-    EXPECT_EQ(GURL("https://myform.com/submit.html"), results.action);
-    EXPECT_TRUE(results.user_submitted);
-    ASSERT_EQ(11U, results.fields.size());
+    EXPECT_EQ(kDefaultPageID, response_page_id);
+    EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
+    EXPECT_EQ(ASCIIToUTF16("POST"), response_data.method);
+    EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
+    EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
+    EXPECT_TRUE(response_data.user_submitted);
+    ASSERT_EQ(11U, response_data.fields.size());
 
-    ExpectFilledField("", "country", "", "text", results.fields[0]);
-    ExpectFilledField("", "firstname", "Elvis", "text", results.fields[1]);
-    ExpectFilledField("", "lastname", "Presley", "text", results.fields[2]);
-    ExpectFilledField("", "address", "", "text", results.fields[3]);
-    ExpectFilledField("", "city", "", "text", results.fields[4]);
-    ExpectFilledField("", "state", "", "text", results.fields[5]);
-    ExpectFilledField("", "zip", "", "text", results.fields[6]);
-    ExpectFilledField("", "ccname", "", "text", results.fields[7]);
-    ExpectFilledField("", "ccnumber", "", "text", results.fields[8]);
-    ExpectFilledField("", "ccexp", "", "text", results.fields[9]);
+    ExpectFilledField("", "country", "", "text", response_data.fields[0]);
+    ExpectFilledField("", "firstname", "Elvis", "text",
+                      response_data.fields[1]);
+    ExpectFilledField("", "lastname", "Presley", "text",
+                      response_data.fields[2]);
+    ExpectFilledField("", "address", "", "text", response_data.fields[3]);
+    ExpectFilledField("", "city", "", "text", response_data.fields[4]);
+    ExpectFilledField("", "state", "", "text", response_data.fields[5]);
+    ExpectFilledField("", "zip", "", "text", response_data.fields[6]);
+    ExpectFilledField("", "ccname", "", "text", response_data.fields[7]);
+    ExpectFilledField("", "ccnumber", "", "text", response_data.fields[8]);
+    ExpectFilledField("", "ccexp", "", "text", response_data.fields[9]);
     ExpectFilledField("", "email", "theking@gmail.com", "text",
-                      results.fields[10]);
+                      response_data.fields[10]);
   }
 
   // Fill the address portion of the billing section.
   const int kPageID2 = 2;
   GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
-  FillAutofillFormData(kPageID2, form, form.fields[0],
-                       PackGUIDs(empty, guid2));
-
-  page_id = 0;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  response_page_id = 0;
+  FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
+      PackGUIDs(empty, guid2), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Billing address");
-    EXPECT_EQ(kPageID2, page_id);
-    EXPECT_EQ(ASCIIToUTF16("MyForm"), results.name);
-    EXPECT_EQ(ASCIIToUTF16("POST"), results.method);
-    EXPECT_EQ(GURL("https://myform.com/form.html"), results.origin);
-    EXPECT_EQ(GURL("https://myform.com/submit.html"), results.action);
-    EXPECT_TRUE(results.user_submitted);
-    ASSERT_EQ(11U, results.fields.size());
+    EXPECT_EQ(kPageID2, response_page_id);
+    EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
+    EXPECT_EQ(ASCIIToUTF16("POST"), response_data.method);
+    EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
+    EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
+    EXPECT_TRUE(response_data.user_submitted);
+    ASSERT_EQ(11U, response_data.fields.size());
 
     ExpectFilledField("", "country", "United States", "text",
-                      results.fields[0]);
-    ExpectFilledField("", "firstname", "", "text", results.fields[1]);
-    ExpectFilledField("", "lastname", "", "text", results.fields[2]);
+                      response_data.fields[0]);
+    ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
+    ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
     ExpectFilledField("", "address", "3734 Elvis Presley Blvd.", "text",
-                      results.fields[3]);
-    ExpectFilledField("", "city", "Memphis", "text", results.fields[4]);
-    ExpectFilledField("", "state", "Tennessee", "text", results.fields[5]);
-    ExpectFilledField("", "zip", "38116", "text", results.fields[6]);
-    ExpectFilledField("", "ccname", "", "text", results.fields[7]);
-    ExpectFilledField("", "ccnumber", "", "text", results.fields[8]);
-    ExpectFilledField("", "ccexp", "", "text", results.fields[9]);
-    ExpectFilledField("", "email", "", "text", results.fields[10]);
+                      response_data.fields[3]);
+    ExpectFilledField("", "city", "Memphis", "text", response_data.fields[4]);
+    ExpectFilledField("", "state", "Tennessee", "text",
+                      response_data.fields[5]);
+    ExpectFilledField("", "zip", "38116", "text", response_data.fields[6]);
+    ExpectFilledField("", "ccname", "", "text", response_data.fields[7]);
+    ExpectFilledField("", "ccnumber", "", "text", response_data.fields[8]);
+    ExpectFilledField("", "ccexp", "", "text", response_data.fields[9]);
+    ExpectFilledField("", "email", "", "text", response_data.fields[10]);
   }
 
   // Fill the credit card portion of the billing section.
   const int kPageID3 = 3;
   GUIDPair guid3("00000000-0000-0000-0000-000000000004", 0);
-  FillAutofillFormData(kPageID3, form, form.fields[form.fields.size() - 2],
-                       PackGUIDs(guid3, empty));
-
-  page_id = 0;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  response_page_id = 0;
+  FillAutofillFormDataAndSaveResults(
+      kPageID3, form, form.fields[form.fields.size() - 2],
+      PackGUIDs(guid3, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card");
-    EXPECT_EQ(kPageID3, page_id);
-    EXPECT_EQ(ASCIIToUTF16("MyForm"), results.name);
-    EXPECT_EQ(ASCIIToUTF16("POST"), results.method);
-    EXPECT_EQ(GURL("https://myform.com/form.html"), results.origin);
-    EXPECT_EQ(GURL("https://myform.com/submit.html"), results.action);
-    EXPECT_TRUE(results.user_submitted);
-    ASSERT_EQ(11U, results.fields.size());
+    EXPECT_EQ(kPageID3, response_page_id);
+    EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
+    EXPECT_EQ(ASCIIToUTF16("POST"), response_data.method);
+    EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
+    EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
+    EXPECT_TRUE(response_data.user_submitted);
+    ASSERT_EQ(11U, response_data.fields.size());
 
-    ExpectFilledField("", "country", "", "text", results.fields[0]);
-    ExpectFilledField("", "firstname", "", "text", results.fields[1]);
-    ExpectFilledField("", "lastname", "", "text", results.fields[2]);
-    ExpectFilledField("", "address", "", "text", results.fields[3]);
-    ExpectFilledField("", "city", "", "text", results.fields[4]);
-    ExpectFilledField("", "state", "", "text", results.fields[5]);
-    ExpectFilledField("", "zip", "", "text", results.fields[6]);
-    ExpectFilledField("", "ccname", "Elvis Presley", "text", results.fields[7]);
+    ExpectFilledField("", "country", "", "text", response_data.fields[0]);
+    ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
+    ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
+    ExpectFilledField("", "address", "", "text", response_data.fields[3]);
+    ExpectFilledField("", "city", "", "text", response_data.fields[4]);
+    ExpectFilledField("", "state", "", "text", response_data.fields[5]);
+    ExpectFilledField("", "zip", "", "text", response_data.fields[6]);
+    ExpectFilledField("", "ccname", "Elvis Presley", "text",
+                      response_data.fields[7]);
     ExpectFilledField("", "ccnumber", "4234567890123456", "text",
-                      results.fields[8]);
-    ExpectFilledField("", "ccexp", "04/2012", "text", results.fields[9]);
-    ExpectFilledField("", "email", "", "text", results.fields[10]);
+                      response_data.fields[8]);
+    ExpectFilledField("", "ccexp", "04/2012", "text", response_data.fields[9]);
+    ExpectFilledField("", "email", "", "text", response_data.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);
+  test::CreateTestAddressFormData(&form);
   FormFieldData field;
   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);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
 
   // The second email address should be filled.
-  EXPECT_EQ(ASCIIToUTF16("theking@gmail.com"), results.fields.back().value);
+  EXPECT_EQ(ASCIIToUTF16("theking@gmail.com"),
+            response_data.fields.back().value);
 
   // The remainder of the form should be filled as usual.
-  results.fields.pop_back();
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  response_data.fields.pop_back();
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 }
 
 // Test that we correctly fill a previously auto-filled form.
 TEST_F(AutofillManagerTest, FillAutofilledForm) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   // Mark one of the address fields as autofilled.
   form.fields[4].is_autofilled = true;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // First fill the address data.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, *form.fields.begin(),
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address");
-    ExpectFilledForm(page_id, results, kDefaultPageID,
+    ExpectFilledForm(response_page_id, response_data, kDefaultPageID,
                      "Elvis", "", "", "", "", "", "", "", "", "", "", "", "",
                      "", "", true, true, false);
   }
 
   // Now fill the credit card data.
   const int kPageID2 = 2;
   GUIDPair guid2("00000000-0000-0000-0000-000000000004", 0);
-  FillAutofillFormData(kPageID2, form, form.fields.back(),
-                       PackGUIDs(guid2, empty));
-
-  page_id = 0;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  response_page_id = 0;
+  FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
+      PackGUIDs(guid2, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card 1");
-    ExpectFilledCreditCardFormElvis(page_id, results, kPageID2, true);
+    ExpectFilledCreditCardFormElvis(
+        response_page_id, response_data, 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<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;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  response_page_id = 0;
+  FillAutofillFormDataAndSaveResults(kPageID3, form, *form.fields.rbegin(),
+      PackGUIDs(guid2, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card 2");
-    ExpectFilledForm(page_id, results, kPageID3,
+    ExpectFilledForm(response_page_id, response_data, kPageID3,
                      "", "", "", "", "", "", "", "", "", "", "", "", "", "",
                      "2012", true, true, false);
   }
 }
 
 // Test that we correctly fill an address form with a non-default variant for a
 // multi-valued field.
 TEST_F(AutofillManagerTest, FillAddressFormWithVariantType) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Add a name variant to the Elvis profile.
   AutofillProfile* profile = autofill_manager_->GetProfileWithGUID(
       "00000000-0000-0000-0000-000000000001");
   const base::string16 elvis_name = profile->GetRawInfo(NAME_FULL);
 
   std::vector<base::string16> name_variants;
   name_variants.push_back(ASCIIToUTF16("Some Other Guy"));
   name_variants.push_back(elvis_name);
   profile->SetRawMultiInfo(NAME_FULL, name_variants);
 
   GUIDPair guid(profile->guid(), 1);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results1;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results1));
+  int response_page_id = 0;
+  FormData response_data1;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data1);
   {
     SCOPED_TRACE("Valid variant");
-    ExpectFilledAddressFormElvis(page_id, results1, kDefaultPageID, false);
+    ExpectFilledAddressFormElvis(
+        response_page_id, response_data1, kDefaultPageID, false);
   }
 
   // Try filling with a variant that doesn't exist.  The fields to which this
   // variant would normally apply should not be filled.
   const int kPageID2 = 2;
   GUIDPair guid2(profile->guid(), 2);
-  FillAutofillFormData(kPageID2, form, form.fields[0],
-                       PackGUIDs(empty, guid2));
-
-  page_id = 0;
-  FormData results2;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results2));
+  response_page_id = 0;
+  FormData response_data2;
+  FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
+      PackGUIDs(empty, guid2), &response_page_id, &response_data2);
   {
     SCOPED_TRACE("Invalid variant");
-    ExpectFilledForm(page_id, results2, kPageID2, "", "", "",
+    ExpectFilledForm(response_page_id, response_data2, kPageID2, "", "", "",
                      "3734 Elvis Presley Blvd.", "Apt. 10", "Memphis",
                      "Tennessee", "38116", "United States", "12345678901",
                      "theking@gmail.com", "", "", "", "", true, false, false);
   }
 }
 
 // Test that we correctly fill a phone number split across multiple fields.
 TEST_F(AutofillManagerTest, FillPhoneNumber) {
   // In one form, rely on the maxlength attribute to imply phone number parts.
   // In the other form, rely on the autocompletetype attribute.
@@ skipping 40 matching lines @@
 
   // We should be able to fill prefix and suffix fields for US numbers.
   AutofillProfile* work_profile = autofill_manager_->GetProfileWithGUID(
       "00000000-0000-0000-0000-000000000002");
   ASSERT_TRUE(work_profile != NULL);
   work_profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
                            ASCIIToUTF16("16505554567"));
 
   GUIDPair guid(work_profile->guid(), 0);
   GUIDPair empty(std::string(), 0);
+  int page_id = 1;
+  int response_page_id = 0;
+  FormData response_data1;
+  FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
+      *form_with_maxlength.fields.begin(),
+      PackGUIDs(empty, guid), &response_page_id, &response_data1);
+  EXPECT_EQ(1, response_page_id);
 
-  int page_id = 1;
-  FillAutofillFormData(page_id, form_with_maxlength,
-                       *form_with_maxlength.fields.begin(),
-                       PackGUIDs(empty, guid));
-  page_id = 0;
-  FormData results1;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results1));
-  EXPECT_EQ(1, page_id);
-
-  ASSERT_EQ(5U, results1.fields.size());
-  EXPECT_EQ(ASCIIToUTF16("1"), results1.fields[0].value);
-  EXPECT_EQ(ASCIIToUTF16("650"), results1.fields[1].value);
-  EXPECT_EQ(ASCIIToUTF16("555"), results1.fields[2].value);
-  EXPECT_EQ(ASCIIToUTF16("4567"), results1.fields[3].value);
-  EXPECT_EQ(base::string16(), results1.fields[4].value);
+  ASSERT_EQ(5U, response_data1.fields.size());
+  EXPECT_EQ(ASCIIToUTF16("1"), response_data1.fields[0].value);
+  EXPECT_EQ(ASCIIToUTF16("650"), response_data1.fields[1].value);
+  EXPECT_EQ(ASCIIToUTF16("555"), response_data1.fields[2].value);
+  EXPECT_EQ(ASCIIToUTF16("4567"), response_data1.fields[3].value);
+  EXPECT_EQ(base::string16(), response_data1.fields[4].value);
 
   page_id = 2;
-  FillAutofillFormData(page_id, form_with_autocompletetype,
-                       *form_with_autocompletetype.fields.begin(),
-                       PackGUIDs(empty, guid));
-  page_id = 0;
-  FormData results2;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results2));
-  EXPECT_EQ(2, page_id);
+  response_page_id = 0;
+  FormData response_data2;
+  FillAutofillFormDataAndSaveResults(page_id, form_with_autocompletetype,
+      *form_with_autocompletetype.fields.begin(),
+      PackGUIDs(empty, guid), &response_page_id, &response_data2);
+  EXPECT_EQ(2, response_page_id);
 
-  ASSERT_EQ(5U, results2.fields.size());
-  EXPECT_EQ(ASCIIToUTF16("1"), results2.fields[0].value);
-  EXPECT_EQ(ASCIIToUTF16("650"), results2.fields[1].value);
-  EXPECT_EQ(ASCIIToUTF16("555"), results2.fields[2].value);
-  EXPECT_EQ(ASCIIToUTF16("4567"), results2.fields[3].value);
-  EXPECT_EQ(base::string16(), results2.fields[4].value);
+  ASSERT_EQ(5U, response_data2.fields.size());
+  EXPECT_EQ(ASCIIToUTF16("1"), response_data2.fields[0].value);
+  EXPECT_EQ(ASCIIToUTF16("650"), response_data2.fields[1].value);
+  EXPECT_EQ(ASCIIToUTF16("555"), response_data2.fields[2].value);
+  EXPECT_EQ(ASCIIToUTF16("4567"), response_data2.fields[3].value);
+  EXPECT_EQ(base::string16(), response_data2.fields[4].value);
 
   // We should not be able to fill prefix and suffix fields for international
   // numbers.
   work_profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("GB"));
   work_profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
                            ASCIIToUTF16("447700954321"));
   page_id = 3;
-  FillAutofillFormData(page_id, form_with_maxlength,
-                       *form_with_maxlength.fields.begin(),
-                       PackGUIDs(empty, guid));
-  page_id = 0;
-  FormData results3;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results3));
-  EXPECT_EQ(3, page_id);
+  response_page_id = 0;
+  FormData response_data3;
+  FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
+      *form_with_maxlength.fields.begin(),
+      PackGUIDs(empty, guid), &response_page_id, &response_data3);
+  EXPECT_EQ(3, response_page_id);
 
-  ASSERT_EQ(5U, results3.fields.size());
-  EXPECT_EQ(ASCIIToUTF16("44"), results3.fields[0].value);
-  EXPECT_EQ(ASCIIToUTF16("7700"), results3.fields[1].value);
-  EXPECT_EQ(ASCIIToUTF16("954321"), results3.fields[2].value);
-  EXPECT_EQ(ASCIIToUTF16("954321"), results3.fields[3].value);
-  EXPECT_EQ(base::string16(), results3.fields[4].value);
+  ASSERT_EQ(5U, response_data3.fields.size());
+  EXPECT_EQ(ASCIIToUTF16("44"), response_data3.fields[0].value);
+  EXPECT_EQ(ASCIIToUTF16("7700"), response_data3.fields[1].value);
+  EXPECT_EQ(ASCIIToUTF16("954321"), response_data3.fields[2].value);
+  EXPECT_EQ(ASCIIToUTF16("954321"), response_data3.fields[3].value);
+  EXPECT_EQ(base::string16(), response_data3.fields[4].value);
 
   page_id = 4;
-  FillAutofillFormData(page_id, form_with_autocompletetype,
-                       *form_with_autocompletetype.fields.begin(),
-                       PackGUIDs(empty, guid));
-  page_id = 0;
-  FormData results4;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results4));
-  EXPECT_EQ(4, page_id);
+  response_page_id = 0;
+  FormData response_data4;
+  FillAutofillFormDataAndSaveResults(page_id, form_with_autocompletetype,
+      *form_with_autocompletetype.fields.begin(),
+      PackGUIDs(empty, guid), &response_page_id, &response_data4);
+  EXPECT_EQ(4, response_page_id);
 
-  ASSERT_EQ(5U, results4.fields.size());
-  EXPECT_EQ(ASCIIToUTF16("44"), results4.fields[0].value);
-  EXPECT_EQ(ASCIIToUTF16("7700"), results4.fields[1].value);
-  EXPECT_EQ(ASCIIToUTF16("954321"), results4.fields[2].value);
-  EXPECT_EQ(ASCIIToUTF16("954321"), results4.fields[3].value);
-  EXPECT_EQ(base::string16(), results4.fields[4].value);
+  ASSERT_EQ(5U, response_data4.fields.size());
+  EXPECT_EQ(ASCIIToUTF16("44"), response_data4.fields[0].value);
+  EXPECT_EQ(ASCIIToUTF16("7700"), response_data4.fields[1].value);
+  EXPECT_EQ(ASCIIToUTF16("954321"), response_data4.fields[2].value);
+  EXPECT_EQ(ASCIIToUTF16("954321"), response_data4.fields[3].value);
+  EXPECT_EQ(base::string16(), response_data4.fields[4].value);
 
   // We should fill all phone fields with the same phone number variant.
   std::vector<base::string16> phone_variants;
   phone_variants.push_back(ASCIIToUTF16("16505554567"));
   phone_variants.push_back(ASCIIToUTF16("18887771234"));
   work_profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   work_profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, phone_variants);
 
   page_id = 5;
+  response_page_id = 0;
+  FormData response_data5;
   GUIDPair variant_guid(work_profile->guid(), 1);
-  FillAutofillFormData(page_id, form_with_maxlength,
-                       *form_with_maxlength.fields.begin(),
-                       PackGUIDs(empty, variant_guid));
-  page_id = 0;
-  FormData results5;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results5));
-  EXPECT_EQ(5, page_id);
+  FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
+      *form_with_maxlength.fields.begin(),
+      PackGUIDs(empty, variant_guid), &response_page_id, &response_data5);
+  EXPECT_EQ(5, response_page_id);
 
-  ASSERT_EQ(5U, results5.fields.size());
-  EXPECT_EQ(ASCIIToUTF16("1"), results5.fields[0].value);
-  EXPECT_EQ(ASCIIToUTF16("888"), results5.fields[1].value);
-  EXPECT_EQ(ASCIIToUTF16("777"), results5.fields[2].value);
-  EXPECT_EQ(ASCIIToUTF16("1234"), results5.fields[3].value);
-  EXPECT_EQ(base::string16(), results5.fields[4].value);
+  ASSERT_EQ(5U, response_data5.fields.size());
+  EXPECT_EQ(ASCIIToUTF16("1"), response_data5.fields[0].value);
+  EXPECT_EQ(ASCIIToUTF16("888"), response_data5.fields[1].value);
+  EXPECT_EQ(ASCIIToUTF16("777"), response_data5.fields[2].value);
+  EXPECT_EQ(ASCIIToUTF16("1234"), response_data5.fields[3].value);
+  EXPECT_EQ(base::string16(), response_data5.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);
+  test::CreateTestAddressFormData(&form);
 
   // Add a field -- we'll remove it again later.
   FormFieldData field;
   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);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 }
 
 // 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);
+  test::CreateTestAddressFormData(&form);
 
   // Remove the phone field -- we'll add it back later.
   std::vector<FormFieldData>::iterator pos =
       form.fields.begin() + kPhoneFieldOffset;
   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);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 }
 
 // Test that we are able to save form data when forms are submitted.
 TEST_F(AutofillManagerTest, FormSubmitted) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Fill the form.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 
   // Simulate form submission. We should call into the PDM to try to save the
   // filled data.
   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
-  FormSubmitted(results);
+  FormSubmitted(response_data);
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled,
 // form submissions are still received by AutocompleteHistoryManager.
 TEST_F(AutofillManagerTest, FormSubmittedAutocompleteEnabled) {
   TestAutofillManagerDelegate delegate;
   autofill_manager_.reset(new TestAutofillManager(
       autofill_driver_.get(),
       &delegate,
       NULL));
   autofill_manager_->set_autofill_enabled(false);
   scoped_ptr<MockAutocompleteHistoryManager> autocomplete_history_manager;
   autocomplete_history_manager.reset(
       new MockAutocompleteHistoryManager(autofill_driver_.get(), &delegate));
   autofill_manager_->autocomplete_history_manager_ =
       autocomplete_history_manager.Pass();
 
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   MockAutocompleteHistoryManager* m = static_cast<
       MockAutocompleteHistoryManager*>(
           autofill_manager_->autocomplete_history_manager_.get());
   EXPECT_CALL(*m,
               OnFormSubmitted(_)).Times(1);
   FormSubmitted(form);
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled,
 // Autocomplete suggestions are still received.
 TEST_F(AutofillManagerTest, AutocompleteSuggestionsWhenAutofillDisabled) {
   TestAutofillManagerDelegate delegate;
   autofill_manager_.reset(new TestAutofillManager(
       autofill_driver_.get(),
       &delegate,
       NULL));
   autofill_manager_->set_autofill_enabled(false);
 
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions. We should return the autocomplete
   // suggestions, these will be culled by the renderer.
   std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
@@ skipping 18 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we are able to save form data when forms are submitted and we only
 // have server data for the field types.
 TEST_F(AutofillManagerTest, FormSubmittedServerTypes) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
   AutofillMetrics metrics_logger;  // ignored
   form_structure->DetermineHeuristicTypes(metrics_logger);
 
   // Clear the heuristic types, and instead set the appropriate server types.
   std::vector<AutofillFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
     server_types.push_back(form_structure->field(i)->type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure);
 
   // Fill the form.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[0],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
-  ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
+  ExpectFilledAddressFormElvis(
+      response_page_id, response_data, kDefaultPageID, false);
 
   // Simulate form submission. We should call into the PDM to try to save the
   // filled data.
   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
-  FormSubmitted(results);
+  FormSubmitted(response_data);
 }
 
 // Test that the form signature for an uploaded form always matches the form
 // signature from the query.
 TEST_F(AutofillManagerTest, FormSubmittedWithDifferentFields) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Cache the expected form signature.
   std::string signature = FormStructure(form, std::string()).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();
   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.
 TEST_F(AutofillManagerTest, FormSubmittedWithDefaultValues) {
   // Set up our form data.
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   form.fields[3].value = ASCIIToUTF16("Enter your address");
 
   // Convert the state field to a <select> popup, to make sure that we only
   // reject default values for text fields.
   ASSERT_TRUE(form.fields[6].name == ASCIIToUTF16("state"));
   form.fields[6].form_control_type = "select-one";
   form.fields[6].value = ASCIIToUTF16("Tennessee");
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Fill the form.
   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   GUIDPair empty(std::string(), 0);
-  FillAutofillFormData(kDefaultPageID, form, form.fields[3],
-                       PackGUIDs(empty, guid));
-
-  int page_id = 0;
-  FormData results;
-  EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
+  int response_page_id = 0;
+  FormData response_data;
+  FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[3],
+      PackGUIDs(empty, guid), &response_page_id, &response_data);
 
   // Simulate form submission.  We should call into the PDM to try to save the
   // filled data.
   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
-  FormSubmitted(results);
+  FormSubmitted(response_data);
 
   // Set the address field's value back to the default value.
-  results.fields[3].value = ASCIIToUTF16("Enter your address");
+  response_data.fields[3].value = ASCIIToUTF16("Enter your address");
 
   // Simulate form submission.  We should not call into the PDM to try to save
   // the filled data, since the filled form is effectively missing an address.
   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(0);
-  FormSubmitted(results);
+  FormSubmitted(response_data);
 }
 
 // Checks that resetting the auxiliary profile enabled preference does the right
 // thing on all platforms.
 TEST_F(AutofillManagerTest, AuxiliaryProfilesReset) {
   PrefService* prefs = user_prefs::UserPrefs::Get(profile());
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   // Auxiliary profiles is implemented on Mac and Android only.
   // OSX: enables Mac Address Book integration.
   // Android: enables integration with user's contact profile.
@@ skipping 418 matching lines @@
 
 // Test that Autocheckout bubble is offered when server specifies field types.
 TEST_F(AutofillManagerTest, TestBubbleShown) {
   MockAutofillManagerDelegate delegate;
   autofill_manager_.reset(new TestAutofillManager(
       autofill_driver_.get(), &delegate, &personal_data_));
   autofill_manager_->set_autofill_enabled(true);
   autofill_manager_->MarkAsFirstPageInAutocheckoutFlow();
 
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
 
   TestFormStructure* form_structure = new TestFormStructure(form);
   AutofillMetrics metrics_logger;  // ignored
   form_structure->DetermineHeuristicTypes(metrics_logger);
 
   // Build and add form structure with server data.
   std::vector<AutofillFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
     server_types.push_back(form_structure->field(i)->type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure);
 
   autofill_manager_->OnMaybeShowAutocheckoutBubble(form, gfx::RectF());
 
   EXPECT_TRUE(delegate.autocheckout_bubble_shown());
 }
 
 // Test that Autocheckout bubble is not offered when server doesn't have data
 // for the form.
 TEST_F(AutofillManagerTest, TestAutocheckoutBubbleNotShown) {
   MockAutofillManagerDelegate delegate;
   autofill_manager_.reset(new TestAutofillManager(
       autofill_driver_.get(), &delegate, &personal_data_));
   autofill_manager_->set_autofill_enabled(true);
   autofill_manager_->MarkAsFirstPageInAutocheckoutFlow();
 
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
 
   TestFormStructure* form_structure = new TestFormStructure(form);
   AutofillMetrics metrics_logger;  // ignored
   form_structure->DetermineHeuristicTypes(metrics_logger);
 
   // Build form structure without server data.
   std::vector<AutofillFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(form_structure->field(i)->type());
     server_types.push_back(NO_SERVER_DATA);
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(form_structure);
 
   autofill_manager_->OnMaybeShowAutocheckoutBubble(form, gfx::RectF());
 
   EXPECT_FALSE(delegate.autocheckout_bubble_shown());
 }
 
 // Test our external delegate is called at the right time.
 TEST_F(AutofillManagerTest, TestExternalDelegate) {
   MockAutofillExternalDelegate external_delegate(web_contents(),
                                                  autofill_manager_.get());
   EXPECT_CALL(external_delegate, OnQuery(_, _, _, _, _));
   autofill_manager_->SetExternalDelegate(&external_delegate);
 
   FormData form;
-  CreateTestAddressFormData(&form);
+  test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   autofill_manager_->SetExternalDelegate(NULL);
 }
 
 // Test that in the case of Autocheckout, forms seen are in order supplied.
 TEST_F(AutofillManagerTest, DynamicFormsSeenAndIgnored) {
   MockAutofillManagerDelegate delegate;
   autofill_manager_.reset(new TestAutofillManager(
       autofill_driver_.get(), &delegate, &personal_data_));
   FormData shipping_options;
   CreateTestShippingOptionsFormData(&shipping_options);
   FormData user_supplied;
   CreateTestFormWithAutocompleteAttribute(&user_supplied);
   FormData address;
-  CreateTestAddressFormData(&address);
+  test::CreateTestAddressFormData(&address);
 
   autofill_manager_->set_autocheckout_url_prefix("test-prefix");
   // Push address only
   std::vector<FormData> forms;
   forms.push_back(address);
 
   // Build and add form structure with server data.
   scoped_ptr<TestFormStructure> form_structure(new TestFormStructure(address));
   std::vector<AutofillFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < address.fields.size(); ++i) {
@@ skipping 19 matching lines @@
   forms.push_back(user_supplied);
 
   // FormStructure should contain the same forms as before.
   DynamicFormsSeen(forms);
   form_structures = autofill_manager_->GetFormStructures();
   ASSERT_EQ(1U, form_structures.size());
   EXPECT_EQ("/form.html", form_structures[0]->source_url().path());
 }
 
 }  // namespace autofill