[Autofill] Improve support for various credit card expiration dates.

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 <stdint.h>
 
 #include <algorithm>
@@ skipping 17 matching lines @@
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/autofill_l10n_util.h"
 #include "components/autofill/core/common/autofill_regexes.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/components_scaled_resources.h"
 #include "grit/components_strings.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "third_party/icu/source/i18n/unicode/dtfmtsym.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using base::ASCIIToUTF16;
+
 namespace autofill {
 
 const base::char16 kMidlineEllipsis[] = { 0x22ef, 0 };
 
 namespace {
 
 const base::char16 kCreditCardObfuscationSymbol = '*';
 const base::char16 kNonBreakingSpace[] = { 0x00a0, 0 };
 
 bool ConvertYear(const base::string16& year, int* num) {
@@ skipping 63 matching lines @@
 
 CreditCard::CreditCard(const CreditCard& credit_card) : CreditCard() {
   operator=(credit_card);
 }
 
 CreditCard::~CreditCard() {}
 
 // static
 const base::string16 CreditCard::StripSeparators(const base::string16& number) {
   base::string16 stripped;
-  base::RemoveChars(number, base::ASCIIToUTF16("- "), &stripped);
+  base::RemoveChars(number, ASCIIToUTF16("- "), &stripped);
   return stripped;
 }
 
 // static
 base::string16 CreditCard::TypeForDisplay(const std::string& type) {
   if (kGenericCard == type)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_GENERIC);
   if (kAmericanExpressCard == type)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_AMEX_SHORT);
 
@@ skipping 151 matching lines @@
     case CREDIT_CARD_EXP_2_DIGIT_YEAR:
       return Expiration2DigitYearAsString();
 
     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
       return Expiration4DigitYearAsString();
 
     case CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR: {
       base::string16 month = ExpirationMonthAsString();
       base::string16 year = Expiration2DigitYearAsString();
       if (!month.empty() && !year.empty())
-        return month + base::ASCIIToUTF16("/") + year;
+        return month + ASCIIToUTF16("/") + year;
       return base::string16();
     }
 
     case CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR: {
       base::string16 month = ExpirationMonthAsString();
       base::string16 year = Expiration4DigitYearAsString();
       if (!month.empty() && !year.empty())
-        return month + base::ASCIIToUTF16("/") + year;
+        return month + ASCIIToUTF16("/") + year;
       return base::string16();
     }
 
     case CREDIT_CARD_TYPE:
       return TypeForFill();
 
     case CREDIT_CARD_NUMBER:
       return number_;
 
     case CREDIT_CARD_VERIFICATION_CODE:
@@ skipping 12 matching lines @@
   switch (type) {
     case CREDIT_CARD_NAME_FULL:
       name_on_card_ = value;
       break;
 
     case CREDIT_CARD_EXP_MONTH:
       SetExpirationMonthFromString(value, std::string());
       break;
 
     case CREDIT_CARD_EXP_2_DIGIT_YEAR:
-      // This is a read-only attribute.
+      SetExpirationYearFromString(value);
       break;
 
     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
       SetExpirationYearFromString(value);
       break;
 
     case CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR:
-      // This is a read-only attribute.
+      SetExpirationDateFromString(value);
       break;
 
     case CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR:
-      // This is a read-only attribute.
+      SetExpirationDateFromString(value);
       break;
 
     case CREDIT_CARD_TYPE:
       // 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);
@@ skipping 67 matching lines @@
   // No CC number, return name only.
   if (number().empty())
     return std::make_pair(name_on_card_, base::string16());
 
   base::string16 obfuscated_cc_number = TypeAndLastFourDigits();
   // No expiration date set.
   if (!expiration_month_ || !expiration_year_)
     return std::make_pair(obfuscated_cc_number, base::string16());
 
   base::string16 formatted_date(ExpirationMonthAsString());
-  formatted_date.append(base::ASCIIToUTF16("/"));
+  formatted_date.append(ASCIIToUTF16("/"));
   formatted_date.append(Expiration4DigitYearAsString());
 
   base::string16 separator =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR);
   return std::make_pair(obfuscated_cc_number, separator + formatted_date);
 }
 
 void CreditCard::SetInfoForMonthInputType(const base::string16& value) {
   // Check if |text| is "yyyy-mm" format first, and check normal month format.
   if (!MatchesPattern(value, base::UTF8ToUTF16("^[0-9]{4}-[0-9]{1,2}$")))
     return;
 
   std::vector<base::StringPiece16> year_month = base::SplitStringPiece(
-      value, base::ASCIIToUTF16("-"),
-      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      value, ASCIIToUTF16("-"), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(2u, year_month.size());
   int num = 0;
   bool converted = false;
   converted = base::StringToInt(year_month[0], &num);
   DCHECK(converted);
   SetExpirationYear(num);
   converted = base::StringToInt(year_month[1], &num);
   DCHECK(converted);
   SetExpirationMonth(num);
 }
 
 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))
+  // If |expiration_year| is beyond this millenium, or more than 2 digits but
+  // before the current millenium (e.g. "545", "1995"), return. What is left are
+  // values like "45" or "2018".
+  if (expiration_year > 2999 ||
+      (expiration_year > 99 && expiration_year < 2000))
     return;
+
+  // Will normalize 2-digit years to the 4-digit version.
+  if (expiration_year > 0 && expiration_year < 100) {
+    base::Time::Exploded now_exploded;
+    base::Time::Now().LocalExplode(&now_exploded);
+    expiration_year += (now_exploded.year / 100) * 100;
+  }
+
   expiration_year_ = expiration_year;
 }
 
 base::string16 CreditCard::LastFourDigits() const {
   static const size_t kNumLastDigits = 4;
 
   base::string16 number = StripSeparators(number_);
   if (number.size() <= kNumLastDigits)
     return number;
 
@@ skipping 184 matching lines @@
 }
 
 base::string16 CreditCard::ExpirationMonthAsString() const {
   if (expiration_month_ == 0)
     return base::string16();
 
   base::string16 month = base::IntToString16(expiration_month_);
   if (expiration_month_ >= 10)
     return month;
 
-  base::string16 zero = base::ASCIIToUTF16("0");
+  base::string16 zero = ASCIIToUTF16("0");
   zero.append(month);
   return zero;
 }
 
 base::string16 CreditCard::TypeForFill() const {
   return ::autofill::TypeForFill(type_);
 }
 
 base::string16 CreditCard::Expiration4DigitYearAsString() const {
   if (expiration_year_ == 0)
@@ skipping 23 matching lines @@
 }
 
 void CreditCard::SetExpirationYearFromString(const base::string16& text) {
   int year;
   if (!ConvertYear(text, &year))
     return;
 
   SetExpirationYear(year);
 }
 
+void CreditCard::SetExpirationDateFromString(const base::string16& text) {
+  // Check that |text| fits the supported patterns: mmyy, mmyyyy, m-yy,
+  // mm-yy, m-yyyy and mm-yyyy. Note that myy and myyyy matched by this pattern
+  // but are not supported (ambiguous). Separators: -, / and |.
+  if (!MatchesPattern(text, base::UTF8ToUTF16("^[0-9]{1,2}[-/|]?[0-9]{2,4}$")))
+    return;
+
+  base::string16 month;
+  base::string16 year;
+
+  // Check for a separator.
+  base::string16 found_separator;
+  const std::vector<const base::string16> kSeparators{
+      ASCIIToUTF16("-"), ASCIIToUTF16("/"), ASCIIToUTF16("|")};
+  for (const base::string16& separator : kSeparators) {
+    if (text.find(separator) != base::string16::npos)
+      found_separator = separator;

[Justin Donnelly, 2016/07/08 17:45:22]

break? Obviously not a performance issue but as I read this code my brain can't
help but wonder why it's not there. :)

[sebsg, 2016/07/08 17:48:31]

I noticed it too, took me a while to parse the loop even though the break
wouldn't change much effectively :P Thanks for pointing it out, I forgot about
it.

[Mathieu, 2016/07/08 18:32:57]

Done.

[Mathieu, 2016/07/08 18:32:57]

Done.

+  }
+
+  if (!found_separator.empty()) {
+    std::vector<base::string16> month_year = base::SplitString(
+        text, found_separator, base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    DCHECK_EQ(2u, month_year.size());
+    month = month_year[0];
+    year = month_year[1];
+  } else if (text.size() % 2 == 0) {
+    // There is no separator, the format is either mmyy or mmyyyy.

[sebsg, 2016/07/08 17:23:15]

optional nit: If there is no separator, the supported formats are mmyy and
mmyyyy.

[Mathieu, 2016/07/08 18:32:57]

Done.

+    month = text.substr(0, 2);
+    year = text.substr(2);
+  } else {
+    // Odd number of digits with no separator is too ambiguous.
+    return;
+  }
+
+  int num = 0;
+  bool converted = false;
+  converted = base::StringToInt(month, &num);
+  DCHECK(converted);
+  SetExpirationMonth(num);
+  converted = base::StringToInt(year, &num);
+  DCHECK(converted);
+  SetExpirationYear(num);
+}
+
 void CreditCard::SetNumber(const base::string16& number) {
   number_ = number;
 
   // Set the type based on the card number, but only for full numbers, not
   // when we have masked cards from the server (last 4 digits).
   if (record_type_ != MASKED_SERVER_CARD)
     type_ = GetCreditCardType(StripSeparators(number_));
 }
 
 void CreditCard::RecordAndLogUse() {
@@ skipping 32 matching lines @@
     if (compare.StringsEqual(icu_month, month)) {
       *num = i + 1;  // Adjust from 0-indexed to 1-indexed.
       return true;
     }
   }
 
   months = date_format_symbols.getShortMonths(num_months);
   // Some abbreviations have . at the end (e.g., "janv." in French). We don't
   // care about matching that.
   base::string16 trimmed_month;
-  base::TrimString(month, base::ASCIIToUTF16("."), &trimmed_month);
+  base::TrimString(month, ASCIIToUTF16("."), &trimmed_month);
   for (int32_t i = 0; i < num_months; ++i) {
     base::string16 icu_month(months[i].getBuffer(), months[i].length());
-    base::TrimString(icu_month, base::ASCIIToUTF16("."), &icu_month);
+    base::TrimString(icu_month, ASCIIToUTF16("."), &icu_month);
     if (compare.StringsEqual(icu_month, trimmed_month)) {
       *num = i + 1;  // Adjust from 0-indexed to 1-indexed.
       return true;
     }
   }
 
   return false;
 }
 
 bool CreditCard::IsExpired(const base::Time& current_time) const {
@@ skipping 28 matching lines @@
 const char kAmericanExpressCard[] = "americanExpressCC";
 const char kDinersCard[] = "dinersCC";
 const char kDiscoverCard[] = "discoverCC";
 const char kGenericCard[] = "genericCC";
 const char kJCBCard[] = "jcbCC";
 const char kMasterCard[] = "masterCardCC";
 const char kUnionPay[] = "unionPayCC";
 const char kVisaCard[] = "visaCC";
 
 }  // namespace autofill