autofill: switch autofill_regexes to RE2 library

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"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"

[Ilya Sherman, 2015/11/26 02:25:09]

Is this include still needed?

[tfarina, 2015/11/26 14:22:27]

Done.

 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_regex_constants.h"
 #include "components/autofill/core/browser/autofill_scanner.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/common/autofill_regexes.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace autofill {
 
 namespace {
 
 // Credit card numbers are at most 19 digits in length.
 // [Ref: http://en.wikipedia.org/wiki/Bank_card_number]
 const size_t kMaxValidCardNumberSize = 19;
 
 // Look for the vector |regex_needles| in |haystack|. Returns true if a
 // consecutive section of |haystack| matches |regex_needles|.
 bool FindConsecutiveStrings(const std::vector<base::string16>& regex_needles,

[Ilya Sherman, 2015/11/26 02:25:09]

Please make this type also be std::string

[tfarina, 2015/11/26 14:22:27]

Done.

                             const std::vector<base::string16>& haystack) {
   if (regex_needles.empty() ||
       haystack.empty() ||
       (haystack.size() < regex_needles.size()))
     return false;
 
   for (size_t i = 0; i < haystack.size() - regex_needles.size() + 1; ++i) {
     for (size_t j = 0; j < regex_needles.size(); ++j) {
-      if (!MatchesPattern(haystack[i + j], regex_needles[j]))
+      if (!MatchesPattern(haystack[i + j], base::UTF16ToUTF8(regex_needles[j])))
         break;
 
       if (j == regex_needles.size() - 1)
         return true;
     }
   }
   return false;
 }
 
 // Returns true if a field that has |max_length| can fit the data for a field of
@@ skipping 30 matching lines @@
 
   // Credit card fields can appear in many different orders.
   // We loop until no more credit card related fields are found, see |break| at
   // the bottom of the loop.
   for (int fields = 0; !scanner->IsEnd(); ++fields) {
     // Ignore gift card fields.
     if (IsGiftCardField(scanner))
       break;
 
     if (!credit_card_field->cardholder_) {
-      if (ParseField(scanner,
-                     base::UTF8ToUTF16(kNameOnCardRe),
-                     &credit_card_field->cardholder_)) {
+      if (ParseField(scanner, 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),
+      if (fields > 0 && !credit_card_field->expiration_month_ &&
+          ParseField(scanner, kNameOnCardContextualRe,
                      &credit_card_field->cardholder_)) {
         continue;
       }
     }
 
     // Check for a credit card type (Visa, MasterCard, etc.) field.
     // All CC type fields encountered so far have been of type select.
     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;
     if (!credit_card_field->verification_ &&
         ParseFieldSpecifics(scanner,
-                            base::UTF8ToUTF16(kCardCvcRe),
+                            kCardCvcRe,
                             kMatchNumAndTel | MATCH_PASSWORD,
                             &credit_card_field->verification_)) {
       continue;
     }
 
     AutofillField* current_number_field;
     if (ParseFieldSpecifics(scanner,
-                            base::UTF8ToUTF16(kCardNumberRe),
+                            kCardNumberRe,
                             kMatchNumAndTel,
                             &current_number_field)) {
       // Avoid autofilling any credit card number field having very low or high
       // |start_index| on the HTML form.
       size_t start_index = 0;
       if (!credit_card_field->numbers_.empty()) {
         size_t last_number_field_size =
             credit_card_field->numbers_.back()->credit_card_number_offset() +
             credit_card_field->numbers_.back()->max_length;
 
@@ skipping 56 matching lines @@
     return false;
 
   AutofillField* field = scanner->Cursor();
   if (!MatchesFormControlType(field->form_control_type, MATCH_SELECT))
     return false;
 
   if (field->option_values.size() < 12 || field->option_values.size() > 13)
     return false;
 
   // Filter out years.
-  const base::string16 kNumericalYearRe =
-      base::ASCIIToUTF16("[1-9][0-9][0-9][0-9]");
+  const char kNumericalYearRe[] = "[1-9][0-9][0-9][0-9]";
   for (const auto& value : field->option_values) {
     if (MatchesPattern(value, kNumericalYearRe))
       return false;
   }
   for (const auto& value : field->option_contents) {
     if (MatchesPattern(value, kNumericalYearRe))
       return false;
   }
 
   // Look for numerical months.
-  const base::string16 kNumericalMonthRe = base::ASCIIToUTF16("12");
+  const char kNumericalMonthRe[] = "12";
   if (MatchesPattern(field->option_values.back(), kNumericalMonthRe) ||
       MatchesPattern(field->option_contents.back(), kNumericalMonthRe)) {
     return true;
   }
 
   // Maybe do more matches here. e.g. look for (translated) December.
 
   // Unsure? Return false.
   return false;
 }
@@ skipping 38 matching lines @@
              *field, l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_MASTERCARD),
              nullptr);
 }
 
 // static
 bool CreditCardField::IsGiftCardField(AutofillScanner* scanner) {
   if (scanner->IsEnd())
     return false;
 
   size_t saved_cursor = scanner->SaveCursor();
-  if (ParseField(scanner, base::UTF8ToUTF16(kDebitCardRe), nullptr)) {
+  if (ParseField(scanner, kDebitCardRe, nullptr)) {
     scanner->RewindTo(saved_cursor);
     return false;
   }
-  if (ParseField(scanner, base::UTF8ToUTF16(kDebitGiftCardRe), nullptr)) {
+  if (ParseField(scanner, kDebitGiftCardRe, nullptr)) {
     scanner->RewindTo(saved_cursor);
     return false;
   }
 
-  return ParseField(scanner, base::UTF8ToUTF16(kGiftCardRe), nullptr);
+  return ParseField(scanner, kGiftCardRe, nullptr);
 }
 
 CreditCardField::CreditCardField()
     : cardholder_(nullptr),
       cardholder_last_(nullptr),
       type_(nullptr),
       verification_(nullptr),
       expiration_month_(nullptr),
       expiration_year_(nullptr),
       expiration_date_(nullptr),
@@ skipping 61 matching lines @@
       return true;
     }
     expiration_month_ = nullptr;
     expiration_year_ = nullptr;
   }
 
   // If that fails, do a general regex search.
   scanner->RewindTo(month_year_saved_cursor);
   const int kMatchTelAndSelect = MATCH_DEFAULT | MATCH_TELEPHONE | MATCH_SELECT;
   if (ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationMonthRe),
+                          kExpirationMonthRe,
                           kMatchTelAndSelect,
                           &expiration_month_) &&
       ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationYearRe),
+                          kExpirationYearRe,
                           kMatchTelAndSelect,
                           &expiration_year_)) {
     return true;
   }
 
   // If that fails, look for just MM/YY(YY).
   scanner->RewindTo(month_year_saved_cursor);
   if (ParseFieldSpecifics(scanner,
-                          base::ASCIIToUTF16("^mm$"),
+                          "^mm$",
                           kMatchTelAndSelect,
                           &expiration_month_) &&
       ParseFieldSpecifics(scanner,
-                          base::ASCIIToUTF16("^(yy|yyyy)$"),
+                          "^(yy|yyyy)$",
                           kMatchTelAndSelect,
                           &expiration_year_)) {
     return true;
   }
 
   // If that fails, try to parse a combined expiration field.
   // We allow <select> fields, because they're used e.g. on qvc.com.
   scanner->RewindTo(month_year_saved_cursor);
 
   // Bail out if the field cannot fit a 2-digit year expiration date.
   const int current_field_max_length = scanner->Cursor()->max_length;
   if (!FieldCanFitDataForFieldType(current_field_max_length,
                                    CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR)) {
     return false;
   }
 
   // Try to look for a 2-digit year expiration date.
   if (ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationDate2DigitYearRe),
+                          kExpirationDate2DigitYearRe,
                           kMatchTelAndSelect,
                           &expiration_date_)) {
     exp_year_type_ = CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR;
     expiration_month_ = nullptr;
     return true;
   }
 
   // Try to look for a generic expiration date field. (2 or 4 digit year)
   if (ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationDateRe),
+                          kExpirationDateRe,
                           kMatchTelAndSelect,
                           &expiration_date_)) {
     // If such a field exists, but it cannot fit a 4-digit year expiration
     // date, then the likely possibility is that it is a 2-digit year expiration
     // date.
     if (!FieldCanFitDataForFieldType(current_field_max_length,
                                      CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR)) {
       exp_year_type_ = CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR;
     }
     expiration_month_ = nullptr;
     return true;
   }
 
   // Try to look for a 4-digit year expiration date.
   if (FieldCanFitDataForFieldType(current_field_max_length,
                                   CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR) &&
       ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationDate4DigitYearRe),
+                          kExpirationDate4DigitYearRe,
                           kMatchTelAndSelect,
                           &expiration_date_)) {
     expiration_month_ = nullptr;
     return true;
   }
 
   return false;
 }
 
 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