1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "components/autofill/core/browser/credit_card_field.h" 6 7 #include <stddef.h> 8 9 #include "base/logging.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/strings/string16.h" 12 #include "base/strings/string_util.h" 13 #include "base/strings/utf_string_conversions.h" 14 #include "components/autofill/core/browser/autofill_field.h" 15 #include "components/autofill/core/browser/autofill_regex_constants.h" 16 #include "components/autofill/core/browser/autofill_scanner.h" 17 #include "components/autofill/core/browser/field_types.h" 18 #include "ui/base/l10n/l10n_util.h" 19 20 namespace autofill { 21 22 // static 23 FormField* CreditCardField::Parse(AutofillScanner* scanner) { 24 if (scanner->IsEnd()) 25 return NULL; 26 27 scoped_ptr<CreditCardField> credit_card_field(new CreditCardField); 28 size_t saved_cursor = scanner->SaveCursor(); 29 30 // Credit card fields can appear in many different orders. 31 // We loop until no more credit card related fields are found, see |break| at 32 // bottom of the loop. 33 for (int fields = 0; !scanner->IsEnd(); ++fields) { 34 // Ignore gift card fields. 35 if (ParseField(scanner, UTF8ToUTF16(autofill::kGiftCardRe), NULL)) 36 break; 37 38 // Sometimes the cardholder field is just labeled "name". Unfortunately this 39 // is a dangerously generic word to search for, since it will often match a 40 // name (not cardholder name) field before or after credit card fields. So 41 // we search for "name" only when we've already parsed at least one other 42 // credit card field and haven't yet parsed the expiration date (which 43 // usually appears at the end). 44 if (credit_card_field->cardholder_ == NULL) { 45 base::string16 name_pattern; 46 if (fields == 0 || credit_card_field->expiration_month_) { 47 // at beginning or end 48 name_pattern = UTF8ToUTF16(autofill::kNameOnCardRe); 49 } else { 50 name_pattern = UTF8ToUTF16(autofill::kNameOnCardContextualRe); 51 } 52 53 if (ParseField(scanner, name_pattern, &credit_card_field->cardholder_)) 54 continue; 55 56 // As a hard-coded hack for Expedia's billing pages (expedia_checkout.html 57 // and ExpediaBilling.html in our test suite), recognize separate fields 58 // for the cardholder's first and last name if they have the labels "cfnm" 59 // and "clnm". 60 scanner->SaveCursor(); 61 const AutofillField* first; 62 if (ParseField(scanner, ASCIIToUTF16("^cfnm"), &first) && 63 ParseField(scanner, ASCIIToUTF16("^clnm"), 64 &credit_card_field->cardholder_last_)) { 65 credit_card_field->cardholder_ = first; 66 continue; 67 } 68 scanner->Rewind(); 69 } 70 71 // Check for a credit card type (Visa, MasterCard, etc.) field. 72 base::string16 type_pattern = UTF8ToUTF16(autofill::kCardTypeRe); 73 if (!credit_card_field->type_ && 74 ParseFieldSpecifics(scanner, type_pattern, 75 MATCH_DEFAULT | MATCH_SELECT, 76 &credit_card_field->type_)) { 77 continue; 78 } 79 80 // We look for a card security code before we look for a credit 81 // card number and match the general term "number". The security code 82 // has a plethora of names; we've seen "verification #", 83 // "verification number", "card identification number" and others listed 84 // in the |pattern| below. 85 base::string16 pattern = UTF8ToUTF16(autofill::kCardCvcRe); 86 if (!credit_card_field->verification_ && 87 ParseField(scanner, pattern, &credit_card_field->verification_)) { 88 continue; 89 } 90 91 pattern = UTF8ToUTF16(autofill::kCardNumberRe); 92 if (!credit_card_field->number_ && 93 ParseField(scanner, pattern, &credit_card_field->number_)) { 94 continue; 95 } 96 97 if (LowerCaseEqualsASCII(scanner->Cursor()->form_control_type, "month")) { 98 credit_card_field->expiration_month_ = scanner->Cursor(); 99 scanner->Advance(); 100 } else { 101 // First try to parse split month/year expiration fields. 102 scanner->SaveCursor(); 103 pattern = UTF8ToUTF16(autofill::kExpirationMonthRe); 104 if (!credit_card_field->expiration_month_ && 105 ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT | MATCH_SELECT, 106 &credit_card_field->expiration_month_)) { 107 pattern = UTF8ToUTF16(autofill::kExpirationYearRe); 108 if (ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT | MATCH_SELECT, 109 &credit_card_field->expiration_year_)) { 110 continue; 111 } 112 } 113 114 // If that fails, try to parse a combined expiration field. 115 if (!credit_card_field->expiration_date_) { 116 // Look for a 2-digit year first. 117 scanner->Rewind(); 118 pattern = UTF8ToUTF16(autofill::kExpirationDate2DigitYearRe); 119 // We allow <select> fields, because they're used e.g. on qvc.com. 120 if (ParseFieldSpecifics(scanner, pattern, 121 MATCH_LABEL | MATCH_VALUE | MATCH_TEXT | 122 MATCH_SELECT, 123 &credit_card_field->expiration_date_)) { 124 credit_card_field->is_two_digit_year_ = true; 125 continue; 126 } 127 128 pattern = UTF8ToUTF16(autofill::kExpirationDateRe); 129 if (ParseFieldSpecifics(scanner, pattern, 130 MATCH_LABEL | MATCH_VALUE | MATCH_TEXT | 131 MATCH_SELECT, 132 &credit_card_field->expiration_date_)) { 133 continue; 134 } 135 } 136 137 if (credit_card_field->expiration_month_ && 138 !credit_card_field->expiration_year_ && 139 !credit_card_field->expiration_date_) { 140 // Parsed a month but couldn't parse a year; give up. 141 scanner->RewindTo(saved_cursor); 142 return NULL; 143 } 144 } 145 146 // Some pages (e.g. ExpediaBilling.html) have a "card description" 147 // field; we parse this field but ignore it. 148 // We also ignore any other fields within a credit card block that 149 // start with "card", under the assumption that they are related to 150 // the credit card section being processed but are uninteresting to us. 151 if (ParseField(scanner, UTF8ToUTF16(autofill::kCardIgnoredRe), NULL)) 152 continue; 153 154 break; 155 } 156 157 // Some pages have a billing address field after the cardholder name field. 158 // For that case, allow only just the cardholder name field. The remaining 159 // CC fields will be picked up in a following CreditCardField. 160 if (credit_card_field->cardholder_) 161 return credit_card_field.release(); 162 163 // On some pages, the user selects a card type using radio buttons 164 // (e.g. test page Apple Store Billing.html). We can't handle that yet, 165 // so we treat the card type as optional for now. 166 // The existence of a number or cvc in combination with expiration date is 167 // a strong enough signal that this is a credit card. It is possible that 168 // the number and name were parsed in a separate part of the form. So if 169 // the cvc and date were found independently they are returned. 170 if ((credit_card_field->number_ || credit_card_field->verification_) && 171 (credit_card_field->expiration_date_ || 172 (credit_card_field->expiration_month_ && 173 (credit_card_field->expiration_year_ || 174 (LowerCaseEqualsASCII( 175 credit_card_field->expiration_month_->form_control_type, 176 "month")))))) { 177 return credit_card_field.release(); 178 } 179 180 scanner->RewindTo(saved_cursor); 181 return NULL; 182 } 183 184 CreditCardField::CreditCardField() 185 : cardholder_(NULL), 186 cardholder_last_(NULL), 187 type_(NULL), 188 number_(NULL), 189 verification_(NULL), 190 expiration_month_(NULL), 191 expiration_year_(NULL), 192 expiration_date_(NULL), 193 is_two_digit_year_(false) { 194 } 195 196 bool CreditCardField::ClassifyField(ServerFieldTypeMap* map) const { 197 bool ok = AddClassification(number_, CREDIT_CARD_NUMBER, map); 198 ok = ok && AddClassification(type_, CREDIT_CARD_TYPE, map); 199 ok = ok && AddClassification(verification_, CREDIT_CARD_VERIFICATION_CODE, 200 map); 201 202 // If the heuristics detected first and last name in separate fields, 203 // then ignore both fields. Putting them into separate fields is probably 204 // wrong, because the credit card can also contain a middle name or middle 205 // initial. 206 if (cardholder_last_ == NULL) 207 ok = ok && AddClassification(cardholder_, CREDIT_CARD_NAME, map); 208 209 if (expiration_date_) { 210 if (is_two_digit_year_) { 211 ok = ok && AddClassification(expiration_date_, 212 CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR, map); 213 } else { 214 ok = ok && AddClassification(expiration_date_, 215 CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR, map); 216 } 217 } else { 218 ok = ok && AddClassification(expiration_month_, CREDIT_CARD_EXP_MONTH, map); 219 if (is_two_digit_year_) { 220 ok = ok && AddClassification(expiration_year_, 221 CREDIT_CARD_EXP_2_DIGIT_YEAR, 222 map); 223 } else { 224 ok = ok && AddClassification(expiration_year_, 225 CREDIT_CARD_EXP_4_DIGIT_YEAR, 226 map); 227 } 228 } 229 230 return ok; 231 } 232 233 } // namespace autofill 234