[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.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/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/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);