AutoFill suggestions for billing and credit card fields should show derived labels.

chrome/browser/autofill/autofill_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/autofill/autofill_manager.h"
 
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 21 matching lines @@
 // The rate for positive/negative matches potentially could be different.
 const double kAutoFillPositiveUploadRateDefaultValue = 0.01;
 const double kAutoFillNegativeUploadRateDefaultValue = 0.01;
 
 // Size and offset of the prefix and suffix portions of phone numbers.
 const int kAutoFillPhoneNumberPrefixOffset = 0;
 const int kAutoFillPhoneNumberPrefixCount = 3;
 const int kAutoFillPhoneNumberSuffixOffset = 3;
 const int kAutoFillPhoneNumberSuffixCount = 4;
 
+const string16::value_type kCreditCardPrefix[] = {'*', 0};
+const string16::value_type kLabelSeparator[] = {';',' ', '*', 0};
 
-const string16::value_type kCreditCardLabelPrefix[] = {'*', 0};
-const string16::value_type kLabelSeparator[] = {';',' ', '*', 0};
+// Combines the |label| string with the last four digits of the credit card
+// |cc|.  If one, the other, or both are empty strings we omit the separator.
+string16 CombineLabelAndCreditCard(const string16& label,
+                                   const CreditCard* cc) {
+  if (label.empty())
+    return kCreditCardPrefix + cc->LastFourDigits();
+  else if (cc->LastFourDigits().empty())
+    return label;
+  else
+    return label + kLabelSeparator + cc->LastFourDigits();
+}
 
 // The name of the generic credit card icon, which maps to the image resource ID
 // in webkit/glue:WebKitClientImpl.
 // TODO(jhawkins): Move the images to chrome/common and implement the resource
 // handling in RendererWebKitClientImpl.
 const char kGenericCC[] = "genericCC";
 
 // Removes duplicate elements whilst preserving original order of |elements| and
 // |unique_ids|.
 void RemoveDuplicateElements(
@@ skipping 453 matching lines @@
   std::vector<string16> expanded_labels;
   std::vector<int> expanded_ids;
   for (std::vector<AutoFillProfile*>::const_iterator iter =
        matched_profiles.begin(); iter != matched_profiles.end();
        ++iter, ++i) {
     AutoFillProfile* profile = *iter;
     for (std::vector<CreditCard*>::const_iterator cc =
          personal_data_->credit_cards().begin();
          cc != personal_data_->credit_cards().end(); ++cc) {
       expanded_values.push_back((*values)[i]);
-      string16 label = (*labels)[i] + kLabelSeparator + (*cc)->LastFourDigits();
+      string16 label = CombineLabelAndCreditCard((*labels)[i], *cc);
       expanded_labels.push_back(label);
       expanded_ids.push_back(PackIDs((*cc)->unique_id(), profile->unique_id()));
     }
   }
   expanded_labels.swap(*labels);
   expanded_values.swap(*values);
+  // No CC, so no icons.
+  icons->resize(values->size());
   expanded_ids.swap(*unique_ids);
+  DCHECK_EQ(values->size(), icons->size());
 }
 
 void AutoFillManager::GetBillingProfileSuggestions(
     FormStructure* form,
     const FormField& field,
     AutoFillType type,
     std::vector<string16>* values,
     std::vector<string16>* labels,
     std::vector<string16>* icons,
     std::vector<int>* unique_ids) {
-  std::vector<CreditCard*> matching_creditcards;
-  std::vector<AutoFillProfile*> matching_profiles;
-  std::vector<string16> cc_values;
-  std::vector<string16> cc_labels;
 
   // If the form is non-HTTPS, no CC suggestions are provided; however, give the
   // user the option of filling the billing address fields with regular address
   // data.
   if (!FormIsHTTPS(form)) {
     GetProfileSuggestions(
         form, field, type, false, values, icons, labels, unique_ids);
     return;
   }
 
+  std::vector<CreditCard*> matching_creditcards;
+  std::vector<AutoFillProfile*> matching_profiles;
+
+  // Collect matching pairs of credit cards and related profiles, where profile
+  // field value matches form field value.
   for (std::vector<CreditCard*>::const_iterator cc =
            personal_data_->credit_cards().begin();
        cc != personal_data_->credit_cards().end(); ++cc) {
     string16 label = (*cc)->billing_address();
     AutoFillProfile* billing_profile = NULL;
 
     // The value of the stored data for this field type in the |profile|.
     string16 profile_field_value;
 
     for (std::vector<AutoFillProfile*>::const_iterator iter =
              personal_data_->profiles().begin();
          iter != personal_data_->profiles().end(); ++iter) {
       AutoFillProfile* profile = *iter;
 
       // This assumes that labels are unique.
       if (profile->Label() == label &&
           !profile->GetFieldText(type).empty() &&
           StartsWith(profile->GetFieldText(type), field.value(), false)) {
         billing_profile = profile;
         break;
       }
     }
 
     if (!billing_profile)
       continue;
 
-    for (std::vector<AutoFillProfile*>::const_iterator iter =
-             personal_data_->profiles().begin();
-         iter != personal_data_->profiles().end(); ++iter) {
-      values->push_back(billing_profile->GetFieldText(type));
+    matching_creditcards.push_back(*cc);
+    matching_profiles.push_back(billing_profile);
+  }
 
-      string16 label = (*iter)->Label() + kLabelSeparator +
-                       (*cc)->LastFourDigits();
-      labels->push_back(label);
-      icons->push_back(ASCIIToUTF16(kGenericCC));
-      unique_ids->push_back(
-          PackIDs((*cc)->unique_id(), (*iter)->unique_id()));
-    }
+  std::vector<string16> inferred_labels;
+  AutoFillProfile::CreateInferredLabels(&matching_profiles, &inferred_labels, 0,
+                                        type.field_type());
+
+  DCHECK_EQ(matching_profiles.size(), matching_creditcards.size());
+  DCHECK_EQ(matching_profiles.size(), inferred_labels.size());
+
+  // Process the matching pairs into suggested |values|, |labels|, and
+  // |unique_ids|.
+  for (size_t i = 0; i < matching_profiles.size(); ++i) {
+    values->push_back(matching_profiles[i]->GetFieldText(type));
+    string16 label = CombineLabelAndCreditCard(inferred_labels[i],
+                                               matching_creditcards[i]);
+    labels->push_back(label);
+    icons->push_back(ASCIIToUTF16(kGenericCC));
+    unique_ids->push_back(PackIDs(matching_creditcards[i]->unique_id(),
+                                  matching_profiles[i]->unique_id()));
   }
 }
 
 void AutoFillManager::GetCreditCardSuggestions(FormStructure* form,
                                                const FormField& field,
                                                AutoFillType type,
                                                std::vector<string16>* values,
                                                std::vector<string16>* labels,
                                                std::vector<string16>* icons,
                                                std::vector<int>* unique_ids) {
   // Don't return CC suggestions for non-HTTPS pages.
   if (!FormIsHTTPS(form))
     return;
 
   for (std::vector<CreditCard*>::const_iterator iter =
            personal_data_->credit_cards().begin();
        iter != personal_data_->credit_cards().end(); ++iter) {
     CreditCard* credit_card = *iter;
 
     // The value of the stored data for this field type in the |credit_card|.
     string16 creditcard_field_value = credit_card->GetFieldText(type);
     if (!creditcard_field_value.empty() &&
         StartsWith(creditcard_field_value, field.value(), false)) {
       if (type.field_type() == CREDIT_CARD_NUMBER)
         creditcard_field_value = credit_card->ObfuscatedNumber();
 
       if (!form->HasNonBillingFields()) {
         values->push_back(creditcard_field_value);
-        labels->push_back(
-            kCreditCardLabelPrefix + credit_card->LastFourDigits());
+        labels->push_back(CombineLabelAndCreditCard(string16(), credit_card));
+        icons->push_back(ASCIIToUTF16(kGenericCC));
         unique_ids->push_back(PackIDs(credit_card->unique_id(), 0));
       } else {
-        for (std::vector<AutoFillProfile*>::const_iterator iter =
-                 personal_data_->profiles().begin();
-             iter != personal_data_->profiles().end(); ++iter) {
+        const std::vector<AutoFillProfile*>& profiles
+            = personal_data_->profiles();
+        std::vector<string16> inferred_labels;
+        AutoFillProfile::CreateInferredLabels(&profiles,
+                                              &inferred_labels,
+                                              0,
+                                              type.field_type());
+        DCHECK_EQ(profiles.size(), inferred_labels.size());
+
+        for (size_t i = 0; i < profiles.size(); ++i) {
           values->push_back(creditcard_field_value);
 
-          string16 label = (*iter)->Label() + kLabelSeparator +
-                           credit_card->LastFourDigits();
+          string16 label = CombineLabelAndCreditCard(inferred_labels[i],
+                                                     credit_card);
           labels->push_back(label);
           icons->push_back(ASCIIToUTF16(kGenericCC));
           unique_ids->push_back(
-            PackIDs(credit_card->unique_id(), (*iter)->unique_id()));
+              PackIDs(credit_card->unique_id(), profiles[i]->unique_id()));
         }
       }
     }
   }
 }
 
 void AutoFillManager::FillBillingFormField(const CreditCard* credit_card,
                                            AutoFillType type,
                                            webkit_glue::FormField* field) {
   DCHECK(credit_card);
@@ skipping 124 matching lines @@
 
 // When receiving IDs (across processes) from the renderer we unpack credit card
 // and profile IDs from a single integer.  Credit card IDs are stored in the
 // high word and profile IDs are stored in the low word.
 // static
 void AutoFillManager::UnpackIDs(int id, int* cc_id, int* profile_id) {
   *cc_id = id >> std::numeric_limits<unsigned short>::digits &
       std::numeric_limits<unsigned short>::max();
   *profile_id = id & std::numeric_limits<unsigned short>::max();
 }