[Autofill] Cleanups in the field type parser files

Rename variables containing the parsing patterns.
Removes auto& statements in favor of explicit type declarations.
Removes spurious comments.

Change-Id: I9ca9523a5039952ab7de9dbeaa45f0baaa476d68
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2535770
Commit-Queue: Matthias Körber <koerber@google.com>
Reviewed-by: Christoph Schwering <schwering@google.com>
Cr-Commit-Position: refs/heads/master@{#827993}

components/autofill/core/browser/form_parsing/address_field.cc

@@ -59,21 +59,25 @@ std::unique_ptr<FormField> AddressField::Parse(
   base::string16 attention_ignored = UTF8ToUTF16(kAttentionIgnoredRe);
   base::string16 region_ignored = UTF8ToUTF16(kRegionIgnoredRe);
 
-  // In JSON : EMAIL_ADDRESS
-  auto& patterns_email = PatternProvider::GetInstance().GetMatchPatterns(
-      "EMAIL_ADDRESS", page_language);
-  // In JSON : ADDRESS_LOOKUP
-  auto& patterns_al = PatternProvider::GetInstance().GetMatchPatterns(
-      "ADDRESS_LOOKUP", page_language);
-  // In JSON : ADDRESS_NAME_IGNORED
-  auto& patterns_ni = PatternProvider::GetInstance().GetMatchPatterns(
-      "ADDRESS_NAME_IGNORED", page_language);
-  // In JSON : ATTENTION_IGNORED
-  auto& patterns_ai = PatternProvider::GetInstance().GetMatchPatterns(
-      "ATTENTION_IGNORED", page_language);
-  // In JSON : REGION_IGNORED
-  auto& patterns_ri = PatternProvider::GetInstance().GetMatchPatterns(
-      "REGION_IGNORED", page_language);
+  const std::vector<MatchingPattern>& email_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("EMAIL_ADDRESS",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& address_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ADDRESS_LOOKUP",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& address_ignore_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ADDRESS_NAME_IGNORED",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& attention_ignore_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ATTENTION_IGNORED",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& region_ignore_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("REGION_IGNORED",
+                                                      page_language);
 
   // Allow address fields to appear in any order.
   size_t begin_trailing_non_labeled_fields = 0;
@@ -81,16 +85,17 @@ std::unique_ptr<FormField> AddressField::Parse(
   while (!scanner->IsEnd()) {
     const size_t cursor = scanner->SaveCursor();
     // Ignore "Address Lookup" field. http://crbug.com/427622
-    if (ParseField(scanner, base::UTF8ToUTF16(kAddressLookupRe), patterns_al,
-                   nullptr, {log_manager, "kAddressLookupRe"}) ||
+    if (ParseField(scanner, base::UTF8ToUTF16(kAddressLookupRe),
+                   address_patterns, nullptr,
+                   {log_manager, "kAddressLookupRe"}) ||
         ParseField(scanner, base::UTF8ToUTF16(kAddressNameIgnoredRe),
-                   patterns_ni, nullptr,
+                   address_ignore_patterns, nullptr,
                    {log_manager, "kAddressNameIgnoreRe"})) {
       continue;
       // Ignore email addresses.
     } else if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kEmailRe),
                                    MATCH_DEFAULT | MATCH_TEXT_AREA,
-                                   patterns_email, nullptr,
+                                   email_patterns, nullptr,
                                    {log_manager, "kEmailRe"},
                                    {.augment_types = MATCH_TEXT_AREA})) {
       continue;
@@ -100,10 +105,10 @@ std::unique_ptr<FormField> AddressField::Parse(
                address_field->ParseCompany(scanner, page_language)) {
       has_trailing_non_labeled_fields = false;
       continue;
-    } else if (ParseField(scanner, attention_ignored, patterns_ai, nullptr,
-                          {log_manager, "kAttentionIgnoredRe"}) ||
-               ParseField(scanner, region_ignored, patterns_ri, nullptr,
-                          {log_manager, "kRegionIgnoredRe"})) {
+    } else if (ParseField(scanner, attention_ignored, attention_ignore_patterns,
+                          nullptr, {log_manager, "kAttentionIgnoredRe"}) ||
+               ParseField(scanner, region_ignored, region_ignore_patterns,
+                          nullptr, {log_manager, "kRegionIgnoredRe"})) {
       // We ignore the following:
       // * Attention.
       // * Province/Region/Other.
@@ -187,12 +192,12 @@ bool AddressField::ParseCompany(AutofillScanner* scanner,
                                 const LanguageCode& page_language) {
   if (company_)
     return false;
-  // In JSON : COMPANY
-  auto& patterns_c =
+
+  const std::vector<MatchingPattern>& company_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("COMPANY", page_language);
 
-  return ParseField(scanner, UTF8ToUTF16(kCompanyRe), patterns_c, &company_,
-                    {log_manager_, "kCompanyRe"});
+  return ParseField(scanner, UTF8ToUTF16(kCompanyRe), company_patterns,
+                    &company_, {log_manager_, "kCompanyRe"});
 }
 
 bool AddressField::ParseAddressFieldSequence(
@@ -209,23 +214,25 @@ bool AddressField::ParseAddressFieldSequence(
   }
 
   const size_t cursor_position = scanner->CursorPosition();
-  // In JSON : ---- maybe ADDRESS_LINE1(2,3)
-  auto& patterns_s = PatternProvider::GetInstance().GetMatchPatterns(
-      ADDRESS_HOME_STREET_NAME, page_language);
-  // In JSON : ----
-  auto& patterns_h = PatternProvider::GetInstance().GetMatchPatterns(
-      ADDRESS_HOME_HOUSE_NUMBER, page_language);
+
+  const std::vector<MatchingPattern>& street_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(ADDRESS_HOME_STREET_NAME,
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& house_number_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(ADDRESS_HOME_HOUSE_NUMBER,
+                                                      page_language);
 
   while (!scanner->IsEnd()) {
     if (!street_name_ &&
         ParseFieldSpecifics(scanner, UTF8ToUTF16(kStreetNameRe), MATCH_DEFAULT,
-                            patterns_s, &street_name_,
+                            street_name_patterns, &street_name_,
                             {log_manager_, "kStreetNameRe"})) {
       continue;
     }
     if (!house_number_ &&
         ParseFieldSpecifics(scanner, UTF8ToUTF16(kHouseNumberRe), MATCH_DEFAULT,
-                            patterns_h, &house_number_,
+                            house_number_patterns, &house_number_,
                             {log_manager_, "kHouseNumberRe"})) {
       continue;
     }
@@ -269,22 +276,25 @@ bool AddressField::ParseAddressLines(AutofillScanner* scanner,
 
   base::string16 pattern = UTF8ToUTF16(kAddressLine1Re);
   base::string16 label_pattern = UTF8ToUTF16(kAddressLine1LabelRe);
-  // In JSON : ADDRESS_LINE_1
-  auto& patterns_l1 = PatternProvider::GetInstance().GetMatchPatterns(
-      "ADDRESS_LINE_1", page_language);
 
-  if (!ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT, patterns_l1,
-                           &address1_, {log_manager_, "kAddressLine1Re"}) &&
+  const std::vector<MatchingPattern>& address_line1_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ADDRESS_LINE_1",
+                                                      page_language);
+
+  if (!ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT,
+                           address_line1_patterns, &address1_,
+                           {log_manager_, "kAddressLine1Re"}) &&
       !ParseFieldSpecifics(scanner, label_pattern, MATCH_LABEL | MATCH_TEXT,
-                           patterns_l1, &address1_,
+                           address_line1_patterns, &address1_,
                            {log_manager_, "kAddressLine1LabelRe"}) &&
       !ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT | MATCH_TEXT_AREA,
-                           patterns_l1, &street_address_,
+                           address_line1_patterns, &street_address_,
                            {log_manager_, "kAddressLine1Re"},
                            {.augment_types = MATCH_TEXT_AREA}) &&
-      !ParseFieldSpecifics(
-          scanner, label_pattern, MATCH_LABEL | MATCH_TEXT_AREA, patterns_l1,
-          &street_address_, {log_manager_, "kAddressLine1LabelRe"},
+      !ParseFieldSpecifics(scanner, label_pattern,
+                           MATCH_LABEL | MATCH_TEXT_AREA,
+                           address_line1_patterns, &street_address_,
+                           {log_manager_, "kAddressLine1LabelRe"},
                            {.augment_types = MATCH_TEXT_AREA}))
     return false;
 
@@ -296,32 +306,29 @@ bool AddressField::ParseAddressLines(AutofillScanner* scanner,
   // discussion on https://codereview.chromium.org/741493003/
   pattern = UTF8ToUTF16(kAddressLine2Re);
   label_pattern = UTF8ToUTF16(kAddressLine2LabelRe);
-  // auto& patternsL2 = PatternProvider::GetInstance().GetMatchPatterns(
-  //     "ADDRESS_HOME_LINE2", page_language);
-  // auto& patternsSA = PatternProvider::GetInstance().GetMatchPatterns(
-  //  "ADDRESS_HOME_STREET_ADDRESS", page_language);
-
-  // In JSON : ADDRESS_LINE_2
-  auto& patterns_l2 = PatternProvider::GetInstance().GetMatchPatterns(
-      "ADDRESS_LINE_2", page_language);
-  // In JSON : ADDRESS_LINE_EXTRA
-  auto& patterns_le = PatternProvider::GetInstance().GetMatchPatterns(
-      "ADDRESS_LINE_EXTRA", page_language);
-
-  if (!ParseField(scanner, pattern, patterns_l2, &address2_,
+
+  const std::vector<MatchingPattern>& address_line2_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ADDRESS_LINE_2",
+                                                      page_language);
+
+  if (!ParseField(scanner, pattern, address_line2_patterns, &address2_,
                   {log_manager_, "kAddressLine2Re"}) &&
       !ParseFieldSpecifics(scanner, label_pattern, MATCH_LABEL | MATCH_TEXT,
-                           patterns_l2, &address2_,
+                           address_line2_patterns, &address2_,
                            {log_manager_, "kAddressLine2LabelRe"}))
     return true;
 
+  const std::vector<MatchingPattern>& address_line_extra_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ADDRESS_LINE_EXTRA",
+                                                      page_language);
+
   // Optionally parse address line 3. This uses the same label regexp as
   // address 2 above.
   pattern = UTF8ToUTF16(kAddressLinesExtraRe);
-  if (!ParseField(scanner, pattern, patterns_le, &address3_,
+  if (!ParseField(scanner, pattern, address_line_extra_patterns, &address3_,
                   {log_manager_, "kAddressLinesExtraRe"}) &&
       !ParseFieldSpecifics(scanner, label_pattern, MATCH_LABEL | MATCH_TEXT,
-                           patterns_l2, &address3_,
+                           address_line2_patterns, &address3_,
                            {log_manager_, "kAddressLine2LabelRe"}))
     return true;
 
@@ -331,7 +338,7 @@ bool AddressField::ParseAddressLines(AutofillScanner* scanner,
   // Since these are rare, don't bother considering unlabeled lines as extra
   // address lines.
   pattern = UTF8ToUTF16(kAddressLinesExtraRe);
-  while (ParseField(scanner, pattern, patterns_le, nullptr,
+  while (ParseField(scanner, pattern, address_line_extra_patterns, nullptr,
                     {log_manager_, "kAddressLinesExtraRe"})) {
     // Consumed a surplus line, try for another.
   }
@@ -343,16 +350,16 @@ bool AddressField::ParseCountry(AutofillScanner* scanner,
   if (country_)
     return false;
 
-  // In JSON : COUNTRY
-  auto& patterns_c =
+  const std::vector<MatchingPattern>& country_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("COUNTRY", page_language);
-  auto& patterns_cl = PatternProvider::GetInstance().GetMatchPatterns(
-      "COUNTRY_LOCATION", page_language);
+  const std::vector<MatchingPattern>& country_patternsl =
+      PatternProvider::GetInstance().GetMatchPatterns("COUNTRY_LOCATION",
+                                                      page_language);
 
   scanner->SaveCursor();
   if (ParseFieldSpecifics(scanner, UTF8ToUTF16(kCountryRe),
                           MATCH_DEFAULT | MATCH_SELECT | MATCH_SEARCH,
-                          patterns_c, &country_,
+                          country_patterns, &country_,
                           {log_manager_, "kCountryRe"})) {
     return true;
   }
@@ -362,7 +369,7 @@ bool AddressField::ParseCountry(AutofillScanner* scanner,
   scanner->Rewind();
   return ParseFieldSpecifics(
       scanner, UTF8ToUTF16(kCountryLocationRe),
-      MATCH_LABEL | MATCH_NAME | MATCH_SELECT | MATCH_SEARCH, patterns_cl,
+      MATCH_LABEL | MATCH_NAME | MATCH_SELECT | MATCH_SEARCH, country_patternsl,
       &country_, {log_manager_, "kCountryLocationRe"});
 }
 
@@ -371,23 +378,23 @@ bool AddressField::ParseZipCode(AutofillScanner* scanner,
   if (zip_)
     return false;
 
-  // auto& patternsZ = PatternProvider::GetInstance().GetMatchPatterns(
-  //     "ADDRESS_HOME_ZIP", page_language);
-  // In JSON : ZIP_CODE
-  auto& patterns_z = PatternProvider::GetInstance().GetMatchPatterns(
-      "ZIP_CODE", page_language);
-  // In JSON : ZIP_4
-  auto& patterns_z4 =
+  const std::vector<MatchingPattern>& zip_code_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ZIP_CODE",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& four_digit_zip_code_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("ZIP_4", page_language);
   if (!ParseFieldSpecifics(scanner, UTF8ToUTF16(kZipCodeRe), kZipCodeMatchType,
-                           patterns_z, &zip_, {log_manager_, "kZipCodeRe"})) {
+                           zip_code_patterns, &zip_,
+                           {log_manager_, "kZipCodeRe"})) {
     return false;
   }
 
   // Look for a zip+4, whose field name will also often contain
   // the substring "zip".
   ParseFieldSpecifics(scanner, UTF8ToUTF16(kZip4Re), kZipCodeMatchType,
-                      patterns_z4, &zip4_, {log_manager_, "kZip4Re"});
+                      four_digit_zip_code_patterns, &zip4_,
+                      {log_manager_, "kZip4Re"});
   return true;
 }
 
@@ -396,11 +403,10 @@ bool AddressField::ParseCity(AutofillScanner* scanner,
   if (city_)
     return false;
 
-  // In JSON : CITY
-  auto& patterns_city =
+  const std::vector<MatchingPattern>& city_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("CITY", page_language);
   return ParseFieldSpecifics(scanner, UTF8ToUTF16(kCityRe), kCityMatchType,
-                             patterns_city, &city_, {log_manager_, "kCityRe"});
+                             city_patterns, &city_, {log_manager_, "kCityRe"});
 }
 
 bool AddressField::ParseState(AutofillScanner* scanner,
@@ -408,10 +414,7 @@ bool AddressField::ParseState(AutofillScanner* scanner,
   if (state_)
     return false;
 
-  // auto& patterns = PatternProvider::GetInstance().GetMatchPatterns(
-  //     "ADDRESS_HOME_STATE", page_language);
-  // In JSON : STATE
-  auto& patterns_state =
+  const std::vector<MatchingPattern>& patterns_state =
       PatternProvider::GetInstance().GetMatchPatterns("STATE", page_language);
   return ParseFieldSpecifics(scanner, UTF8ToUTF16(kStateRe), kStateMatchType,
                              patterns_state, &state_,
@@ -537,16 +540,16 @@ AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForZipCode(
   if (zip_)
     return RESULT_MATCH_NONE;
 
-  // In JSON : ZIP_CODE
-  auto& patterns_z = PatternProvider::GetInstance().GetMatchPatterns(
-      "ZIP_CODE", page_language);
-  // In JSON :
-  auto& patterns_z4 =
+  const std::vector<MatchingPattern>& zip_code_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("ZIP_CODE",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& four_digit_zip_code_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("ZIP_4", page_language);
 
   ParseNameLabelResult result = ParseNameAndLabelSeparately(
-      scanner, UTF8ToUTF16(kZipCodeRe), kZipCodeMatchType, patterns_z, &zip_,
-      {log_manager_, "kZipCodeRe"});
+      scanner, UTF8ToUTF16(kZipCodeRe), kZipCodeMatchType, zip_code_patterns,
+      &zip_, {log_manager_, "kZipCodeRe"});
 
   if (result != RESULT_MATCH_NAME_LABEL || scanner->IsEnd())
     return result;
@@ -567,7 +570,8 @@ AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForZipCode(
     // Look for a zip+4, whose field name will also often contain
     // the substring "zip".
     ParseFieldSpecifics(scanner, UTF8ToUTF16(kZip4Re), kZipCodeMatchType,
-                        patterns_z4, &zip4_, {log_manager_, "kZip4Re"});
+                        four_digit_zip_code_patterns, &zip4_,
+                        {log_manager_, "kZip4Re"});
   }
   return result;
 }
@@ -578,11 +582,10 @@ AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForCity(
   if (city_)
     return RESULT_MATCH_NONE;
 
-  // In JSON : CITY
-  auto& patterns_city =
+  const std::vector<MatchingPattern>& city_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("CITY", page_language);
   return ParseNameAndLabelSeparately(scanner, UTF8ToUTF16(kCityRe),
-                                     kCityMatchType, patterns_city, &city_,
+                                     kCityMatchType, city_patterns, &city_,
                                      {log_manager_, "kCityRe"});
 }
 
@@ -592,8 +595,7 @@ AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForState(
   if (state_)
     return RESULT_MATCH_NONE;
 
-  // In JSON : STATE
-  auto& patterns_state =
+  const std::vector<MatchingPattern>& patterns_state =
       PatternProvider::GetInstance().GetMatchPatterns("STATE", page_language);
   return ParseNameAndLabelSeparately(scanner, UTF8ToUTF16(kStateRe),
                                      kStateMatchType, patterns_state, &state_,
@@ -606,15 +608,16 @@ AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForCountry(
   if (country_)
     return RESULT_MATCH_NONE;
 
-  // In JSON : COUNTRY
-  auto& patterns_c =
+  const std::vector<MatchingPattern>& country_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("COUNTRY", page_language);
-  auto& patterns_cl = PatternProvider::GetInstance().GetMatchPatterns(
-      "COUNTRY_LOCATION", page_language);
+
+  const std::vector<MatchingPattern>& country_location_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("COUNTRY_LOCATION",
+                                                      page_language);
 
   ParseNameLabelResult country_result = ParseNameAndLabelSeparately(
       scanner, UTF8ToUTF16(kCountryRe),
-      MATCH_DEFAULT | MATCH_SELECT | MATCH_SEARCH, patterns_c, &country_,
+      MATCH_DEFAULT | MATCH_SELECT | MATCH_SEARCH, country_patterns, &country_,
       {log_manager_, "kCountryRe"});
   if (country_result != RESULT_MATCH_NONE)
     return country_result;
@@ -623,8 +626,9 @@ AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForCountry(
   // "location". However, this only makes sense for select tags.
   return ParseNameAndLabelSeparately(
       scanner, UTF8ToUTF16(kCountryLocationRe),
-      MATCH_LABEL | MATCH_NAME | MATCH_SELECT | MATCH_SEARCH, patterns_cl,
-      &country_, {log_manager_, "kCountryLocationRe"});
+      MATCH_LABEL | MATCH_NAME | MATCH_SELECT | MATCH_SEARCH,
+      country_location_patterns, &country_,
+      {log_manager_, "kCountryLocationRe"});
 }
 
 }  // namespace autofill

components/autofill/core/browser/form_parsing/address_field.h

@@ -88,15 +88,6 @@ class AddressField : public FormField {
   // RESULT_MATCH_NAME_LABEL, then |scanner| advances and |match| is filled if
   // it is non-NULL. Otherwise |scanner| does not advance and |match| does not
   // change.
-  // ParseNameLabelResult ParseNameAndLabelSeparately(
-  //     AutofillScanner* scanner,
-  //     const base::string16& pattern,
-  //     int match_type,
-  //     AutofillField** match,
-  //     const RegExLogging& logging);
-
-  // New version of function above using new structure MatchingPattern and
-  // PatternProvider.
   ParseNameLabelResult ParseNameAndLabelSeparately(
       AutofillScanner* scanner,
       const base::string16& pattern,

components/autofill/core/browser/form_parsing/credit_card_field.cc

@@ -92,16 +92,20 @@ std::unique_ptr<FormField> CreditCardField::Parse(
   size_t saved_cursor = scanner->SaveCursor();
   int nb_unknown_fields = 0;
 
-  auto& patterns = PatternProvider::GetInstance().GetMatchPatterns(
-      "NAME_ON_CARD", page_language);
-  // In JSON : NAME_ON_CARD_CONTEXTUAL
-  auto& patterns_cont = PatternProvider::GetInstance().GetMatchPatterns(
-      "NAME_ON_CARD_CONTEXTUAL", page_language);
-  // In JSON : LAST_NAME
-  auto& patterns_nl = PatternProvider::GetInstance().GetMatchPatterns(
-      "LAST_NAME", page_language);
-  // In JSON : CARD_CVC
-  auto& patterns_cvc = PatternProvider::GetInstance().GetMatchPatterns(
+  const std::vector<MatchingPattern>& name_on_card_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("NAME_ON_CARD",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& name_on_card_contextual_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("NAME_ON_CARD_CONTEXTUAL",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& last_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("LAST_NAME",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& cvc_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(
           CREDIT_CARD_VERIFICATION_CODE, page_language);
 
   // Credit card fields can appear in many different orders.
@@ -113,8 +117,8 @@ std::unique_ptr<FormField> CreditCardField::Parse(
       break;
 
     if (!credit_card_field->cardholder_) {
-      if (ParseField(scanner, base::UTF8ToUTF16(kNameOnCardRe), patterns,
-                     &credit_card_field->cardholder_,
+      if (ParseField(scanner, base::UTF8ToUTF16(kNameOnCardRe),
+                     name_on_card_patterns, &credit_card_field->cardholder_,
                      {log_manager, "kNameOnCardRe"})) {
         continue;
       }
@@ -128,7 +132,8 @@ std::unique_ptr<FormField> CreditCardField::Parse(
 
       if (fields > 0 && !credit_card_field->expiration_month_ &&
           ParseField(scanner, base::UTF8ToUTF16(kNameOnCardContextualRe),
-                     patterns_cont, &credit_card_field->cardholder_,
+                     name_on_card_contextual_patterns,
+                     &credit_card_field->cardholder_,
                      {log_manager, "kNameOnCardContextualRe"})) {
         continue;
       }
@@ -138,8 +143,8 @@ std::unique_ptr<FormField> CreditCardField::Parse(
       // and haven't yet parsed the expiration date (which usually appears at
       // the end).
       if (!credit_card_field->expiration_month_ &&
-          ParseField(scanner, base::UTF8ToUTF16(kLastNameRe), patterns_nl,
-                     &credit_card_field->cardholder_last_,
+          ParseField(scanner, base::UTF8ToUTF16(kLastNameRe),
+                     last_name_patterns, &credit_card_field->cardholder_last_,
                      {log_manager, "kLastNameRe"})) {
         continue;
       }
@@ -166,7 +171,7 @@ std::unique_ptr<FormField> CreditCardField::Parse(
 
     if (!credit_card_field->verification_ &&
         ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kCardCvcRe),
-                            kMatchNumTelAndPwd, patterns_cvc,
+                            kMatchNumTelAndPwd, cvc_patterns,
                             &credit_card_field->verification_,
                             {log_manager, "kCardCvcRe"})) {
       // A couple of sites have multiple verification codes right after another.
@@ -182,7 +187,7 @@ std::unique_ptr<FormField> CreditCardField::Parse(
         scanner->RewindTo(scanner->SaveCursor() - 2);
 
         if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kCardCvcRe),
-                                kMatchNumTelAndPwd, patterns_cvc,
+                                kMatchNumTelAndPwd, cvc_patterns,
                                 &credit_card_field->verification_,
                                 {log_manager, "kCardCvcRe"})) {
           // Reset the current cvv (The verification parse overwrote it).
@@ -205,8 +210,9 @@ std::unique_ptr<FormField> CreditCardField::Parse(
     // TODO(crbug.com/591816): Make sure parsing cc-numbers of type password
     // doesn't have bad side effects.
     AutofillField* current_number_field;
-    auto& patterns = PatternProvider::GetInstance().GetMatchPatterns(
-        CREDIT_CARD_NUMBER, page_language);
+    const std::vector<MatchingPattern>& patterns =
+        PatternProvider::GetInstance().GetMatchPatterns(CREDIT_CARD_NUMBER,
+                                                        page_language);
     if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kCardNumberRe),
                             kMatchNumTelAndPwd, patterns, &current_number_field,
                             {log_manager, "kCardNumberRe"})) {
@@ -352,11 +358,10 @@ bool CreditCardField::LikelyCardYearSelectField(
   }
 
   // Another way to eliminate days - filter out 'day' fields.
-  // In JSON : DAY (only in JSON)
-  auto& patterns_day =
+  const std::vector<MatchingPattern>& day_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("DAY", page_language);
   if (FormField::ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kDayRe),
-                                     MATCH_DEFAULT | MATCH_SELECT, patterns_day,
+                                     MATCH_DEFAULT | MATCH_SELECT, day_patterns,
                                      nullptr, {log_manager, "kDayRe"})) {
     return false;
   }
@@ -422,31 +427,33 @@ bool CreditCardField::IsGiftCardField(AutofillScanner* scanner,
       MATCH_DEFAULT | MATCH_NUMBER | MATCH_TELEPHONE | MATCH_SEARCH;
   size_t saved_cursor = scanner->SaveCursor();
 
-  // In JSON : DEBIT_CARD (only in JSON)
-  auto& patterns_d = PatternProvider::GetInstance().GetMatchPatterns(
-      "DEBIT_CARD", page_language);
-  // In JSON : DEBIT_GIFT_CARD (only in JSON)
-  auto& patterns_dg = PatternProvider::GetInstance().GetMatchPatterns(
-      "DEBIT_GIFT_CARD", page_language);
-  // In JSON : GIFT_CARD (only in JSON)
-  auto& patterns_g = PatternProvider::GetInstance().GetMatchPatterns(
-      "GIFT_CARD", page_language);
+  const std::vector<MatchingPattern>& debit_cards_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("DEBIT_CARD",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& debit_gift_card_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("DEBIT_GIFT_CARD",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& gift_card_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("GIFT_CARD",
+                                                      page_language);
 
   if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kDebitCardRe),
-                          kMatchFieldTypes, patterns_d, nullptr,
+                          kMatchFieldTypes, debit_cards_patterns, nullptr,
                           {log_manager, "kDebitCardRe"})) {
     scanner->RewindTo(saved_cursor);
     return false;
   }
   if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kDebitGiftCardRe),
-                          kMatchFieldTypes, patterns_dg, nullptr,
+                          kMatchFieldTypes, debit_gift_card_patterns, nullptr,
                           {log_manager, "kDebitGiftCardRe"})) {
     scanner->RewindTo(saved_cursor);
     return false;
   }
 
   return ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kGiftCardRe),
-                             kMatchFieldTypes, patterns_g, nullptr,
+                             kMatchFieldTypes, gift_card_patterns, nullptr,
                              {log_manager, "kGiftCardRe"});
 }
 
@@ -538,22 +545,28 @@ bool CreditCardField::ParseExpirationDate(AutofillScanner* scanner,
   const int kMatchCCType = MATCH_DEFAULT | MATCH_NUMBER | MATCH_TELEPHONE |
                            MATCH_SELECT | MATCH_SEARCH;
 
-  // In JSON : CARD_EXP_MONTH
-  auto& patterns_m = PatternProvider::GetInstance().GetMatchPatterns(
-      CREDIT_CARD_EXP_MONTH, page_language);
-  // In JSON : CARD_EXP_YEAR
-  auto& patterns_y = PatternProvider::GetInstance().GetMatchPatterns(
-      "CREDIT_CARD_EXP_YEAR", page_language);
-  auto& patterns_mm = PatternProvider::GetInstance().GetMatchPatterns(
+  const std::vector<MatchingPattern>& cc_exp_month_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(CREDIT_CARD_EXP_MONTH,
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& cc_exp_year_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("CREDIT_CARD_EXP_YEAR",
+                                                      page_language);
+
+  const std::vector<MatchingPattern>& cc_exp_month_before_year_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(
           "CREDIT_CARD_EXP_MONTH_BEFORE_YEAR", page_language);
-  auto& patterns_yy = PatternProvider::GetInstance().GetMatchPatterns(
+
+  const std::vector<MatchingPattern>& cc_exp_year_after_month_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(
           "CREDIT_CARD_EXP_YEAR_AFTER_MONTH", page_language);
 
   if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kExpirationMonthRe),
-                          kMatchCCType, patterns_m, &expiration_month_,
+                          kMatchCCType, cc_exp_month_patterns,
+                          &expiration_month_,
                           {log_manager_, "kExpirationMonthRe"}) &&
       ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kExpirationYearRe),
-                          kMatchCCType, patterns_y, &expiration_year_,
+                          kMatchCCType, cc_exp_year_patterns, &expiration_year_,
                           {log_manager_, "kExpirationYearRe"})) {
     return true;
   }
@@ -561,11 +574,11 @@ bool CreditCardField::ParseExpirationDate(AutofillScanner* scanner,
   // If that fails, look for just MM and/or YY(YY).
   scanner->RewindTo(month_year_saved_cursor);
   if (ParseFieldSpecifics(scanner, base::ASCIIToUTF16("^mm$"), kMatchCCType,
-                          patterns_mm, &expiration_month_,
+                          cc_exp_month_before_year_patterns, &expiration_month_,
                           {log_manager_, "^mm$"}) &&
       ParseFieldSpecifics(scanner, base::ASCIIToUTF16("^(yy|yyyy)$"),
-                          kMatchCCType, patterns_yy, &expiration_year_,
-                          {log_manager_, "^(yy|yyyy)$"})) {
+                          kMatchCCType, cc_exp_year_after_month_patterns,
+                          &expiration_year_, {log_manager_, "^(yy|yyyy)$"})) {
     return true;
   }
 
@@ -580,12 +593,12 @@ bool CreditCardField::ParseExpirationDate(AutofillScanner* scanner,
     return false;
 
   // Try to look for a 2-digit year expiration date.
-  // In JSON : CARD_EXP_DATE_2_DIGIT_YEAR
-  auto& patterns_2dy = PatternProvider::GetInstance().GetMatchPatterns(
+  const std::vector<MatchingPattern>& cc_exp_2digit_year_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(
           CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR, page_language);
-  if (ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationDate2DigitYearRe),
-                          kMatchCCType, patterns_2dy, &expiration_date_,
+  if (ParseFieldSpecifics(
+          scanner, base::UTF8ToUTF16(kExpirationDate2DigitYearRe), kMatchCCType,
+          cc_exp_2digit_year_patterns, &expiration_date_,
           {log_manager_, "kExpirationDate2DigitYearRe"})) {
     exp_year_type_ = CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR;
     expiration_month_ = nullptr;
@@ -593,10 +606,11 @@ bool CreditCardField::ParseExpirationDate(AutofillScanner* scanner,
   }
 
   // Try to look for a generic expiration date field. (2 or 4 digit year)
-  auto& patterns_exp_d = PatternProvider::GetInstance().GetMatchPatterns(
-      "CREDIT_CARD_EXP_DATE", page_language);
+  const std::vector<MatchingPattern>& cc_exp_date_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("CREDIT_CARD_EXP_DATE",
+                                                      page_language);
   if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kExpirationDateRe),
-                          kMatchCCType, patterns_exp_d, &expiration_date_,
+                          kMatchCCType, cc_exp_date_patterns, &expiration_date_,
                           {log_manager_, "kExpirationDateRe"})) {
     // 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
@@ -610,13 +624,14 @@ bool CreditCardField::ParseExpirationDate(AutofillScanner* scanner,
   }
 
   // Try to look for a 4-digit year expiration date.
-  auto& patterns_4dy = PatternProvider::GetInstance().GetMatchPatterns(
+  const std::vector<MatchingPattern>& cc_exp_date_4_digit_year_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(
           CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR, page_language);
   if (FieldCanFitDataForFieldType(current_field_max_length,
                                   CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR) &&
-      ParseFieldSpecifics(scanner,
-                          base::UTF8ToUTF16(kExpirationDate4DigitYearRe),
-                          kMatchCCType, patterns_4dy, &expiration_date_,
+      ParseFieldSpecifics(
+          scanner, base::UTF8ToUTF16(kExpirationDate4DigitYearRe), kMatchCCType,
+          cc_exp_date_4_digit_year_patterns, &expiration_date_,
           {log_manager_, "kExpirationDate4DigitYearRe"})) {
     expiration_month_ = nullptr;
     return true;

components/autofill/core/browser/form_parsing/email_field.cc

@@ -15,10 +15,11 @@ std::unique_ptr<FormField> EmailField::Parse(AutofillScanner* scanner,
                                              const LanguageCode& page_language,
                                              LogManager* log_manager) {
   AutofillField* field;
-  auto& patterns = PatternProvider::GetInstance().GetMatchPatterns(
-      "EMAIL_ADDRESS", page_language);
+  const std::vector<MatchingPattern>& email_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("EMAIL_ADDRESS",
+                                                      page_language);
   if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kEmailRe),
-                          MATCH_DEFAULT | MATCH_EMAIL, patterns, &field,
+                          MATCH_DEFAULT | MATCH_EMAIL, email_patterns, &field,
                           {log_manager, "kEmailRe"})) {
     return std::make_unique<EmailField>(field);
   }

components/autofill/core/browser/form_parsing/form_field.h

@@ -103,6 +103,7 @@ class FormField {
                                   int match_field_input_types,
                                   AutofillField** match,
                                   const RegExLogging& logging = {});
+
   struct MatchFieldBitmasks {
     int restrict_attributes = ~0;
     int augment_types = 0;

components/autofill/core/browser/form_parsing/name_field.cc

@@ -130,11 +130,12 @@ std::unique_ptr<FullNameField> FullNameField::Parse(
     LogManager* log_manager) {
   // Exclude e.g. "username" or "nickname" fields.
   scanner->SaveCursor();
-  auto& patterns_ni = PatternProvider::GetInstance().GetMatchPatterns(
-      "NAME_IGNORED", page_language);
+  const std::vector<MatchingPattern>& name_ignored_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("NAME_IGNORED",
+                                                      page_language);
   bool should_ignore =
-      ParseField(scanner, UTF8ToUTF16(kNameIgnoredRe), patterns_ni, nullptr,
-                 {log_manager, "kNameIgnoredRe"});
+      ParseField(scanner, UTF8ToUTF16(kNameIgnoredRe), name_ignored_patterns,
+                 nullptr, {log_manager, "kNameIgnoredRe"});
   scanner->Rewind();
   if (should_ignore)
     return nullptr;
@@ -143,10 +144,11 @@ std::unique_ptr<FullNameField> FullNameField::Parse(
   // for example, Travelocity_Edit travel profile.html contains a field
   // "Travel Profile Name".
   AutofillField* field = nullptr;
-  // In JSON : FULL_NAME (closest vatiant)
-  auto& patterns_name = PatternProvider::GetInstance().GetMatchPatterns(
-      "FULL_NAME", page_language);
-  if (ParseField(scanner, UTF8ToUTF16(kNameRe), patterns_name, &field,
+
+  const std::vector<MatchingPattern>& name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("FULL_NAME",
+                                                      page_language);
+  if (ParseField(scanner, UTF8ToUTF16(kNameRe), name_patterns, &field,
                  {log_manager, "kNameRe"}))
     return std::make_unique<FullNameField>(field);
 
@@ -178,18 +180,24 @@ FirstTwoLastNamesField::ParseComponentNames(AutofillScanner* scanner,
   std::unique_ptr<FirstTwoLastNamesField> v(new FirstTwoLastNamesField);
   scanner->SaveCursor();
 
-  auto& patterns_hp = PatternProvider::GetInstance().GetMatchPatterns(
-      "HONORIFIC_PREFIX", page_language);
-  auto& patterns_ni = PatternProvider::GetInstance().GetMatchPatterns(
-      "NAME_IGNORED", page_language);
-  auto& patterns_fn = PatternProvider::GetInstance().GetMatchPatterns(
-      "FIRST_NAME", page_language);
-  auto& patterns_mn = PatternProvider::GetInstance().GetMatchPatterns(
-      "MIDDLE_NAME", page_language);
-  auto& patterns_ln1 = PatternProvider::GetInstance().GetMatchPatterns(
-      "LAST_NAME_FIRST", page_language);
-  auto& patterns_ln2 = PatternProvider::GetInstance().GetMatchPatterns(
-      "LAST_NAME_SECOND", page_language);
+  const std::vector<MatchingPattern>& honorific_prefix_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("HONORIFIC_PREFIX",
+                                                      page_language);
+  const std::vector<MatchingPattern>& name_ignored_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("NAME_IGNORED",
+                                                      page_language);
+  const std::vector<MatchingPattern>& first_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("FIRST_NAME",
+                                                      page_language);
+  const std::vector<MatchingPattern>& middle_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("MIDDLE_NAME",
+                                                      page_language);
+  const std::vector<MatchingPattern>& first_last_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("LAST_NAME_FIRST",
+                                                      page_language);
+  const std::vector<MatchingPattern>& second_last_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("LAST_NAME_SECOND",
+                                                      page_language);
 
   // Allow name fields to appear in any order.
   while (!scanner->IsEnd()) {
@@ -199,8 +207,8 @@ FirstTwoLastNamesField::ParseComponentNames(AutofillScanner* scanner,
     // TODO(crbug.com/1098943): Remove check once feature is launched or
     // removed.
     if (!v->honorific_prefix_ &&
-        ParseField(scanner, UTF8ToUTF16(kHonorificPrefixRe), patterns_hp,
-                   &v->honorific_prefix_,
+        ParseField(scanner, UTF8ToUTF16(kHonorificPrefixRe),
+                   honorific_prefix_patterns, &v->honorific_prefix_,
                    {log_manager, "kHonorificPrefixRe"})) {
       continue;
     }
@@ -208,32 +216,33 @@ FirstTwoLastNamesField::ParseComponentNames(AutofillScanner* scanner,
     // Skip over any unrelated fields, e.g. "username" or "nickname".
     if (ParseFieldSpecifics(scanner, UTF8ToUTF16(kNameIgnoredRe),
                             MATCH_DEFAULT | MATCH_SELECT | MATCH_SEARCH,
-                            patterns_ni, nullptr,
+                            name_ignored_patterns, nullptr,
                             {log_manager, "kNameIgnoredRe"})) {
       continue;
     }
 
     if (!v->first_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kFirstNameRe), patterns_fn,
+        ParseField(scanner, UTF8ToUTF16(kFirstNameRe), first_name_patterns,
                    &v->first_name_, {log_manager, "kFirstNameRe"})) {
       continue;
     }
 
     if (!v->middle_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kMiddleNameRe), patterns_mn,
+        ParseField(scanner, UTF8ToUTF16(kMiddleNameRe), middle_name_patterns,
                    &v->middle_name_, {log_manager, "kMiddleNameRe"})) {
       continue;
     }
 
     if (!v->first_last_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kNameLastFirstRe), patterns_ln1,
-                   &v->first_last_name_, {log_manager, "kNameLastFirstRe"})) {
+        ParseField(scanner, UTF8ToUTF16(kNameLastFirstRe),
+                   first_last_name_patterns, &v->first_last_name_,
+                   {log_manager, "kNameLastFirstRe"})) {
       continue;
     }
 
     if (!v->second_last_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kNameLastSecondRe), patterns_ln2,
-                   &v->second_last_name_,
+        ParseField(scanner, UTF8ToUTF16(kNameLastSecondRe),
+                   second_last_name_patterns, &v->second_last_name_,
                    {log_manager, "kNameLastSecondtRe"})) {
       continue;
     }
@@ -275,10 +284,11 @@ std::unique_ptr<FirstLastNameField> FirstLastNameField::ParseSpecificName(
   scanner->SaveCursor();
 
   AutofillField* next = nullptr;
-  auto& patterns_ns = PatternProvider::GetInstance().GetMatchPatterns(
-      "NAME_SPECIFIC", page_language);
+  const std::vector<MatchingPattern>& name_specific_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("NAME_SPECIFIC",
+                                                      page_language);
 
-  if (ParseField(scanner, UTF8ToUTF16(kNameSpecificRe), patterns_ns,
+  if (ParseField(scanner, UTF8ToUTF16(kNameSpecificRe), name_specific_patterns,
                  &v->first_name_, {log_manager, "kNameSpecificRe"}) &&
       ParseEmptyLabel(scanner, &next)) {
     if (ParseEmptyLabel(scanner, &v->last_name_)) {
@@ -317,18 +327,24 @@ std::unique_ptr<FirstLastNameField> FirstLastNameField::ParseComponentNames(
 
   // Allow name fields to appear in any order.
 
-  auto& patterns_hp = PatternProvider::GetInstance().GetMatchPatterns(
-      "HONORIFIC_PREFIX", page_language);
-  auto& patterns_ni = PatternProvider::GetInstance().GetMatchPatterns(
-      "NAME_IGNORED", page_language);
-  auto& patterns_fn = PatternProvider::GetInstance().GetMatchPatterns(
-      "FIRST_NAME", page_language);
-  auto& patterns_mi = PatternProvider::GetInstance().GetMatchPatterns(
-      "MIDDLE_INITIAL", page_language);
-  auto& patterns_mn = PatternProvider::GetInstance().GetMatchPatterns(
-      "MIDDLE_NAME", page_language);
-  auto& patterns_ln = PatternProvider::GetInstance().GetMatchPatterns(
-      "LAST_NAME", page_language);
+  const std::vector<MatchingPattern>& honorific_prefix_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("HONORIFIC_PREFIX",
+                                                      page_language);
+  const std::vector<MatchingPattern>& name_ignored_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("NAME_IGNORED",
+                                                      page_language);
+  const std::vector<MatchingPattern>& first_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("FIRST_NAME",
+                                                      page_language);
+  const std::vector<MatchingPattern>& middle_name_initial_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("MIDDLE_INITIAL",
+                                                      page_language);
+  const std::vector<MatchingPattern>& middle_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("MIDDLE_NAME",
+                                                      page_language);
+  const std::vector<MatchingPattern>& last_name_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("LAST_NAME",
+                                                      page_language);
 
   while (!scanner->IsEnd()) {
     // Scan for the honorific prefix before checking for unrelated fields
@@ -339,8 +355,8 @@ std::unique_ptr<FirstLastNameField> FirstLastNameField::ParseComponentNames(
     if (base::FeatureList::IsEnabled(
             features::kAutofillEnableSupportForMoreStructureInNames)) {
       if (!v->honorific_prefix_ &&
-          ParseField(scanner, UTF8ToUTF16(kHonorificPrefixRe), patterns_hp,
-                     &v->honorific_prefix_,
+          ParseField(scanner, UTF8ToUTF16(kHonorificPrefixRe),
+                     honorific_prefix_patterns, &v->honorific_prefix_,
                      {log_manager, "kHonorificPrefixRe"})) {
         continue;
       }
@@ -349,13 +365,13 @@ std::unique_ptr<FirstLastNameField> FirstLastNameField::ParseComponentNames(
     // Skip over any unrelated name fields, e.g. "username" or "nickname".
     if (ParseFieldSpecifics(scanner, UTF8ToUTF16(kNameIgnoredRe),
                             MATCH_DEFAULT | MATCH_SELECT | MATCH_SEARCH,
-                            patterns_ni, nullptr,
+                            name_ignored_patterns, nullptr,
                             {log_manager, "kNameIgnoredRe"})) {
       continue;
     }
 
     if (!v->first_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kFirstNameRe), patterns_fn,
+        ParseField(scanner, UTF8ToUTF16(kFirstNameRe), first_name_patterns,
                    &v->first_name_, {log_manager, "kFirstNameRe"})) {
       continue;
     }
@@ -366,20 +382,21 @@ std::unique_ptr<FirstLastNameField> FirstLastNameField::ParseComponentNames(
     // "txtmiddlename"); such a field probably actually represents a
     // middle initial.
     if (!v->middle_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kMiddleInitialRe), patterns_mi,
-                   &v->middle_name_, {log_manager, "kMiddleInitialRe"})) {
+        ParseField(scanner, UTF8ToUTF16(kMiddleInitialRe),
+                   middle_name_initial_patterns, &v->middle_name_,
+                   {log_manager, "kMiddleInitialRe"})) {
       v->middle_initial_ = true;
       continue;
     }
 
     if (!v->middle_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kMiddleNameRe), patterns_mn,
+        ParseField(scanner, UTF8ToUTF16(kMiddleNameRe), middle_name_patterns,
                    &v->middle_name_, {log_manager, "kMiddleNameRe"})) {
       continue;
     }
 
     if (!v->last_name_ &&
-        ParseField(scanner, UTF8ToUTF16(kLastNameRe), patterns_ln,
+        ParseField(scanner, UTF8ToUTF16(kLastNameRe), last_name_patterns,
                    &v->last_name_, {log_manager, "kLastNameRe"})) {
       continue;
     }

components/autofill/core/browser/form_parsing/phone_field.cc

@@ -420,7 +420,8 @@ const char* PhoneField::GetRegExpName(RegexType regex_id) {
   return "";
 }
 
-//
+// Returns the string representation of |phonetype_id| as it is used to key to
+// identify coressponding patterns.
 std::string PhoneField::GetJSONFieldType(RegexType phonetype_id) {
   switch (phonetype_id) {
     case REGEX_COUNTRY:
@@ -461,8 +462,9 @@ bool PhoneField::ParsePhoneField(AutofillScanner* scanner,
   if (is_country_code_field)
     match_type |= MATCH_SELECT;
 
-  auto& patterns = PatternProvider::GetInstance().GetMatchPatterns(
-      json_field_type, page_language);
+  const std::vector<MatchingPattern>& patterns =
+      PatternProvider::GetInstance().GetMatchPatterns(json_field_type,
+                                                      page_language);
 
   return ParseFieldSpecifics(scanner, base::UTF8ToUTF16(regex), match_type,
                              patterns, field, logging);

components/autofill/core/browser/form_parsing/price_field.cc

@@ -16,13 +16,13 @@ std::unique_ptr<FormField> PriceField::Parse(AutofillScanner* scanner,
                                              const LanguageCode& page_language,
                                              LogManager* log_manager) {
   AutofillField* field;
-  auto& patterns =
+  const std::vector<MatchingPattern>& price_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("PRICE", page_language);
 
   if (ParseFieldSpecifics(scanner, base::UTF8ToUTF16(kPriceRe),
                           MATCH_DEFAULT | MATCH_NUMBER | MATCH_SELECT |
                               MATCH_TEXT_AREA | MATCH_SEARCH,
-                          patterns, &field, {log_manager, kPriceRe})) {
+                          price_patterns, &field, {log_manager, kPriceRe})) {
     return std::make_unique<PriceField>(field);
   }
 

components/autofill/core/browser/form_parsing/travel_field.cc

@@ -18,27 +18,31 @@ TravelField::~TravelField() = default;
 std::unique_ptr<FormField> TravelField::Parse(AutofillScanner* scanner,
                                               const LanguageCode& page_language,
                                               LogManager* log_manager) {
-  if (!scanner || scanner->IsEnd()) {
+  if (!scanner || scanner->IsEnd())
     return nullptr;
-  }
-  auto& patternsP = PatternProvider::GetInstance().GetMatchPatterns(
-      "PASSPORT", page_language);
-  auto& patternsTO = PatternProvider::GetInstance().GetMatchPatterns(
-      "TRAVEL_ORIGIN", page_language);
-  auto& patternsTD = PatternProvider::GetInstance().GetMatchPatterns(
-      "TRAVEL_DESTINATION", page_language);
-  auto& patternsF =
+
+  const std::vector<MatchingPattern>& passport_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("PASSPORT",
+                                                      page_language);
+  const std::vector<MatchingPattern>& travel_origin_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("TRAVEL_ORIGIN",
+                                                      page_language);
+  const std::vector<MatchingPattern>& travel_destination_patterns =
+      PatternProvider::GetInstance().GetMatchPatterns("TRAVEL_DESTINATION",
+                                                      page_language);
+  const std::vector<MatchingPattern>& flight_patterns =
       PatternProvider::GetInstance().GetMatchPatterns("FLIGHT", page_language);
 
   auto travel_field = std::make_unique<TravelField>();
-  if (ParseField(scanner, base::UTF8ToUTF16(kPassportRe), patternsP,
+  if (ParseField(scanner, base::UTF8ToUTF16(kPassportRe), passport_patterns,
                  &travel_field->passport_, {log_manager, "kPassportRe"}) ||
-      ParseField(scanner, base::UTF8ToUTF16(kTravelOriginRe), patternsTO,
-                 &travel_field->origin_, {log_manager, "kTravelOriginRe"}) ||
-      ParseField(scanner, base::UTF8ToUTF16(kTravelDestinationRe), patternsTD,
-                 &travel_field->destination_,
+      ParseField(scanner, base::UTF8ToUTF16(kTravelOriginRe),
+                 travel_origin_patterns, &travel_field->origin_,
+                 {log_manager, "kTravelOriginRe"}) ||
+      ParseField(scanner, base::UTF8ToUTF16(kTravelDestinationRe),
+                 travel_destination_patterns, &travel_field->destination_,
                  {log_manager, "kTravelDestinationRe"}) ||
-      ParseField(scanner, base::UTF8ToUTF16(kFlightRe), patternsF,
+      ParseField(scanner, base::UTF8ToUTF16(kFlightRe), flight_patterns,
                  &travel_field->flight_, {log_manager, "kFlightRe"})) {
     // If any regex matches, then we found a travel field.
     return std::move(travel_field);