[Autofill] Autofill fails to fill credit card number when split across fields.

components/autofill/core/browser/credit_card.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/credit_card.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <ostream>
@@ skipping 292 matching lines @@
       base::string16 year = Expiration4DigitYearAsString();
       if (!month.empty() && !year.empty())
         return month + base::ASCIIToUTF16("/") + year;
       return base::string16();
     }
 
     case CREDIT_CARD_TYPE:
       return TypeForDisplay();
 
     case CREDIT_CARD_NUMBER:
-      return number_;
+      return this->GetNumber();
+
+    case CREDIT_CARD_NUMBER_PART1:
+      return this->number_part1_;
+
+    case CREDIT_CARD_NUMBER_PART2:
+      return this->number_part2_;
+
+    case CREDIT_CARD_NUMBER_PART3:
+      return this->number_part3_;
+
+    case CREDIT_CARD_NUMBER_PART4:
+      return this->number_part4_;
 
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store credit card verification codes.
       return base::string16();
 
     default:
       // ComputeDataPresentForArray will hit this repeatedly.
       return base::string16();
   }
 }
@@ skipping 30 matching lines @@
       // This is a read-only attribute, determined by the credit card number.
       break;
 
     case CREDIT_CARD_NUMBER: {
       // Don't change the real value if the input is an obfuscated string.
       if (value.size() > 0 && value[0] != kCreditCardObfuscationSymbol)
         SetNumber(value);
       break;
     }
 
+    case CREDIT_CARD_NUMBER_PART1: {
+      // Don't change the real value if the input is an obfuscated string.
+      if (value.size() > 0 && value[0] != kCreditCardObfuscationSymbol)
+        SetNumber(value, autofill::CreditCard::first_part);
+      break;
+    }
+
+    case CREDIT_CARD_NUMBER_PART2: {
+      // Don't change the real value if the input is an obfuscated string.
+      if (value.size() > 0 && value[0] != kCreditCardObfuscationSymbol)
+        SetNumber(value, autofill::CreditCard::second_part);
+      break;
+    }
+
+    case CREDIT_CARD_NUMBER_PART3: {
+      // Don't change the real value if the input is an obfuscated string.
+      if (value.size() > 0 && value[0] != kCreditCardObfuscationSymbol)
+        SetNumber(value, autofill::CreditCard::third_part);
+      break;
+    }
+
+    case CREDIT_CARD_NUMBER_PART4: {
+      // Don't change the real value if the input is an obfuscated string.
+      if (value.size() > 0 && value[0] != kCreditCardObfuscationSymbol)
+        SetNumber(value, autofill::CreditCard::last_part);
+      break;
+    }
+
     case CREDIT_CARD_VERIFICATION_CODE:
       // Chrome doesn't store the credit card verification code.
       break;
 
     default:
       NOTREACHED() << "Attempting to set unknown info-type " << type;
       break;
   }
 }
 
 base::string16 CreditCard::GetInfo(const AutofillType& type,
                                    const std::string& app_locale) const {
   ServerFieldType storable_type = type.GetStorableType();
   if (storable_type == CREDIT_CARD_NUMBER)
-    return StripSeparators(number_);
+    return this->GetNumber();
 
   return GetRawInfo(storable_type);
 }
 
 bool CreditCard::SetInfo(const AutofillType& type,
                          const base::string16& value,
                          const std::string& app_locale) {
   ServerFieldType storable_type = type.GetStorableType();
   if (storable_type == CREDIT_CARD_NUMBER)
     SetRawInfo(storable_type, StripSeparators(value));
@@ skipping 17 matching lines @@
 
   int month;
   if (ConvertMonth(text, app_locale, &month) && month != 0 &&
       month == expiration_month_) {
     matching_types->insert(CREDIT_CARD_EXP_MONTH);
   }
 }
 
 const base::string16 CreditCard::Label() const {
   base::string16 label;
-  if (number().empty())
+  if (GetNumber().empty())
     return name_on_card_;  // No CC number, return name only.
 
   base::string16 obfuscated_cc_number = ObfuscatedNumber();
   if (!expiration_month_ || !expiration_year_)
     return obfuscated_cc_number;  // No expiration date set.
 
   // TODO(georgey): Internationalize date.
   base::string16 formatted_date(ExpirationMonthAsString());
   formatted_date.append(base::ASCIIToUTF16("/"));
   formatted_date.append(Expiration4DigitYearAsString());
@@ skipping 19 matching lines @@
   converted = base::StringToInt(year_month[0], &num);
   DCHECK(converted);
   SetExpirationYear(num);
   converted = base::StringToInt(year_month[1], &num);
   DCHECK(converted);
   SetExpirationMonth(num);
 }
 
 base::string16 CreditCard::ObfuscatedNumber() const {
   // If the number is shorter than four digits, there's no need to obfuscate it.
-  if (number_.size() < 4)
-    return number_;
+  if (this->GetNumber().size() < 4)
+    return this->GetNumber();
 
-  base::string16 number = StripSeparators(number_);
+  base::string16 number = this->GetNumber();
 
   // Avoid making very long obfuscated numbers.
   size_t obfuscated_digits = std::min(kMaxObfuscationSize, number.size() - 4);
   base::string16 result(obfuscated_digits, kCreditCardObfuscationSymbol);
   return result.append(LastFourDigits());
 }
 
 base::string16 CreditCard::LastFourDigits() const {
   static const size_t kNumLastDigits = 4;
 
-  base::string16 number = StripSeparators(number_);
+  base::string16 number = this->GetNumber();
   if (number.size() < kNumLastDigits)
     return base::string16();
 
   return number.substr(number.size() - kNumLastDigits, kNumLastDigits);
 }
 
 base::string16 CreditCard::TypeForDisplay() const {
   return CreditCard::TypeForDisplay(type_);
 }
 
 base::string16 CreditCard::TypeAndLastFourDigits() const {
   base::string16 type = TypeForDisplay();
   // TODO(estade): type may be empty, we probably want to return
   // "Card - 1234" or something in that case.
 
   base::string16 digits = LastFourDigits();
   if (digits.empty())
     return type;
 
   // TODO(estade): i18n.
   return type + base::ASCIIToUTF16(" - ") + digits;
 }
 
 void CreditCard::operator=(const CreditCard& credit_card) {
   if (this == &credit_card)
     return;
 
-  number_ = credit_card.number_;
+  number_part1_ = credit_card.number_part1_;
+  number_part2_ = credit_card.number_part2_;
+  number_part3_ = credit_card.number_part3_;
+  number_part4_ = credit_card.number_part4_;
   name_on_card_ = credit_card.name_on_card_;
   type_ = credit_card.type_;
   expiration_month_ = credit_card.expiration_month_;
   expiration_year_ = credit_card.expiration_year_;
 
   set_guid(credit_card.guid());
   set_origin(credit_card.origin());
 }
 
 bool CreditCard::UpdateFromImportedCard(const CreditCard& imported_card,
@@ skipping 54 matching lines @@
   return !operator==(credit_card);
 }
 
 bool CreditCard::IsEmpty(const std::string& app_locale) const {
   ServerFieldTypeSet types;
   GetNonEmptyTypes(app_locale, &types);
   return types.empty();
 }
 
 bool CreditCard::IsComplete() const {
-  return
-      autofill::IsValidCreditCardNumber(number_) &&
-      expiration_month_ != 0 &&
-      expiration_year_ != 0;
+  return autofill::IsValidCreditCardNumber(this->GetNumber()) &&
+         expiration_month_ != 0 && expiration_year_ != 0;
 }
 
 bool CreditCard::IsValid() const {
-  return autofill::IsValidCreditCardNumber(number_) &&
+  return autofill::IsValidCreditCardNumber(this->GetNumber()) &&
          autofill::IsValidCreditCardExpirationDate(
              expiration_year_, expiration_month_, base::Time::Now());
 }
 
 void CreditCard::GetSupportedTypes(ServerFieldTypeSet* supported_types) const {
   supported_types->insert(CREDIT_CARD_NAME);
   supported_types->insert(CREDIT_CARD_NUMBER);
+  supported_types->insert(CREDIT_CARD_NUMBER_PART1);
+  supported_types->insert(CREDIT_CARD_NUMBER_PART2);
+  supported_types->insert(CREDIT_CARD_NUMBER_PART3);
+  supported_types->insert(CREDIT_CARD_NUMBER_PART4);
   supported_types->insert(CREDIT_CARD_TYPE);
   supported_types->insert(CREDIT_CARD_EXP_MONTH);
   supported_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
   supported_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
 }
 
 base::string16 CreditCard::ExpirationMonthAsString() const {
   if (expiration_month_ == 0)
@@ skipping 32 matching lines @@
 }
 
 void CreditCard::SetExpirationYearFromString(const base::string16& text) {
   int year;
   if (!ConvertYear(text, &year))
     return;
 
   SetExpirationYear(year);
 }
 
-void CreditCard::SetNumber(const base::string16& number) {
-  number_ = number;
-  type_ = GetCreditCardType(StripSeparators(number_));
+void CreditCard::SetNumber(const base::string16& number, const Part& part) {
+  base::string16 card_number = StripSeparators(number);
+  switch (part) {
+    case autofill::CreditCard::first_part:
+      number_part1_ = card_number;
+      type_ = GetCreditCardType(number_part1_);
+      break;
+
+    case autofill::CreditCard::second_part:
+      number_part2_ = card_number;
+      break;
+
+    case autofill::CreditCard::third_part:
+      number_part3_ = card_number;
+      break;
+
+    case autofill::CreditCard::last_part:
+      number_part4_ = card_number;
+      break;
+
+    default: {
+      static const size_t kNumDigits = 4;
+      size_t card_number_length = card_number.size();
+      number_part1_ = base::string16();
+      number_part2_ = base::string16();
+      number_part3_ = base::string16();
+      number_part4_ = base::string16();
+      type_ = "";
+
+      if (card_number_length)
+        number_part1_ =
+            card_number.substr(0, std::min(kNumDigits, card_number_length));
+
+      if (card_number_length > kNumDigits)
+        number_part2_ = card_number.substr(
+            kNumDigits, std::min(kNumDigits, card_number_length - kNumDigits));
+
+      if (card_number_length > 2 * kNumDigits)
+        number_part3_ = card_number.substr(
+            2 * kNumDigits,
+            std::min(kNumDigits, card_number_length - 2 * kNumDigits));
+
+      if (card_number_length > 3 * kNumDigits)
+        number_part4_ = card_number.substr(3 * kNumDigits,
+                                           card_number_length - 3 * kNumDigits);
+
+      type_ = GetCreditCardType(card_number);
+    }
+  }
 }
 
 void CreditCard::SetExpirationMonth(int expiration_month) {
   if (expiration_month < 0 || expiration_month > 12)
     return;
 
   expiration_month_ = expiration_month;
 }
 
 void CreditCard::SetExpirationYear(int expiration_year) {
   if (expiration_year != 0 &&
       (expiration_year < 2006 || expiration_year > 10000)) {
     return;
   }
 
   expiration_year_ = expiration_year;
 }
 
+base::string16 CreditCard::GetNumber() const {
+  base::string16 number = number_part1_;
+  number += number_part2_;
+  number += number_part3_;
+  number += number_part4_;
+  return number;
+}
+
 // So we can compare CreditCards with EXPECT_EQ().
 std::ostream& operator<<(std::ostream& os, const CreditCard& credit_card) {
   return os
-      << base::UTF16ToUTF8(credit_card.Label())
-      << " "
-      << credit_card.guid()
-      << " "
-      << credit_card.origin()
-      << " "
-      << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NAME))
-      << " "
-      << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_TYPE))
-      << " "
-      << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NUMBER))
-      << " "
-      << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_EXP_MONTH))
-      << " "
-      << base::UTF16ToUTF8(
-             credit_card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
+         << base::UTF16ToUTF8(credit_card.Label()) << " " << credit_card.guid()
+         << " " << credit_card.origin() << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NAME)) << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_TYPE)) << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NUMBER)) << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NUMBER_PART1))
+         << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NUMBER_PART2))
+         << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NUMBER_PART3))
+         << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_NUMBER_PART4))
+         << " "
+         << base::UTF16ToUTF8(credit_card.GetRawInfo(CREDIT_CARD_EXP_MONTH))
+         << " " << base::UTF16ToUTF8(
+                       credit_card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 }
 
 // These values must match the values in WebKitPlatformSupportImpl in
 // webkit/glue. We send these strings to WebKit, which then asks
 // WebKitPlatformSupportImpl to load the image data.
 const char* const kAmericanExpressCard = "americanExpressCC";
 const char* const kDinersCard = "dinersCC";
 const char* const kDiscoverCard = "discoverCC";
 const char* const kGenericCard = "genericCC";
 const char* const kJCBCard = "jcbCC";
 const char* const kMasterCard = "masterCardCC";
 const char* const kUnionPay = "unionPayCC";
 const char* const kVisaCard = "visaCC";
 
 }  // namespace autofill