Create an autofill Suggestion class

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/format_macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 30 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using testing::_;
 
 namespace autofill {
 
-typedef PersonalDataManager::GUIDPair GUIDPair;
-
 namespace {
 
 const int kDefaultPageID = 137;
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager() : PersonalDataManager("en-US") {
     CreateTestAutofillProfiles(&web_profiles_);
     CreateTestCreditCards(&credit_cards_);
   }
@@ skipping 289 matching lines @@
                    "", "", "", "", "", "", "", "", "", "", "",
                    "Miku Hatsune", "4234567890654321", month, year,
                    has_address_fields, true, true);
 }
 
 class MockAutocompleteHistoryManager : public AutocompleteHistoryManager {
  public:
   MockAutocompleteHistoryManager(AutofillDriver* driver, AutofillClient* client)
       : AutocompleteHistoryManager(driver, client) {}
 
-  MOCK_METHOD8(OnGetAutocompleteSuggestions, void(
+  MOCK_METHOD5(OnGetAutocompleteSuggestions, void(
       int query_id,
       const base::string16& name,
       const base::string16& prefix,
       const std::string& form_control_type,
-      const std::vector<base::string16>& autofill_values,
-      const std::vector<base::string16>& autofill_labels,
-      const std::vector<base::string16>& autofill_icons,
-      const std::vector<int>& autofill_unique_ids));
+      const std::vector<Suggestion>& suggestions));
   MOCK_METHOD1(OnFormSubmitted, void(const FormData& form));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteHistoryManager);
 };
 
 class MockAutofillDriver : public TestAutofillDriver {
  public:
   MockAutofillDriver() {}
 
@@ skipping 90 matching lines @@
   }
 
   void AddCreditCard(CreditCard* credit_card) {
     personal_data_->AddCreditCard(credit_card);
   }
 
   int GetPackedCreditCardID(int credit_card_id) {
     std::string credit_card_guid =
         base::StringPrintf("00000000-0000-0000-0000-%012d", credit_card_id);
 
-    return PackGUIDs(GUIDPair(credit_card_guid, 0), GUIDPair(std::string(), 0));
+    return MakeFrontendID(SuggestionBackendID(credit_card_guid, 0),
+                      SuggestionBackendID());
   }
 
   void AddSeenForm(FormStructure* form) {
     form_structures()->push_back(form);
   }
 
   void ClearFormStructures() {
     form_structures()->clear();
   }
 
@@ skipping 24 matching lines @@
                const FormData& form,
                const FormFieldData& field,
                const gfx::RectF& bounds,
                bool display_warning) override {
     on_query_seen_ = true;
     on_suggestions_returned_seen_ = false;
   }
 
   void OnSuggestionsReturned(
       int query_id,
-      const std::vector<base::string16>& autofill_values,
-      const std::vector<base::string16>& autofill_labels,
-      const std::vector<base::string16>& autofill_icons,
-      const std::vector<int>& autofill_unique_ids) override {
+      const std::vector<Suggestion>& suggestions) override {
     on_suggestions_returned_seen_ = true;
-
     query_id_ = query_id;
-    autofill_values_ = autofill_values;
-    autofill_labels_ = autofill_labels;
-    autofill_icons_ = autofill_icons;
-    autofill_unique_ids_ = autofill_unique_ids;
+    suggestions_ = suggestions;
   }
 
   void CheckSuggestions(int expected_page_id,
                         size_t expected_num_suggestions,
-                        const base::string16 expected_values[],
-                        const base::string16 expected_labels[],
-                        const base::string16 expected_icons[],
-                        const int expected_unique_ids[]) {
+                        const Suggestion expected_suggestions[]) {
     // Ensure that these results are from the most recent query.
     EXPECT_TRUE(on_suggestions_returned_seen_);
 
     EXPECT_EQ(expected_page_id, query_id_);
-    ASSERT_EQ(expected_num_suggestions, autofill_values_.size());
-    ASSERT_EQ(expected_num_suggestions, autofill_labels_.size());
-    ASSERT_EQ(expected_num_suggestions, autofill_icons_.size());
-    ASSERT_EQ(expected_num_suggestions, autofill_unique_ids_.size());
+    ASSERT_EQ(expected_num_suggestions, suggestions_.size());
     for (size_t i = 0; i < expected_num_suggestions; ++i) {
       SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
-      EXPECT_EQ(expected_values[i], autofill_values_[i]);
-      EXPECT_EQ(expected_labels[i], autofill_labels_[i]);
-      EXPECT_EQ(expected_icons[i], autofill_icons_[i]);
-      EXPECT_EQ(expected_unique_ids[i], autofill_unique_ids_[i]);
+      EXPECT_EQ(expected_suggestions[i].value, suggestions_[i].value);
+      EXPECT_EQ(expected_suggestions[i].label, suggestions_[i].label);
+      EXPECT_EQ(expected_suggestions[i].icon, suggestions_[i].icon);
+      EXPECT_EQ(expected_suggestions[i].frontend_id,
+                suggestions_[i].frontend_id);
     }
   }
 
+  // Wrappers around the above GetSuggestions call that take a hardcoded number
+  // of expected results so callsites are cleaner.
+  void CheckSuggestions(int expected_page_id,
+                        const Suggestion& suggestion0) {
+    std::vector<Suggestion> suggestion_vector;
+    suggestion_vector.push_back(suggestion0);
+    CheckSuggestions(expected_page_id, 1, &suggestion_vector[0]);
+  }
+  void CheckSuggestions(int expected_page_id,
+                        const Suggestion& suggestion0,
+                        const Suggestion& suggestion1) {
+    std::vector<Suggestion> suggestion_vector;
+    suggestion_vector.push_back(suggestion0);
+    suggestion_vector.push_back(suggestion1);
+    CheckSuggestions(expected_page_id, 2, &suggestion_vector[0]);
+  }
+  void CheckSuggestions(int expected_page_id,
+                        const Suggestion& suggestion0,
+                        const Suggestion& suggestion1,
+                        const Suggestion& suggestion2) {
+    std::vector<Suggestion> suggestion_vector;
+    suggestion_vector.push_back(suggestion0);
+    suggestion_vector.push_back(suggestion1);
+    suggestion_vector.push_back(suggestion2);
+    CheckSuggestions(expected_page_id, 3, &suggestion_vector[0]);
+  }
+
+
   bool on_query_seen() const {
     return on_query_seen_;
   }
 
   bool on_suggestions_returned_seen() const {
     return on_suggestions_returned_seen_;
   }
 
  private:
   // Records if OnQuery has been called yet.
   bool on_query_seen_;
 
   // Records if OnSuggestionsReturned has been called after the most recent
   // call to OnQuery.
   bool on_suggestions_returned_seen_;
 
   // The query id of the most recent Autofill query.
   int query_id_;
 
   // The results returned by the most recent Autofill query.
-  std::vector<base::string16> autofill_values_;
-  std::vector<base::string16> autofill_labels_;
-  std::vector<base::string16> autofill_icons_;
-  std::vector<int> autofill_unique_ids_;
+  std::vector<Suggestion> suggestions_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
 };
 
 }  // namespace
 
 class AutofillManagerTest : public testing::Test {
  public:
   void SetUp() override {
     autofill_client_.SetPrefs(test::PrefServiceForTesting());
@@ skipping 70 matching lines @@
                                           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<2>(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);
+  int MakeFrontendID(const SuggestionBackendID& cc_sid,
+                 const SuggestionBackendID& profile_sid) const {
+    return autofill_manager_->MakeFrontendID(cc_sid, profile_sid);
   }
 
  protected:
   base::MessageLoop message_loop_;
   TestAutofillClient autofill_client_;
   scoped_ptr<MockAutofillDriver> autofill_driver_;
   scoped_ptr<TestAutofillManager> autofill_manager_;
   scoped_ptr<TestAutofillExternalDelegate> external_delegate_;
   TestPersonalDataManager personal_data_;
 };
@@ skipping 32 matching lines @@
   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>());
 
-  // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis"),
-    ASCIIToUTF16("Charles")
-  };
-  // Inferred labels include full first relevant field, which in this case is
-  // the address line 1.
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("3734 Elvis Presley Blvd."),
-    ASCIIToUTF16("123 Apple St.")
-  };
-  base::string16 expected_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2};
+  // Test that we sent the right values to the external delegate. Inferred
+  // labels include full first relevant field, which in this case is the
+  // address line 1.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1),
+      Suggestion("Charles", "123 Apple St.", "", 2));
 }
 
 // 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;
   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>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {ASCIIToUTF16("Elvis")};
-  base::string16 expected_labels[] = {ASCIIToUTF16("3734 Elvis Presley Blvd.")};
-  base::string16 expected_icons[] = {base::string16()};
-  int expected_unique_ids[] = {1};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1));
 }
 
 // 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.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
   form.user_submitted = true;
@@ skipping 31 matching lines @@
   autofill_manager_->AddProfile(duplicate_profile);
 
   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>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis"),
-    ASCIIToUTF16("Charles")
-  };
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("3734 Elvis Presley Blvd."),
-    ASCIIToUTF16("123 Apple St.")
-  };
-  base::string16 expected_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1),
+      Suggestion("Charles", "123 Apple St.", "", 2));
 }
 
 // Test that we return no suggestions when autofill is disabled.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsAutofillDisabledByUser) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
@@ skipping 15 matching lines @@
   FormsSeen(forms);
 
   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<base::string16>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("************3456"),
-    ASCIIToUTF16("************8765")
-  };
-  base::string16 expected_labels[] = { ASCIIToUTF16("04/12"),
-                                       ASCIIToUTF16("10/14")};
-  base::string16 expected_icons[] = {
-    ASCIIToUTF16(kVisaCard),
-    ASCIIToUTF16(kMasterCard)
-  };
-  int expected_unique_ids[] = {
-    autofill_manager_->GetPackedCreditCardID(4),
-    autofill_manager_->GetPackedCreditCardID(5)
-  };
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("************3456", "04/12", kVisaCard,
+                 autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion("************8765", "10/14", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // 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);
 
   FormFieldData field;
   test::CreateTestFormField("Card Number", "cardnumber", "78", "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>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {ASCIIToUTF16("************3456")};
-  base::string16 expected_labels[] = {ASCIIToUTF16("04/12")};
-  base::string16 expected_icons[] = {ASCIIToUTF16(kVisaCard)};
-  int expected_unique_ids[] = {autofill_manager_->GetPackedCreditCardID(4)};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("************3456", "04/12", kVisaCard,
+                 autofill_manager_->GetPackedCreditCardID(4)));
 }
 
 // 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 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>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis Presley"),
-    ASCIIToUTF16("Buddy Holly")
-  };
-  base::string16 expected_labels[] = { ASCIIToUTF16("*3456"),
-                                       ASCIIToUTF16("*8765") };
-  base::string16 expected_icons[] = {
-    ASCIIToUTF16(kVisaCard),
-    ASCIIToUTF16(kMasterCard)
-  };
-  int expected_unique_ids[] = {
-    autofill_manager_->GetPackedCreditCardID(4),
-    autofill_manager_->GetPackedCreditCardID(5)
-  };
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis Presley", "*3456", kVisaCard,
+                 autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion("Buddy Holly", "*8765", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // 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 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>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
-  };
-  base::string16 expected_labels[] = {base::string16()};
-  base::string16 expected_icons[] = {base::string16()};
-  int expected_unique_ids[] = {-1};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion(
+          l10n_util::GetStringUTF8(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
+          "", "", -1));
 
   // Now add some Autocomplete suggestions. We should show the autocomplete
   // suggestions and the warning.
   const int kPageID2 = 2;
   GetAutofillSuggestions(kPageID2, form, field);
 
   std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
 
-  base::string16 expected_values2[] = {
-    l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
-    ASCIIToUTF16("Jay"),
-    ASCIIToUTF16("Jason")
-  };
-  base::string16 expected_labels2[] = { base::string16(), base::string16(),
-                                        base::string16() };
-  base::string16 expected_icons2[] = { base::string16(), base::string16(),
-                                       base::string16() };
-  int expected_unique_ids2[] = {-1, 0, 0};
   external_delegate_->CheckSuggestions(
-      kPageID2, arraysize(expected_values2), expected_values2,
-      expected_labels2, expected_icons2, expected_unique_ids2);
+      kPageID2,
+      Suggestion(
+          l10n_util::GetStringUTF8(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
+          "", "", -1),
+      Suggestion("Jay", "", "", 0),
+      Suggestion("Jason", "", "", 0));
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
 }
 
 // Test that we return all credit card suggestions in the case that two cards
 // have the same obfuscated number.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsRepeatedObfuscatedNumber) {
@@ skipping 13 matching lines @@
   FormsSeen(forms);
 
   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<base::string16>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("************3456"),
-    ASCIIToUTF16("************8765"),
-    ASCIIToUTF16("************3456")
-  };
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("04/12"),
-    ASCIIToUTF16("10/14"),
-    ASCIIToUTF16("05/12"),
-  };
-  base::string16 expected_icons[] = {
-    ASCIIToUTF16(kVisaCard),
-    ASCIIToUTF16(kMasterCard),
-    ASCIIToUTF16(kMasterCard)
-  };
-  int expected_unique_ids[] = {
-    autofill_manager_->GetPackedCreditCardID(4),
-    autofill_manager_->GetPackedCreditCardID(5),
-    autofill_manager_->GetPackedCreditCardID(7)
-  };
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("************3456", "04/12", kVisaCard,
+                 autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion("************8765", "10/14", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)),
+      Suggestion("************3456", "05/12", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(7)));
 }
 
 // Test that we return profile and credit card suggestions for combined forms.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestions) {
   // Set up our form data.
   FormData 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>());
 
   // Test that we sent the right address suggestions to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis"),
-    ASCIIToUTF16("Charles")
-  };
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("3734 Elvis Presley Blvd."),
-    ASCIIToUTF16("123 Apple St.")
-  };
-  base::string16 expected_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1),
+      Suggestion("Charles", "123 Apple St.", "", 2));
 
   const int kPageID2 = 2;
   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
   GetAutofillSuggestions(kPageID2, form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the credit card suggestions to the external delegate.
-  base::string16 expected_values2[] = {
-    ASCIIToUTF16("************3456"),
-    ASCIIToUTF16("************8765")
-  };
-  base::string16 expected_labels2[] = { ASCIIToUTF16("04/12"),
-                                        ASCIIToUTF16("10/14")};
-  base::string16 expected_icons2[] = {
-    ASCIIToUTF16(kVisaCard),
-    ASCIIToUTF16(kMasterCard)
-  };
-  int expected_unique_ids2[] = {
-    autofill_manager_->GetPackedCreditCardID(4),
-    autofill_manager_->GetPackedCreditCardID(5)
-  };
   external_delegate_->CheckSuggestions(
-      kPageID2, arraysize(expected_values2), expected_values2,
-      expected_labels2, expected_icons2, expected_unique_ids2);
+      kPageID2,
+      Suggestion("************3456", "04/12", kVisaCard,
+                 autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion("************8765", "10/14", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // 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;
   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>());
 
   // Test that we sent the right suggestions to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis"),
-    ASCIIToUTF16("Charles")
-  };
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("3734 Elvis Presley Blvd."),
-    ASCIIToUTF16("123 Apple St.")
-  };
-  base::string16 expected_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1),
+      Suggestion("Charles", "123 Apple St.", "", 2));
 
   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
   const int kPageID2 = 2;
   GetAutofillSuggestions(kPageID2, form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values2[] = {
-    l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
-  };
-  base::string16 expected_labels2[] = {base::string16()};
-  base::string16 expected_icons2[] = {base::string16()};
-  int expected_unique_ids2[] = {-1};
   external_delegate_->CheckSuggestions(
-      kPageID2, arraysize(expected_values2), expected_values2,
-      expected_labels2, expected_icons2, expected_unique_ids2);
+      kPageID2,
+      Suggestion(
+          l10n_util::GetStringUTF8(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
+          "", "", -1));
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
 }
 
 // Test that we correctly combine autofill and autocomplete suggestions.
 TEST_F(AutofillManagerTest, GetCombinedAutofillAndAutocompleteSuggestions) {
   // Set up our form data.
   FormData 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"));
   // This suggestion is a duplicate, and should be trimmed.
   suggestions.push_back(ASCIIToUTF16("Elvis"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis"),
-    ASCIIToUTF16("Charles"),
-    ASCIIToUTF16("Jay"),
-    ASCIIToUTF16("Jason")
+  Suggestion expected[] = {
+    Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1),
+    Suggestion("Charles", "123 Apple St.", "", 2),
+    Suggestion("Jay", "", "", 0),
+    Suggestion("Jason", "", "", 0),
   };
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("3734 Elvis Presley Blvd."),
-    ASCIIToUTF16("123 Apple St."),
-    base::string16(),
-    base::string16()
-  };
-  base::string16 expected_icons[] = { base::string16(), base::string16(),
-                                      base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2, 0, 0};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID, arraysize(expected), expected);
 }
 
 // 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;
   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.
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Elvis"),
-    ASCIIToUTF16("Charles")
-  };
-  base::string16 expected_labels[] = {base::string16(), base::string16()};
-  base::string16 expected_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "", "", 1),
+      Suggestion("Charles", "", "", 2));
 }
 
 // Test that nothing breaks when there are autocomplete suggestions but no
 // autofill suggestions.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForAutocompleteOnly) {
   // Set up our form data.
   FormData 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.
   std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("one"));
   suggestions.push_back(ASCIIToUTF16("two"));
   AutocompleteSuggestionsReturned(suggestions);
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("one"),
-    ASCIIToUTF16("two")
-  };
-  base::string16 expected_labels[] = {base::string16(), base::string16()};
-  base::string16 expected_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {0, 0};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("one", "", "", 0),
+      Suggestion("two", "", "", 0));
 }
 
 // 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;
   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);
 
   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<base::string16>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = { ASCIIToUTF16("Elvis") };
-  base::string16 expected_labels[] = { base::string16() };
-  base::string16 expected_icons[] = { base::string16() };
-  int expected_unique_ids[] = { 1 };
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Elvis", "", "", 1));
 }
 
 // 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;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
@@ skipping 18 matching lines @@
     // Start out with "E", hoping for either "Elvis" or "Elena.
     FormFieldData& field = form.fields[0];
     field.value = ASCIIToUTF16("E");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
     // Trigger the |Send|.
     AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
     // Test that we sent the right values to the external delegate.
-    base::string16 expected_values[] = {
-      ASCIIToUTF16("Elvis"),
-      ASCIIToUTF16("Elena")
-    };
-    base::string16 expected_labels[] = {
-      ASCIIToUTF16("me@x.com"),
-      ASCIIToUTF16("me@x.com")
-    };
-    base::string16 expected_icons[] = { base::string16(), base::string16() };
-    int expected_unique_ids[] = { 1, 2 };
     external_delegate_->CheckSuggestions(
-        kDefaultPageID, arraysize(expected_values), expected_values,
-        expected_labels, expected_icons, expected_unique_ids);
+        kDefaultPageID,
+        Suggestion("Elvis", "me@x.com", "", 1),
+        Suggestion("Elena", "me@x.com", "", 2));
   }
 
   {
     // Get the first name field.
     // This time, start out with "Ele", hoping for "Elena".
     FormFieldData& field = form.fields[0];
     field.value = ASCIIToUTF16("Ele");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
     // Trigger the |Send|.
     AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
     // Test that we sent the right values to the external delegate.
-    base::string16 expected_values[] = { ASCIIToUTF16("Elena") };
-    base::string16 expected_labels[] = { ASCIIToUTF16("me@x.com") };
-    base::string16 expected_icons[] = { base::string16() };
-    int expected_unique_ids[] = { 2 };
     external_delegate_->CheckSuggestions(
-        kDefaultPageID, arraysize(expected_values), expected_values,
-        expected_labels, expected_icons, expected_unique_ids);
+        kDefaultPageID,
+        Suggestion("Elena", "me@x.com", "", 2));
   }
 }
 
 // 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;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
@@ skipping 17 matching lines @@
   // multi-valued variants as suggestions.
   FormFieldData& field = form.fields[0];
   field.value = ASCIIToUTF16("Travis");
   field.is_autofilled = true;
   GetAutofillSuggestions(form, field);
 
   // Trigger the |Send|.
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Travis"),
-    ASCIIToUTF16("Cynthia"),
-    ASCIIToUTF16("Zac")
-  };
-  base::string16 expected_labels[] = { base::string16(), base::string16(),
-                                       base::string16() };
-  base::string16 expected_icons[] = { base::string16(), base::string16(),
-                                      base::string16() };
-  int expected_unique_ids[] = { 1, 2, 3 };
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Travis", "", "", 1),
+      Suggestion("Cynthia", "", "", 2),
+      Suggestion("Zac", "", "", 3));
 }
 
 TEST_F(AutofillManagerTest, GetProfileSuggestionsFancyPhone) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid("00000000-0000-0000-0000-000000000103");
   profile->SetInfo(AutofillType(NAME_FULL), ASCIIToUTF16("Natty Bumppo"),
                    "en-US");
   profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
                       ASCIIToUTF16("1800PRAIRIE"));
   autofill_manager_->AddProfile(profile);
 
   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<base::string16>());
 
-  // Test that we sent the right values to the external delegate.
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("12345678901"),
-    ASCIIToUTF16("23456789012"),
-    ASCIIToUTF16("18007724743"),  // 1800PRAIRIE
-  };
-  // Inferred labels include full first relevant field, which in this case is
-  // the address line 1.
-  base::string16 expected_labels[] = {
-    ASCIIToUTF16("Elvis Aaron Presley"),
-    ASCIIToUTF16("Charles Hardin Holley"),
-    ASCIIToUTF16("Natty Bumppo"),
-  };
-  base::string16 expected_icons[] = { base::string16(), base::string16(),
-                                      base::string16()};
-  int expected_unique_ids[] = {1, 2, 3};
+  // Test that we sent the right values to the external delegate. Inferred
+  // labels include full first relevant field, which in this case is the
+  // address line 1.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("12345678901", "Elvis Aaron Presley", "", 1),
+      Suggestion("23456789012", "Charles Hardin Holley", "", 2),
+      Suggestion("18007724743", "Natty Bumppo", "", 3));  // 1800PRAIRIE
+
 }
 
 TEST_F(AutofillManagerTest, GetProfileSuggestionsForPhonePrefixOrSuffix) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
   form.user_submitted = true;
 
@@ skipping 27 matching lines @@
   multi_values[1] = ASCIIToUTF16("14158889999");
 
   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, multi_values);
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->AddProfile(profile);
 
   const FormFieldData& phone_prefix = form.fields[2];
   GetAutofillSuggestions(form, phone_prefix);
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   // Test that we sent the right prefix values to the external delegate.
-  base::string16 expected_prefix_values[] = {ASCIIToUTF16("356"),
-                                             ASCIIToUTF16("888")};
-  base::string16 expected_prefix_labels[] = {ASCIIToUTF16("1"),
-                                             ASCIIToUTF16("1")};
-  base::string16 expected_prefix_icons[] = {base::string16(), base::string16()};
-  int expected_unique_ids[] = {1, 2};
-  external_delegate_->CheckSuggestions(kDefaultPageID,
-                                       arraysize(expected_prefix_values),
-                                       expected_prefix_values,
-                                       expected_prefix_labels,
-                                       expected_prefix_icons,
-                                       expected_unique_ids);
+  external_delegate_->CheckSuggestions(
+      kDefaultPageID,
+      Suggestion("356", "1", "", 1),
+      Suggestion("888", "1", "", 2));
 
   const FormFieldData& phone_suffix = form.fields[3];
   GetAutofillSuggestions(form, phone_suffix);
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   // Test that we sent the right suffix values to the external delegate.
-  base::string16 expected_suffix_values[] = {ASCIIToUTF16("9377"),
-                                             ASCIIToUTF16("9999")};
-  base::string16 expected_suffix_labels[] = {ASCIIToUTF16("1"),
-                                             ASCIIToUTF16("1")};
-  base::string16 expected_suffix_icons[] = {base::string16(), base::string16()};
-  external_delegate_->CheckSuggestions(kDefaultPageID,
-                                       arraysize(expected_suffix_values),
-                                       expected_suffix_values,
-                                       expected_suffix_labels,
-                                       expected_suffix_icons,
-                                       expected_unique_ids);
+  external_delegate_->CheckSuggestions(
+      kDefaultPageID,
+      Suggestion("9377", "1", "", 1),
+      Suggestion("9999", "1", "", 2));
 }
 
 // Test that we correctly fill an address form.
 TEST_F(AutofillManagerTest, FillAddressForm) {
   // Set up our form data.
   FormData 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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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();
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   autofill_client_.GetPrefs()->SetBoolean(
       ::autofill::prefs::kAutofillUseMacAddressBook, true);
 #else
   autofill_client_.GetPrefs()->SetBoolean(
       ::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, true);
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
   personal_data_.CreateTestAuxiliaryProfiles();
 
   // Set up our form data.
   FormData 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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000004", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
-      PackGUIDs(guid, empty), &response_page_id, &response_data);
+      MakeFrontendID(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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000007", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
-      PackGUIDs(guid, empty), &response_page_id, &response_data);
+      MakeFrontendID(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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000007", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
-      PackGUIDs(guid, empty), &response_page_id, &response_data);
+      MakeFrontendID(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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000007", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
-      PackGUIDs(guid, empty), &response_page_id, &response_data);
+      MakeFrontendID(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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000007", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
-      PackGUIDs(guid, empty), &response_page_id, &response_data);
+      MakeFrontendID(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;
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   {
     SCOPED_TRACE("Address");
     FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-        PackGUIDs(empty, guid), &response_page_id, &response_data);
+        MakeFrontendID(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);
+  SuggestionBackendID guid2("00000000-0000-0000-0000-000000000004", 0);
   response_page_id = 0;
   {
     FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
-        PackGUIDs(guid2, empty), &response_page_id, &response_data);
+        MakeFrontendID(guid2, empty), &response_page_id, &response_data);
     SCOPED_TRACE("Credit card");
     ExpectFilledCreditCardFormElvis(
         response_page_id, response_data, kPageID2, true);
   }
 }
 
 // Test that non-focusable field is ignored while inferring boundaries between
 // sections: http://crbug.com/231160
 TEST_F(AutofillManagerTest, FillFormWithNonFocusableFields) {
   // Create a form with both focusable and non-focusable fields.
@@ skipping 21 matching lines @@
   field.is_focusable = false;
   form.fields.push_back(field);
 
   test::CreateTestFormField("Country", "country", "", "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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data);
 
   // The whole form should be filled as all the fields belong to the same
   // logical section.
   ASSERT_EQ(6U, response_data.fields.size());
   ExpectFilledField("First Name", "firstname", "Elvis", "text",
                     response_data.fields[0]);
   ExpectFilledField("", "lastname", "Presley", "text",
                     response_data.fields[1]);
   ExpectFilledField("", "email", "theking@gmail.com", "text",
                     response_data.fields[2]);
@@ skipping 14 matching lines @@
   const size_t kAddressFormSize = form.fields.size();
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address 1");
     // The second address section should be empty.
     ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
     for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
       EXPECT_EQ(base::string16(), response_data.fields[i].value);
     }
 
     // The first address section should be filled with Elvis's data.
     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);
+  SuggestionBackendID guid2("00000000-0000-0000-0000-000000000001", 0);
   ASSERT_LT(9U, kAddressFormSize);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(
       kPageID2, form, form.fields[kAddressFormSize + 9],
-      PackGUIDs(empty, guid2), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid2), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address 2");
     ASSERT_EQ(response_data.fields.size(), form.fields.size());
 
     // The first address section should be empty.
     ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
       EXPECT_EQ(base::string16(), response_data.fields[i].value);
     }
 
@@ skipping 66 matching lines @@
   form.fields.push_back(field);
 
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[1],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Unnamed section");
     EXPECT_EQ(kDefaultPageID, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
     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", 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",
                       response_data.fields[10]);
   }
 
   // Fill the address portion of the billing section.
   const int kPageID2 = 2;
-  GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID guid2("00000000-0000-0000-0000-000000000001", 0);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
-      PackGUIDs(empty, guid2), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid2), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Billing address");
     EXPECT_EQ(kPageID2, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
     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", "US", "text",
                       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",
                       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);
+  SuggestionBackendID guid3("00000000-0000-0000-0000-000000000004", 0);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(
       kPageID3, form, form.fields[form.fields.size() - 2],
-      PackGUIDs(guid3, empty), &response_page_id, &response_data);
+      MakeFrontendID(guid3, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card");
     EXPECT_EQ(kPageID3, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
     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", response_data.fields[0]);
@@ skipping 19 matching lines @@
   FormData 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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data);
 
   // The second email address should be filled.
   EXPECT_EQ(ASCIIToUTF16("theking@gmail.com"),
             response_data.fields.back().value);
 
   // The remainder of the form should be filled as usual.
   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;
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address");
     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);
+  SuggestionBackendID guid2("00000000-0000-0000-0000-000000000004", 0);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
-      PackGUIDs(guid2, empty), &response_page_id, &response_data);
+      MakeFrontendID(guid2, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card 1");
     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;
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(kPageID3, form, *form.fields.rbegin(),
-      PackGUIDs(guid2, empty), &response_page_id, &response_data);
+      MakeFrontendID(guid2, empty), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card 2");
     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.
@@ skipping 16 matching lines @@
   name_variants.clear();
   name_variants.push_back(ASCIIToUTF16("Other"));
   name_variants.push_back(profile->GetRawInfo(NAME_MIDDLE));
   profile->SetRawMultiInfo(NAME_MIDDLE, name_variants);
 
   name_variants.clear();
   name_variants.push_back(ASCIIToUTF16("Guy"));
   name_variants.push_back(profile->GetRawInfo(NAME_LAST));
   profile->SetRawMultiInfo(NAME_LAST, name_variants);
 
-  GUIDPair guid(profile->guid(), 1);
-  GUIDPair empty(std::string(), 0);
+  SuggestionBackendID guid(profile->guid(), 1);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data1;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data1);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data1);
   {
     SCOPED_TRACE("Valid variant");
     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);
+  SuggestionBackendID guid2(profile->guid(), 2);
   response_page_id = 0;
   FormData response_data2;
   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
-      PackGUIDs(empty, guid2), &response_page_id, &response_data2);
+      MakeFrontendID(empty, guid2), &response_page_id, &response_data2);
   {
     SCOPED_TRACE("Invalid variant");
     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.
@@ skipping 40 matching lines @@
   forms.push_back(form_with_autocompletetype);
   FormsSeen(forms);
 
   // 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);
+  SuggestionBackendID guid(work_profile->guid(), 0);
+  SuggestionBackendID 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);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data1);
   EXPECT_EQ(1, response_page_id);
 
   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;
   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);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data2);
   EXPECT_EQ(2, response_page_id);
 
   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;
   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);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data3);
   EXPECT_EQ(3, response_page_id);
 
   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;
   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);
+      MakeFrontendID(empty, guid), &response_page_id, &response_data4);
   EXPECT_EQ(4, response_page_id);
 
   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);
+  SuggestionBackendID variant_guid(work_profile->guid(), 1);
   FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
       *form_with_maxlength.fields.begin(),
-      PackGUIDs(empty, variant_guid), &response_page_id, &response_data5);
+      MakeFrontendID(empty, variant_guid), &response_page_id, &response_data5);
   EXPECT_EQ(5, response_page_id);
 
   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;
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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;
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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;
   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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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(response_data);
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled,
@@ skipping 37 matching lines @@
   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"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
 
-  base::string16 expected_values[] = {
-    ASCIIToUTF16("Jay"),
-    ASCIIToUTF16("Jason")
-  };
-  base::string16 expected_labels[] = { base::string16(), base::string16()};
-  base::string16 expected_icons[] = { base::string16(), base::string16()};
-  int expected_unique_ids[] = {0, 0};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("Jay", "", "", 0),
+      Suggestion("Jason", "", "", 0));
 }
 
 // Duplicate of the below test with the respect-autocomplete-off-autofill
 // switch.
 TEST_F(AutofillManagerTest, AutocompleteOffRespected) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kRespectAutocompleteOffForAutofill);
 
   TestAutofillClient client;
   autofill_manager_.reset(
       new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   autofill_manager_->set_autofill_enabled(false);
   autofill_manager_->SetExternalDelegate(external_delegate_.get());
 
   scoped_ptr<MockAutocompleteHistoryManager> autocomplete_history_manager;
   autocomplete_history_manager.reset(
       new MockAutocompleteHistoryManager(autofill_driver_.get(), &client));
   autofill_manager_->autocomplete_history_manager_ =
       autocomplete_history_manager.Pass();
   MockAutocompleteHistoryManager* m = static_cast<
       MockAutocompleteHistoryManager*>(
           autofill_manager_->autocomplete_history_manager_.get());
   EXPECT_CALL(*m,
-      OnGetAutocompleteSuggestions(_, _, _, _, _, _, _, _)).Times(0);
+      OnGetAutocompleteSuggestions(_, _, _, _, _)).Times(0);
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   FormFieldData* field = &form.fields[0];
   field->should_autocomplete = false;
   GetAutofillSuggestions(form, *field);
 }
 
 TEST_F(AutofillManagerTest, AutocompleteOffRespectedWithFlag) {
   TestAutofillClient client;
   autofill_manager_.reset(
       new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   autofill_manager_->set_autofill_enabled(false);
   autofill_manager_->SetExternalDelegate(external_delegate_.get());
 
   scoped_ptr<MockAutocompleteHistoryManager> autocomplete_history_manager;
   autocomplete_history_manager.reset(
       new MockAutocompleteHistoryManager(autofill_driver_.get(), &client));
   autofill_manager_->autocomplete_history_manager_ =
       autocomplete_history_manager.Pass();
   MockAutocompleteHistoryManager* m = static_cast<
       MockAutocompleteHistoryManager*>(
           autofill_manager_->autocomplete_history_manager_.get());
   EXPECT_CALL(*m,
-      OnGetAutocompleteSuggestions(_, _, _, _, _, _, _, _)).Times(0);
+      OnGetAutocompleteSuggestions(_, _, _, _, _)).Times(0);
 
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   FormFieldData* field = &form.fields[0];
   field->should_autocomplete = false;
   GetAutofillSuggestions(form, *field);
 }
@@ skipping 14 matching lines @@
   // Clear the heuristic types, and instead set the appropriate server types.
   std::vector<ServerFieldType> 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)->heuristic_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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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(response_data);
 }
 
 // Test that the form signature for an uploaded form always matches the form
@@ skipping 32 matching lines @@
   // 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);
+  SuggestionBackendID guid("00000000-0000-0000-0000-000000000001", 0);
+  SuggestionBackendID empty(std::string(), 0);
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[3],
-      PackGUIDs(empty, guid), &response_page_id, &response_data);
+      MakeFrontendID(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(response_data);
 
   // Set the address field's value back to the default value.
   response_data.fields[3].value = ASCIIToUTF16("Enter your address");
 
   // Simulate form submission.  We should not call into the PDM to try to save
@@ skipping 310 matching lines @@
   FormSubmitted(form);
 }
 
 TEST_F(AutofillManagerTest, RemoveProfile) {
   // Add and remove an Autofill profile.
   AutofillProfile* profile = new AutofillProfile;
   std::string guid = "00000000-0000-0000-0000-000000000102";
   profile->set_guid(guid.c_str());
   autofill_manager_->AddProfile(profile);
 
-  GUIDPair guid_pair(guid, 0);
-  GUIDPair empty(std::string(), 0);
-  int id = PackGUIDs(empty, guid_pair);
+  SuggestionBackendID guid_pair(guid, 0);
+  SuggestionBackendID empty(std::string(), 0);
+  int id = MakeFrontendID(empty, guid_pair);
 
   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
 
   EXPECT_FALSE(autofill_manager_->GetProfileWithGUID(guid.c_str()));
 }
 
 TEST_F(AutofillManagerTest, RemoveCreditCard){
   // Add and remove an Autofill credit card.
   CreditCard* credit_card = new CreditCard;
   std::string guid = "00000000-0000-0000-0000-000000100007";
   credit_card->set_guid(guid.c_str());
   autofill_manager_->AddCreditCard(credit_card);
 
-  GUIDPair guid_pair(guid, 0);
-  GUIDPair empty(std::string(), 0);
-  int id = PackGUIDs(guid_pair, empty);
+  SuggestionBackendID guid_pair(guid, 0);
+  SuggestionBackendID empty(std::string(), 0);
+  int id = MakeFrontendID(guid_pair, empty);
 
   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
 
   EXPECT_FALSE(autofill_manager_->GetCreditCardWithGUID(guid.c_str()));
 }
 
 TEST_F(AutofillManagerTest, RemoveProfileVariant) {
   // Add and remove an Autofill profile.
   AutofillProfile* profile = new AutofillProfile;
   std::string guid = "00000000-0000-0000-0000-000000000102";
   profile->set_guid(guid.c_str());
   autofill_manager_->AddProfile(profile);
 
-  GUIDPair guid_pair(guid, 1);
-  GUIDPair empty(std::string(), 0);
-  int id = PackGUIDs(empty, guid_pair);
+  SuggestionBackendID guid_pair(guid, 1);
+  SuggestionBackendID empty(std::string(), 0);
+  int id = MakeFrontendID(empty, guid_pair);
 
   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
 
   // TODO(csharp): Currently variants should not be deleted, but once they are
   // update these expectations.
   // http://crbug.com/124211
   EXPECT_TRUE(autofill_manager_->GetProfileWithGUID(guid.c_str()));
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
@@ skipping 108 matching lines @@
   FormFieldData number_field = form.fields[3];
   number_field.value = ASCIIToUTF16("901");
 
   // Get the suggestions for already filled credit card |number_field|.
   GetAutofillSuggestions(form, number_field);
 
   // No autocomplete suggestions provided, so send an empty vector as the
   // results. This triggers the combined message send.
   AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
-  base::string16 expected_values[] = {ASCIIToUTF16("************3456")};
-  base::string16 expected_labels[] = {ASCIIToUTF16("04/12")};
-  base::string16 expected_icons[] = {ASCIIToUTF16(kVisaCard)};
-  int expected_unique_ids[] = {autofill_manager_->GetPackedCreditCardID(4)};
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, arraysize(expected_values), expected_values,
-      expected_labels, expected_icons, expected_unique_ids);
+      kDefaultPageID,
+      Suggestion("************3456", "04/12", kVisaCard,
+                 autofill_manager_->GetPackedCreditCardID(4)));
 }
 
 }  // namespace autofill