AutoFill Assert with AutoFillManager unique ids and Credit Card filling

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"
 #include "base/string16.h"
 #include "chrome/browser/autofill/autofill_dialog.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/form_structure.h"
 #include "chrome/browser/autofill/select_control_handler.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
@@ skipping 14 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};
 
 // 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;
@@ skipping 217 matching lines @@
     }
   }
 
   if (!form_structure)
     return false;
 
   // No data to return if there are no auto-fillable fields.
   if (!form_structure->autofill_count())
     return false;
 
-  // |cc_digits| will contain the last four digits of a credit card number only
-  // if the form has billing fields.
-  string16 cc_digits;
+  // Unpack the |unique_id| into component parts.
+  int cc_id = 0;
+  int profile_id = 0;
+  UnpackIDs(unique_id, &cc_id, &profile_id);
 
-  // If the form has billing fields, |label| will contain at least one "; "
-  // followed by the last four digits of a credit card number.
-  if (form_structure->HasBillingFields()) {
-    // We must search for the last "; " as it's possible the profile label
-    // proper can contain this sequence of characters.
-    size_t index = label.find_last_of(kLabelSeparator);
-    if (index != string16::npos) {
-      size_t cc_index = index + 1;
-      cc_digits = label.substr(cc_index);
+  // Find the profile that matches the |profile_id|, if one is specified.
+  const AutoFillProfile* profile = NULL;
+  if (profile_id != 0) {
+    for (std::vector<AutoFillProfile*>::const_iterator iter = profiles.begin();
+         iter != profiles.end(); ++iter) {
+      if ((*iter)->unique_id() == profile_id) {
+        profile = *iter;
+        break;
+      }
     }
   }
 
-  // Find the profile that matches the |unique_id|.
-  const AutoFillProfile* profile = NULL;
-  for (std::vector<AutoFillProfile*>::const_iterator iter = profiles.begin();
-       iter != profiles.end(); ++iter) {
-    if ((*iter)->unique_id() == unique_id) {
-      profile = *iter;
-    }
-  }
-
-  // Don't look for a matching credit card if we fully-matched the profile using
-  // the entire label.
+  // Find the credit card that matches the |cc_id|, if one is specified.
   const CreditCard* credit_card = NULL;
-  if (!cc_digits.empty()) {
-    // Find the credit card that matches the |cc_label|.
+  if (cc_id != 0) {
     for (std::vector<CreditCard*>::const_iterator iter = credit_cards.begin();
          iter != credit_cards.end(); ++iter) {
-      if ((*iter)->LastFourDigits() == cc_digits) {
+      if ((*iter)->unique_id() == cc_id) {
         credit_card = *iter;
         break;
       }
     }
   }
 
   if (!profile && !credit_card)
     return false;
 
   // The list of fields in |form_structure| and |result.fields| often match
@@ skipping 155 matching lines @@
        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(profile->unique_id());
+      unique_ids->push_back(PackIDs(0, profile->unique_id()));
     }
   }
 
   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;
   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();
       expanded_labels.push_back(label);
-      unique_ids->push_back(profile->unique_id());
+      expanded_ids.push_back(PackIDs((*cc)->unique_id(), profile->unique_id()));
     }
   }
   expanded_labels.swap(*labels);
   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<int>* unique_ids) {
   std::vector<CreditCard*> matching_creditcards;
@@ skipping 36 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);
-      unique_ids->push_back((*iter)->unique_id());
+      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<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);
+    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(credit_card->Label());
-        unique_ids->push_back(credit_card->unique_id());
+        labels->push_back(
+            kCreditCardLabelPrefix + credit_card->LastFourDigits());
+        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);
-          unique_ids->push_back((*iter)->unique_id());
+          unique_ids->push_back(
+            PackIDs(credit_card->unique_id(), (*iter)->unique_id()));
         }
       }
     }
   }
 }
 
 void AutoFillManager::FillBillingFormField(const CreditCard* credit_card,
                                            AutoFillType type,
                                            webkit_glue::FormField* field) {
   DCHECK(credit_card);
@@ skipping 103 matching lines @@
       continue;
 
     DeterminePossibleFieldTypes(form_structure);
     form_structures_.push_back(form_structure);
   }
 
   // If none of the forms were parsed, no use querying the server.
   if (!form_structures_.empty())
     download_manager_.StartQueryRequest(form_structures_);
 }
+
+// When sending IDs (across processes) to the renderer we pack credit card and
+// profile IDs into a single integer.  Credit card IDs are sent in the high
+// word and profile IDs are sent in the low word.
+// static
+int AutoFillManager::PackIDs(int cc_id, int profile_id) {
+  DCHECK(cc_id <= std::numeric_limits<unsigned short>::max());
+  DCHECK(profile_id <= std::numeric_limits<unsigned short>::max());
+
+  return cc_id << std::numeric_limits<unsigned short>::digits | profile_id;
+}
+
+// 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();
+}