Autofill: Improve heuristics for city/state/zip fields.

components/autofill/core/browser/address_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/address_field.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.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"
 
 using base::UTF8ToUTF16;
 
 namespace autofill {
 
+namespace {
+
+bool SetFieldAndAdvanceCursor(AutofillScanner* scanner, AutofillField** field) {
+  *field = scanner->Cursor();
+  scanner->Advance();
+  return true;
+}
+
+}  // namespace
+
+// Some sites use type="tel" for zip fields (to get a numerical input).
+// http://crbug.com/426958
+const int AddressField::kZipCodeMatchType =
+    MATCH_DEFAULT | MATCH_TELEPHONE | MATCH_NUMBER;
+
+// Select fields are allowed here.  This occurs on top-100 site rediff.com.
+const int AddressField::kCityMatchType = MATCH_DEFAULT | MATCH_SELECT;
+
+const int AddressField::kStateMatchType = MATCH_DEFAULT | MATCH_SELECT;
+
 scoped_ptr<FormField> AddressField::Parse(AutofillScanner* scanner) {
   if (scanner->IsEnd())
     return NULL;
 
   scoped_ptr<AddressField> address_field(new AddressField);
   const AutofillField* const initial_field = scanner->Cursor();
   size_t saved_cursor = scanner->SaveCursor();
 
   base::string16 attention_ignored = UTF8ToUTF16(kAttentionIgnoredRe);
   base::string16 region_ignored = UTF8ToUTF16(kRegionIgnoredRe);
 
   // Allow address fields to appear in any order.
   size_t begin_trailing_non_labeled_fields = 0;
   bool has_trailing_non_labeled_fields = false;
   while (!scanner->IsEnd()) {
     const size_t cursor = scanner->SaveCursor();
     if (address_field->ParseAddressLines(scanner) ||
-        address_field->ParseCity(scanner) ||
-        address_field->ParseState(scanner) ||
-        address_field->ParseZipCode(scanner) ||
+        address_field->ParseCityStateZipCode(scanner) ||
         address_field->ParseCountry(scanner) ||
         address_field->ParseCompany(scanner)) {
       has_trailing_non_labeled_fields = false;
       continue;
     } else if (ParseField(scanner, attention_ignored, NULL) ||
                ParseField(scanner, region_ignored, NULL)) {
       // We ignore the following:
       // * Attention.
       // * Province/Region/Other.
       continue;
@@ skipping 156 matching lines @@
   // The occasional page (e.g. google account registration page) calls this a
   // "location". However, this only makes sense for select tags.
   scanner->Rewind();
   return ParseFieldSpecifics(scanner,
                              UTF8ToUTF16(kCountryLocationRe),
                              MATCH_LABEL | MATCH_NAME | MATCH_SELECT,
                              &country_);
 }
 
 bool AddressField::ParseZipCode(AutofillScanner* scanner) {
-  // Parse a zip code.  On some UK pages (e.g. The China Shop2.html) this
-  // is called a "post code".
   if (zip_)
     return false;
 
-  // Some sites use type="tel" for zip fields (to get a numerical input).
-  // http://crbug.com/426958
   if (!ParseFieldSpecifics(scanner,
                            UTF8ToUTF16(kZipCodeRe),
-                           MATCH_DEFAULT | MATCH_TELEPHONE,
+                           kZipCodeMatchType,
                            &zip_)) {
     return false;
   }
 
   // Look for a zip+4, whose field name will also often contain
   // the substring "zip".
-  ParseFieldSpecifics(scanner,
-                      UTF8ToUTF16(kZip4Re),
-                      MATCH_DEFAULT | MATCH_TELEPHONE,
-                      &zip4_);
+  ParseFieldSpecifics(scanner, UTF8ToUTF16(kZip4Re), kZipCodeMatchType, &zip4_);
   return true;
 }
 
 bool AddressField::ParseCity(AutofillScanner* scanner) {
-  // Parse a city name.  Some UK pages (e.g. The China Shop2.html) use
-  // the term "town".
   if (city_)
     return false;
 
-  // Select fields are allowed here.  This occurs on top-100 site rediff.com.
   return ParseFieldSpecifics(scanner,
                              UTF8ToUTF16(kCityRe),
-                             MATCH_DEFAULT | MATCH_SELECT,
+                             kCityMatchType,
                              &city_);
 }
 
 bool AddressField::ParseState(AutofillScanner* scanner) {
   if (state_)
     return false;
 
   return ParseFieldSpecifics(scanner,
                              UTF8ToUTF16(kStateRe),
-                             MATCH_DEFAULT | MATCH_SELECT,
+                             kStateMatchType,
                              &state_);
 }
 
+bool AddressField::ParseCityStateZipCode(AutofillScanner* scanner) {
+  // Simple cases.
+  if (scanner->IsEnd())
+    return false;
+  if (city_ && state_ && zip_)
+    return false;
+  if (state_ && zip_)
+    return ParseCity(scanner);
+  if (city_ && zip_)
+    return ParseState(scanner);
+  if (city_ && state_)
+    return ParseZipCode(scanner);
+
+  // Check for matches to both name and label.
+  ParseNameLabelResult city_result = ParseNameAndLabelForCity(scanner);
+  if (city_result == RESULT_MATCH_NAME_LABEL)
+    return true;
+  ParseNameLabelResult state_result = ParseNameAndLabelForState(scanner);
+  if (state_result == RESULT_MATCH_NAME_LABEL)
+    return true;
+  ParseNameLabelResult zip_result = ParseNameAndLabelForZipCode(scanner);
+  if (zip_result == RESULT_MATCH_NAME_LABEL)
+    return true;
+
+  // Check if there is only one potential match.
+  bool maybe_city = city_result != RESULT_MATCH_NONE;
+  bool maybe_state = state_result != RESULT_MATCH_NONE;
+  bool maybe_zip = zip_result != RESULT_MATCH_NONE;
+  if (maybe_city && !maybe_state && !maybe_zip)
+    return SetFieldAndAdvanceCursor(scanner, &city_);
+  if (maybe_state && !maybe_city && !maybe_zip)
+    return SetFieldAndAdvanceCursor(scanner, &state_);
+  if (maybe_zip && !maybe_city && !maybe_state)
+    return ParseZipCode(scanner);
+
+  // Otherwise give name priority over label.
+  if (city_result == RESULT_MATCH_NAME)
+    return SetFieldAndAdvanceCursor(scanner, &city_);
+  if (state_result == RESULT_MATCH_NAME)
+    return SetFieldAndAdvanceCursor(scanner, &state_);
+  if (zip_result == RESULT_MATCH_NAME)
+    return ParseZipCode(scanner);
+
+  if (city_result == RESULT_MATCH_LABEL)
+    return SetFieldAndAdvanceCursor(scanner, &city_);
+  if (state_result == RESULT_MATCH_LABEL)
+    return SetFieldAndAdvanceCursor(scanner, &state_);
+  if (zip_result == RESULT_MATCH_LABEL)
+    return ParseZipCode(scanner);
+
+  return false;
+}
+
+AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForZipCode(
+    AutofillScanner* scanner) {
+  if (zip_)
+    return RESULT_MATCH_NONE;
+
+  ParseNameLabelResult result = ParseNameAndLabelSeparately(
+      scanner, UTF8ToUTF16(kZipCodeRe), kZipCodeMatchType, &zip_);
+
+  if (result != RESULT_MATCH_NAME_LABEL || scanner->IsEnd())
+    return result;
+
+  size_t saved_cursor = scanner->SaveCursor();
+  bool found_non_zip4 = ParseCity(scanner);
+  if (found_non_zip4)
+    city_ = nullptr;
+  scanner->RewindTo(saved_cursor);
+  if (!found_non_zip4) {
+    found_non_zip4 = ParseState(scanner);
+    if (found_non_zip4)
+      state_ = nullptr;
+    scanner->RewindTo(saved_cursor);
+  }
+
+  if (!found_non_zip4) {
+    // Look for a zip+4, whose field name will also often contain
+    // the substring "zip".
+    ParseFieldSpecifics(scanner,
+                        UTF8ToUTF16(kZip4Re),
+                        kZipCodeMatchType,
+                        &zip4_);
+  }
+  return result;
+}
+
+AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForCity(
+    AutofillScanner* scanner) {
+  if (city_)
+    return RESULT_MATCH_NONE;
+
+  return ParseNameAndLabelSeparately(
+      scanner, UTF8ToUTF16(kCityRe), kCityMatchType, &city_);
+}
+
+AddressField::ParseNameLabelResult AddressField::ParseNameAndLabelForState(
+    AutofillScanner* scanner) {
+  if (state_)
+    return RESULT_MATCH_NONE;
+
+  return ParseNameAndLabelSeparately(
+      scanner, UTF8ToUTF16(kStateRe), kStateMatchType, &state_);
+}
+
 }  // namespace autofill