Create an autofill Suggestion class

components/autofill/core/browser/personal_data_manager.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 "components/autofill/core/browser/personal_data_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 
@@ skipping 530 matching lines @@
 
 const std::vector<CreditCard*>& PersonalDataManager::GetCreditCards() const {
   return credit_cards_.get();
 }
 
 void PersonalDataManager::Refresh() {
   LoadProfiles();
   LoadCreditCards();
 }
 
-void PersonalDataManager::GetProfileSuggestions(
+std::vector<Suggestion> PersonalDataManager::GetProfileSuggestions(
     const AutofillType& type,
     const base::string16& field_contents,
     bool field_is_autofilled,
     const std::vector<ServerFieldType>& other_field_types,
-    const base::Callback<bool(const AutofillProfile&)>& filter,
-    std::vector<base::string16>* values,
-    std::vector<base::string16>* labels,
-    std::vector<base::string16>* icons,
-    std::vector<GUIDPair>* guid_pairs) {
-  values->clear();
-  labels->clear();
-  icons->clear();
-  guid_pairs->clear();
+    const base::Callback<bool(const AutofillProfile&)>& filter) {
+  std::vector<Suggestion> suggestions;
 
-  const std::vector<AutofillProfile*>& profiles = GetProfiles(true);
   std::vector<AutofillProfile*> matched_profiles;
-  for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
-       iter != profiles.end(); ++iter) {
-    AutofillProfile* profile = *iter;
-
+  for (AutofillProfile* profile : GetProfiles(true)) {
     // The value of the stored data for this field type in the |profile|.
     std::vector<base::string16> multi_values;
     AddressField address_field;
     if (i18n::FieldForType(type.GetStorableType(), &address_field) &&
         address_field == STREET_ADDRESS) {
       std::string street_address_line;
       GetStreetAddressLinesAsSingleLine(
           *i18n::CreateAddressDataFromAutofillProfile(*profile, app_locale_),
           &street_address_line);
       multi_values.push_back(base::UTF8ToUTF16(street_address_line));
     } else {
       profile->GetMultiInfo(type, app_locale_, &multi_values);
     }
 
     for (size_t i = 0; i < multi_values.size(); ++i) {
       // Newlines can be found only in a street address, which was collapsed
       // into a single line above.
       DCHECK(multi_values[i].find('\n') == std::string::npos);
 
       if (!field_is_autofilled) {
         // Suggest data that starts with what the user has typed.
         if (!multi_values[i].empty() &&
             StartsWith(multi_values[i], field_contents, false) &&
             (filter.is_null() || filter.Run(*profile))) {
           matched_profiles.push_back(profile);
-          values->push_back(multi_values[i]);
-          guid_pairs->push_back(GUIDPair(profile->guid(), i));
+          suggestions.push_back(Suggestion(multi_values[i]));
+          suggestions.back().backend_id.guid = profile->guid();
+          suggestions.back().backend_id.variant = i;
         }
       } else {
         if (multi_values[i].empty())
           continue;
 
         base::string16 profile_value_lower_case(
             base::StringToLowerASCII(multi_values[i]));
         base::string16 field_value_lower_case(
             base::StringToLowerASCII(field_contents));
         // Phone numbers could be split in US forms, so field value could be
         // either prefix or suffix of the phone.
         bool matched_phones = false;
         if (type.GetStorableType() == PHONE_HOME_NUMBER &&
             !field_value_lower_case.empty() &&
             profile_value_lower_case.find(field_value_lower_case) !=
                 base::string16::npos) {
           matched_phones = true;
         }
 
         // Suggest variants of the profile that's already been filled in.
         if (matched_phones ||
             profile_value_lower_case == field_value_lower_case) {
           for (size_t j = 0; j < multi_values.size(); ++j) {
             if (!multi_values[j].empty()) {
-              values->push_back(multi_values[j]);
-              guid_pairs->push_back(GUIDPair(profile->guid(), j));
+              suggestions.push_back(Suggestion(multi_values[j]));
+              suggestions.back().backend_id.guid = profile->guid();
+              suggestions.back().backend_id.variant = j;
             }
           }
 
           // We've added all the values for this profile so move on to the
           // next.
           break;
         }
       }
     }
   }
 
   if (!field_is_autofilled) {
+    // Generate labels for the profiles we discovered above.
+    std::vector<base::string16> labels;
     AutofillProfile::CreateInferredLabels(
         matched_profiles, &other_field_types,
-        type.GetStorableType(), 1, app_locale_, labels);
-  } else {
-    // No sub-labels for previously filled fields.
-    labels->resize(values->size());
+        type.GetStorableType(), 1, app_locale_, &labels);
+    DCHECK_EQ(suggestions.size(), labels.size());
+    for (size_t i = 0; i < labels.size(); i++)
+      suggestions[i].label = labels[i];
   }
 
-  // No icons for profile suggestions.
-  icons->resize(values->size());
+  return suggestions;
 }
 
-void PersonalDataManager::GetCreditCardSuggestions(
+std::vector<Suggestion> PersonalDataManager::GetCreditCardSuggestions(
     const AutofillType& type,
-    const base::string16& field_contents,
-    std::vector<base::string16>* values,
-    std::vector<base::string16>* labels,
-    std::vector<base::string16>* icons,
-    std::vector<GUIDPair>* guid_pairs) {
-  values->clear();
-  labels->clear();
-  icons->clear();
-  guid_pairs->clear();
-
-  const std::vector<CreditCard*>& credit_cards = GetCreditCards();
-  for (std::vector<CreditCard*>::const_iterator iter = credit_cards.begin();
-       iter != credit_cards.end(); ++iter) {
-    CreditCard* credit_card = *iter;
-
+    const base::string16& field_contents) {
+  std::vector<Suggestion> suggestions;
+  for (const CreditCard* credit_card : GetCreditCards()) {
     // The value of the stored data for this field type in the |credit_card|.
     base::string16 creditcard_field_value =
         credit_card->GetInfo(type, app_locale_);
     if (!creditcard_field_value.empty() &&
         (StartsWith(creditcard_field_value, field_contents, false) ||
          (type.GetStorableType() == CREDIT_CARD_NUMBER &&
           base::string16::npos !=
               creditcard_field_value.find(field_contents)))) {
+      // Make a new suggestion.
+      suggestions.push_back(Suggestion());
+      Suggestion* suggestion = &suggestions.back();
+
       // If the value is the card number, the label is the expiration date.
       // Otherwise the label is the card number, or if that is empty the
       // cardholder name. The label should never repeat the value.
-      base::string16 label;
       if (type.GetStorableType() == CREDIT_CARD_NUMBER) {
         creditcard_field_value = credit_card->ObfuscatedNumber();
-        label = credit_card->GetInfo(
+        suggestion->label = credit_card->GetInfo(
             AutofillType(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR), app_locale_);
       } else if (credit_card->number().empty()) {
         if (type.GetStorableType() != CREDIT_CARD_NAME) {
-          label =
+          suggestion->label =
               credit_card->GetInfo(AutofillType(CREDIT_CARD_NAME), app_locale_);
         }
       } else {
-        label = kCreditCardPrefix;
-        label.append(credit_card->LastFourDigits());
+        suggestion->label = kCreditCardPrefix;
+        suggestion->label.append(credit_card->LastFourDigits());
       }
 
-      values->push_back(creditcard_field_value);
-      labels->push_back(label);
-      icons->push_back(base::UTF8ToUTF16(credit_card->type()));
-      guid_pairs->push_back(GUIDPair(credit_card->guid(), 0));
+      suggestion->value = creditcard_field_value;
+      suggestion->icon = base::UTF8ToUTF16(credit_card->type());
+      suggestion->backend_id.guid = credit_card->guid();
     }
   }
+  return suggestions;
 }
 
 bool PersonalDataManager::IsAutofillEnabled() const {
   DCHECK(pref_service_);
   return pref_service_->GetBoolean(prefs::kAutofillEnabled);
 }
 
 std::string PersonalDataManager::CountryCodeForCurrentTimezone() const {
   return base::CountryCodeForCurrentTimezone();
 }
@@ skipping 403 matching lines @@
   // Populates |auxiliary_profiles_|.
   LoadAuxiliaryProfiles(record_metrics);
 
   profiles_.insert(profiles_.end(), web_profiles_.begin(), web_profiles_.end());
   profiles_.insert(
       profiles_.end(), auxiliary_profiles_.begin(), auxiliary_profiles_.end());
   return profiles_;
 }
 
 }  // namespace autofill