Autofill: Better recognize credit card type fields.

components/autofill/core/browser/credit_card_field.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_field.h"
 
 #include <stddef.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 42 matching lines @@
 // static
 scoped_ptr<FormField> CreditCardField::Parse(AutofillScanner* scanner) {
   if (scanner->IsEnd())
     return nullptr;
 
   scoped_ptr<CreditCardField> credit_card_field(new CreditCardField);
   size_t saved_cursor = scanner->SaveCursor();
 
   // Credit card fields can appear in many different orders.
   // We loop until no more credit card related fields are found, see |break| at
-  // bottom of the loop.
+  // the bottom of the loop.
   for (int fields = 0; !scanner->IsEnd(); ++fields) {
     // Ignore gift card fields.
     if (ParseField(scanner, base::UTF8ToUTF16(kGiftCardRe), nullptr))
       break;
 
     if (!credit_card_field->cardholder_) {
       if (ParseField(scanner,
                      base::UTF8ToUTF16(kNameOnCardRe),
                      &credit_card_field->cardholder_)) {
         continue;
       }
 
       // Sometimes the cardholder field is just labeled "name". Unfortunately
       // this is a dangerously generic word to search for, since it will often
       // match a name (not cardholder name) field before or after credit card
       // fields. So we search for "name" only when we've already parsed at
       // least one other credit card field and haven't yet parsed the
       // expiration date (which usually appears at the end).
       if (fields > 0 &&
           !credit_card_field->expiration_month_ &&
           ParseField(scanner,
                      base::UTF8ToUTF16(kNameOnCardContextualRe),
                      &credit_card_field->cardholder_)) {
         continue;
       }
     }
 
     // Check for a credit card type (Visa, MasterCard, etc.) field.
-    if (!credit_card_field->type_ &&
-        ParseFieldSpecifics(scanner,
-                            base::UTF8ToUTF16(kCardTypeRe),
-                            MATCH_DEFAULT | MATCH_SELECT,

[Evan Stade, 2015/03/25 21:25:51]

so we'll no longer fill text inputs?

[Lei Zhang, 2015/03/25 22:18:48]

Correct. None of the websites in our heuristics tests make the user type in the
type of their card into text input.

[Evan Stade, 2015/03/25 22:23:08]

k, seems fine. Can you put a comment to that effect? I believe that is unique to
this datatype.

[Lei Zhang, 2015/03/25 22:39:03]

Done.

-                            &credit_card_field->type_)) {
+    if (!credit_card_field->type_ && LikelyCardTypeSelectField(scanner)) {
+      credit_card_field->type_ = scanner->Cursor();
+      scanner->Advance();
       continue;
     }
 
     // We look for a card security code before we look for a credit card number
     // and match the general term "number". The security code has a plethora of
     // names; we've seen "verification #", "verification number", "card
     // identification number", and others listed in the regex pattern used
     // below.
     // Note: Some sites use type="tel" or type="number" for numerical inputs.
     const int kMatchNumAndTel = MATCH_DEFAULT | MATCH_NUMBER | MATCH_TELEPHONE;
@@ skipping 36 matching lines @@
       continue;
 
     if (credit_card_field->expiration_month_ &&
         !credit_card_field->expiration_year_ &&
         !credit_card_field->expiration_date_) {
       // Parsed a month but couldn't parse a year; give up.
       scanner->RewindTo(saved_cursor);
       return nullptr;
     }
 
-    // Some pages (e.g. ExpediaBilling.html) have a "card description"
-    // field; we parse this field but ignore it.
-    // We also ignore any other fields within a credit card block that
-    // start with "card", under the assumption that they are related to
-    // the credit card section being processed but are uninteresting to us.
-    if (ParseField(scanner, base::UTF8ToUTF16(kCardIgnoredRe), nullptr))
-      continue;
-
     break;
   }
 
   // Some pages have a billing address field after the cardholder name field.
   // For that case, allow only just the cardholder name field.  The remaining
   // CC fields will be picked up in a following CreditCardField.
   if (credit_card_field->cardholder_)
     return credit_card_field.Pass();
 
   // On some pages, the user selects a card type using radio buttons
@@ skipping 69 matching lines @@
   std::vector<base::string16> years_to_check;
   for (int year = time_exploded.year;
        year < time_exploded.year + kYearsToMatch;
        ++year) {
     years_to_check.push_back(base::IntToString16(year));
   }
   return (FindConsecutiveStrings(years_to_check, field->option_values) ||
           FindConsecutiveStrings(years_to_check, field->option_contents));
 }
 
+// static
+bool CreditCardField::LikelyCardTypeSelectField(AutofillScanner* scanner) {
+  if (scanner->IsEnd())
+    return false;
+
+  AutofillField* field = scanner->Cursor();
+  if (!MatchesFormControlType(field->form_control_type, MATCH_SELECT))
+    return false;
+
+  // VISA and Mastercard are oftentimes branded as is in other countries, so
+  // translations are probably not needed.
+  const char* const kCardBrands[] = {

[Evan Stade, 2015/03/25 21:25:51]

nit: this is a little over-engineered imo. You can just call
FindValueInCreditTypeSelectControl twice.

Also, instead of new constants, how about CreditCard::TypeForFill

[Lei Zhang, 2015/03/25 22:18:48]

I'm just going to use IDS_AUTOFILL_CC_FOO since TypeForFill() is in an anonymous
namespace within credit_card.cc.

[Evan Stade, 2015/03/25 22:23:08]

sgtm

+    "visa",
+    "mastercard",
+  };
+  for (const char* brand : kCardBrands) {
+    if (AutofillField::FindValueInCreditTypeSelectControl(
+        *field, base::ASCIIToUTF16(brand), nullptr)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 CreditCardField::CreditCardField()
     : cardholder_(nullptr),
       cardholder_last_(nullptr),
       type_(nullptr),
       verification_(nullptr),
       expiration_month_(nullptr),
       expiration_year_(nullptr),
       expiration_date_(nullptr),
       exp_year_type_(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR) {
 }
@@ skipping 114 matching lines @@
 
 ServerFieldType CreditCardField::GetExpirationYearType() const {
   return (expiration_date_
               ? exp_year_type_
               : ((expiration_year_ && expiration_year_->max_length == 2)
                      ? CREDIT_CARD_EXP_2_DIGIT_YEAR
                      : CREDIT_CARD_EXP_4_DIGIT_YEAR));
 }
 
 }  // namespace autofill