AutoFill: Display a right-aligned generic CC icon in the suggestions popup for

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 kCreditCardLabelPrefix[] = {'*', 0};
 const string16::value_type kLabelSeparator[] = {';',' ', '*', 0};
 
+// 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(
     std::vector<string16>* elements, std::vector<int>* unique_ids) {
   DCHECK_EQ(elements->size(), unique_ids->size());
 
   std::vector<string16> elements_copy;
   std::vector<int> unique_ids_copy;
   for (size_t i = 0; i < elements->size(); ++i) {
     const string16& element = (*elements)[i];
@@ skipping 137 matching lines @@
         break;
       }
     }
   }
 
   if (autofill_field == NULL)
     return false;
 
   std::vector<string16> values;
   std::vector<string16> labels;
+  std::vector<string16> icons;
   std::vector<int> unique_ids;
   AutoFillType type(autofill_field->type());
 
   // If this form is non-HTTPS, treat billing address fields as regular address
   // fields.
   bool handle_billing = FormIsHTTPS(form);
 
   if (type.group() == AutoFillType::CREDIT_CARD)
-    GetCreditCardSuggestions(form, field, type, &values, &labels, &unique_ids);
+    GetCreditCardSuggestions(
+        form, field, type, &values, &labels, &icons, &unique_ids);
   else if (type.group() == AutoFillType::ADDRESS_BILLING)
     GetBillingProfileSuggestions(
-        form, field, type, &values, &labels, &unique_ids);
+        form, field, type, &values, &labels, &icons, &unique_ids);
   else
-    GetProfileSuggestions(
-        form, field, type, handle_billing, &values, &labels, &unique_ids);
+    GetProfileSuggestions(form, field, type, handle_billing,
+                          &values, &labels, &icons, &unique_ids);
 
   DCHECK_EQ(values.size(), labels.size());
+  DCHECK_EQ(values.size(), icons.size());
   DCHECK_EQ(values.size(), unique_ids.size());
 
   // No suggestions.
   if (values.empty())
     return false;
 
   // If the form is auto-filled and the renderer is querying for suggestions,
   // then the user is editing the value of a field.  In this case, don't display
   // labels, as that information is redundant. In addition, remove duplicate
   // values.
   if (form_autofilled) {
     RemoveDuplicateElements(&values, &unique_ids);
     labels.resize(values.size());
+    icons.resize(values.size());
 
-    for (size_t i = 0; i < labels.size(); ++i)
+    for (size_t i = 0; i < labels.size(); ++i) {
       labels[i] = string16();
+      icons[i] = string16();
+    }
   }
 
-  host->AutoFillSuggestionsReturned(query_id, values, labels, unique_ids);
+  host->AutoFillSuggestionsReturned(
+      query_id, values, labels, icons, unique_ids);
   return true;
 }
 
 // TODO(jhawkins): Remove the |value| parameter.
 bool AutoFillManager::FillAutoFillFormData(int query_id,
                                            const FormData& form,
                                            const string16& value,
                                            const string16& label,
                                            int unique_id) {
   if (!IsAutoFillEnabled())
@@ skipping 206 matching lines @@
       download_manager_(NULL) {
   DCHECK(tab_contents);
 }
 
 void AutoFillManager::GetProfileSuggestions(FormStructure* form,
                                             const FormField& field,
                                             AutoFillType type,
                                             bool include_cc_labels,
                                             std::vector<string16>* values,
                                             std::vector<string16>* labels,
+                                            std::vector<string16>* icons,
                                             std::vector<int>* unique_ids) {
   const std::vector<AutoFillProfile*>& profiles = personal_data_->profiles();
   std::vector<AutoFillProfile*> matched_profiles;
   for (std::vector<AutoFillProfile*>::const_iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
     AutoFillProfile* profile = *iter;
 
     // The value of the stored data for this field type in the |profile|.
     string16 profile_field_value = profile->GetFieldText(type);
 
     if (!profile_field_value.empty() &&
         StartsWith(profile_field_value, field.value(), false)) {
       matched_profiles.push_back(profile);
       values->push_back(profile_field_value);
       unique_ids->push_back(PackIDs(0, profile->unique_id()));
     }
   }
 
+  // No CC, so no icons.
+  icons->resize(values->size());
+
   AutoFillProfile::CreateInferredLabels(&matched_profiles, labels, 0,
                                         type.field_type());
 
   if (!include_cc_labels || !form->HasBillingFields() || !FormIsHTTPS(form))
     return;
 
   size_t i = 0;
   std::vector<string16> expanded_values;
   std::vector<string16> expanded_labels;
   std::vector<int> expanded_ids;
@@ skipping 14 matching lines @@
   expanded_values.swap(*values);
   expanded_ids.swap(*unique_ids);
 }
 
 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, labels, unique_ids);
+    GetProfileSuggestions(
+        form, field, type, false, values, icons, labels, unique_ids);
     return;
   }
 
   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|.
@@ skipping 17 matching lines @@
       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));
 
       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()));
     }
   }
 }
 
 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;
 
@@ skipping 11 matching lines @@
         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) {
           values->push_back(creditcard_field_value);
 
           string16 label = (*iter)->Label() + kLabelSeparator +
                            credit_card->LastFourDigits();
           labels->push_back(label);
+          icons->push_back(ASCIIToUTF16(kGenericCC));
           unique_ids->push_back(
             PackIDs(credit_card->unique_id(), (*iter)->unique_id()));
         }
       }
     }
   }
 }
 
 void AutoFillManager::FillBillingFormField(const CreditCard* credit_card,
                                            AutoFillType type,
@@ skipping 126 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();
 }