[Autofill] Autofill fails to show suggestions for credit card split across fields.

components/autofill/core/browser/autofill_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/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 138 matching lines @@
       it->GetMatchingTypes(value, app_locale, &matching_types);
     }
 
     if (matching_types.empty())
       matching_types.insert(UNKNOWN_TYPE);
 
     field->set_possible_types(matching_types);
   }
 }
 
+// Helper function to obfuscate the credit card digits with '*'.
+base::string16 ObfuscatedCreditCardNumber(const base::string16& card_number) {
+  // If the number is shorter than four digits, there's no need to obfuscate it.
+  if (card_number.size() < 4)
+    return card_number;
+
+  const size_t max_obfuscation_size = 20;
+  const base::char16 obfuscation_symbol = '*';
+
+  // Avoid making very long obfuscated numbers.
+  size_t obfuscated_digits =
+      std::min(max_obfuscation_size, card_number.size() - 4);
+  base::string16 result(obfuscated_digits, obfuscation_symbol);
+  return result.append(card_number.substr(card_number.size() - 4));
+}

[Ilya Sherman, 2014/10/16 23:55:10]

Please remove this function.  This work should be done by the
PersonalDataManager.

[Pritam Nikam, 2014/10/28 10:11:07]

Done.

+
 }  // namespace
 
 AutofillManager::AutofillManager(
     AutofillDriver* driver,
     AutofillClient* client,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
     : driver_(driver),
       client_(client),
       app_locale_(app_locale),
@@ skipping 297 matching lines @@
   AutofillField* autofill_field = NULL;
   if (RefreshDataModels() &&
       driver_->RendererIsAvailable() &&
       GetCachedFormAndField(form, field, &form_structure, &autofill_field) &&
       // Don't send suggestions for forms that aren't auto-fillable.
       form_structure->IsAutofillable()) {
     AutofillType type = autofill_field->Type();
     bool is_filling_credit_card = (type.group() == CREDIT_CARD);
     if (is_filling_credit_card) {
       GetCreditCardSuggestions(
-          field, type, &values, &labels, &icons, &unique_ids);
+          field, *autofill_field, &values, &labels, &icons, &unique_ids);
     } else {
       GetProfileSuggestions(*form_structure,
                             field,
                             *autofill_field,
                             &values,
                             &labels,
                             &icons,
                             &unique_ids);
     }
 
@@ skipping 610 matching lines @@
   std::vector<GUIDPair> guid_pairs;
 
   personal_data_->GetProfileSuggestions(
       autofill_field.Type(), field.value, field.is_autofilled, field_types,
       base::Callback<bool(const AutofillProfile&)>(),
       values, labels, icons, &guid_pairs);
 
   // Adjust phone number to display in prefix/suffix case.
   if (autofill_field.Type().GetStorableType() == PHONE_HOME_NUMBER) {
     for (size_t i = 0; i < values->size(); ++i) {
-      (*values)[i] = AutofillField::GetPhoneNumberValue(
-          autofill_field, (*values)[i], field);
+      (*values)[i] =
+          AutofillField::GetPhoneNumberValue(autofill_field, (*values)[i]);
     }
   }
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
                                     guid_pairs[i]));
   }
 }
 
 void AutofillManager::GetCreditCardSuggestions(
     const FormFieldData& field,
-    const AutofillType& type,
+    const AutofillField& autofill_field,
     std::vector<base::string16>* values,
     std::vector<base::string16>* labels,
     std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
   std::vector<GUIDPair> guid_pairs;
+  AutofillType type = autofill_field.Type();
   personal_data_->GetCreditCardSuggestions(
-      type, field.value, values, labels, icons, &guid_pairs);
+      type, field.value, values, labels, icons, &guid_pairs, false);
+
+  // Remove the non-matching credit card suggestions.
+  if (type.GetStorableType() == CREDIT_CARD_NUMBER) {
+    std::vector<base::string16>::iterator it = values->begin();
+    while (it != values->end()) {
+      base::string16 card_number =
+          AutofillField::GetCreditCardNumberValue(autofill_field, *it);
+      if (StartsWith(card_number, field.value, false)) {
+        ++it;
+        continue;
+      }
+
+      // Prune the not-matching suggestions.
+      size_t offset = it - values->begin();
+      it = values->erase(it);
+      labels->erase(offset + labels->begin());
+      icons->erase(offset + icons->begin());
+      guid_pairs.erase(offset + guid_pairs.begin());
+    }
+
+    // Obfuscate the credit card numbers in suggetions.
+    for (size_t i = 0; i < values->size(); ++i) {
+      (*values)[i] = ObfuscatedCreditCardNumber((*values)[i]);
+    }
+  }
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
   }
 }
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   std::vector<FormStructure*> non_queryable_forms;
   for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
@@ skipping 104 matching lines @@
     return false;
 
   // Disregard forms that we wouldn't ever autofill in the first place.
   if (!form.ShouldBeParsed())
     return false;
 
   return true;
 }
 
 }  // namespace autofill