Embed address normalization rewriting rules.

components/autofill/core/browser/autofill_profile_comparator.cc

 // Copyright 2016 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/autofill_profile_comparator.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/char_iterator.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
+#include "components/autofill/core/browser/address_rewriter.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_data_util.h"
 #include "components/autofill/core/browser/state_names.h"
 #include "third_party/libphonenumber/phonenumber_api.h"
 
 using i18n::phonenumbers::PhoneNumberUtil;
 using base::UTF16ToUTF8;
 using base::UTF8ToUTF16;
 
 namespace autofill {
 namespace {
 
 const base::char16 kSpace[] = {L' ', L'\0'};
-const base::char16 kUS[] = {L'U', L'S', L'\0'};
 
 bool ContainsNewline(base::StringPiece16 text) {
   return text.find('\n') != base::StringPiece16::npos;
 }
 
 std::ostream& operator<<(std::ostream& os,
                          const ::i18n::phonenumbers::PhoneNumber& n) {
   os << "country_code: " << n.country_code() << " "
      << "national_number: " << n.national_number();
   if (n.has_extension())
@@ skipping 316 matching lines @@
   const base::string16& state2 = p2.GetInfo(kState, app_locale_);
   if (state1.empty()) {
     address->SetInfo(kState, state2, app_locale_);
   } else if (state2.empty()) {
     address->SetInfo(kState, state1, app_locale_);
   } else {
     address->SetInfo(kState, (state2.size() < state1.size() ? state2 : state1),
                      app_locale_);
   }
 
+  AddressRewriter rewriter = AddressRewriter::ForCountryCode(country_code);
+
   // One of the cities is empty or one of the cities has a subset of tokens from
   // the other. Pick the city name with more tokens; this is usually the most
   // explicit one.
   const AutofillType kCity(ADDRESS_HOME_CITY);
   const base::string16& city1 = p1.GetInfo(kCity, app_locale_);
   const base::string16& city2 = p2.GetInfo(kCity, app_locale_);
   if (city1.empty()) {
     address->SetInfo(kCity, city2, app_locale_);
   } else if (city2.empty()) {
     address->SetInfo(kCity, city1, app_locale_);
   } else {
-    // Prefer the one with more tokens.
-    CompareTokensResult result = CompareTokens(NormalizeForComparison(city1),
-                                               NormalizeForComparison(city2));
+    // Prefer the one with more tokens, making sure to apply address
+    // normalization and rewriting before doing the comparison.
+    CompareTokensResult result =
+        CompareTokens(rewriter.Rewrite(NormalizeForComparison(city1)),
+                      rewriter.Rewrite(NormalizeForComparison(city2)));
     switch (result) {
       case SAME_TOKENS:
         // They have the same set of unique tokens. Let's pick the more recently
         // used one.
         address->SetInfo(kCity, (p2.use_date() > p1.use_date() ? city2 : city1),
                          app_locale_);
         break;
       case S1_CONTAINS_S2:
         // city1 has more unique tokens than city2.
         address->SetInfo(kCity, city1, app_locale_);
@@ skipping 24 matching lines @@
   } else {
     // Prefer the multi-line address if one is multi-line and the other isn't.
     bool address1_multiline = ContainsNewline(address1);
     bool address2_multiline = ContainsNewline(address2);
     if (address1_multiline && !address2_multiline) {
       address->SetInfo(kStreetAddress, address1, app_locale_);
     } else if (address2_multiline && !address1_multiline) {
       address->SetInfo(kStreetAddress, address2, app_locale_);
     } else {
       // Prefer the one with more tokens if they're both single-line or both
-      // multi-line addresses.
-      CompareTokensResult result = CompareTokens(
-          NormalizeForComparison(address1), NormalizeForComparison(address2));
+      // multi-line addresses, making sure to apply address normalization and
+      // rewriting before doing the comparison.
+      CompareTokensResult result =
+          CompareTokens(rewriter.Rewrite(NormalizeForComparison(address1)),
+                        rewriter.Rewrite(NormalizeForComparison(address2)));
       switch (result) {
         case SAME_TOKENS:
           // They have the same set of unique tokens. Let's pick the one that's
           // longer.
           address->SetInfo(
               kStreetAddress,
               (p2.use_date() > p1.use_date() ? address2 : address1),
               app_locale_);
           break;
         case S1_CONTAINS_S2:
@@ skipping 244 matching lines @@
   const base::string16& zip1 = NormalizeForComparison(
       p1.GetInfo(kZipCode, app_locale_), DISCARD_WHITESPACE);
   const base::string16& zip2 = NormalizeForComparison(
       p2.GetInfo(kZipCode, app_locale_), DISCARD_WHITESPACE);
   if (!zip1.empty() && !zip2.empty() &&
       zip1.find(zip2) == base::string16::npos &&
       zip2.find(zip1) == base::string16::npos) {
     return false;
   }
 
+  AddressRewriter rewriter =
+      AddressRewriter::ForCountryCode(country1.empty() ? country2 : country1);
+
   // State
   // ------
   // Heuristic: States are mergeable if one is a (possibly empty) bag of words
   // subset of the other.
   //
   // TODO(rogerm): If the match is between non-empty zip codes then we can infer
   // that the two state strings are intended to have the same meaning. This
   // handles the cases where we have invalid or poorly formed data in one of the
   // state values (like "Select one", or "CA - California").
   const AutofillType kState(ADDRESS_HOME_STATE);
   const base::string16& state1 =
-      NormalizeForComparison(p1.GetInfo(kState, app_locale_));
+      rewriter.Rewrite(NormalizeForComparison(p1.GetInfo(kState, app_locale_)));
   const base::string16& state2 =
-      NormalizeForComparison(p2.GetInfo(kState, app_locale_));
-  if (!IsMatchingState(GetNonEmptyOf(p1, p2, kCountryCode), state1, state2) &&
-      CompareTokens(state1, state2) == DIFFERENT_TOKENS) {
+      rewriter.Rewrite(NormalizeForComparison(p2.GetInfo(kState, app_locale_)));
+  if (CompareTokens(state1, state2) == DIFFERENT_TOKENS) {
     return false;
   }
 
   // City
   // ------
   // Heuristic: Cities are mergeable if one is a (possibly empty) bag of words
   // subset of the other.
   //
   // TODO(rogerm): If the match is between non-empty zip codes then we can infer
   // that the two city strings are intended to have the same meaning. This
   // handles the cases where we have a city vs one of its suburbs.
-  const base::string16& city1 = NormalizeForComparison(
-      p1.GetInfo(AutofillType(ADDRESS_HOME_CITY), app_locale_));
-  const base::string16& city2 = NormalizeForComparison(
-      p2.GetInfo(AutofillType(ADDRESS_HOME_CITY), app_locale_));
+  const base::string16& city1 = rewriter.Rewrite(NormalizeForComparison(
+      p1.GetInfo(AutofillType(ADDRESS_HOME_CITY), app_locale_)));
+  const base::string16& city2 = rewriter.Rewrite(NormalizeForComparison(
+      p2.GetInfo(AutofillType(ADDRESS_HOME_CITY), app_locale_)));
   if (CompareTokens(city1, city2) == DIFFERENT_TOKENS) {
     return false;
   }
 
   // Address
   // --------
   // Heuristic: Street addresses are mergeable if one is a (possibly empty) bag
   // of words subset of the other.
-  const base::string16& address1 = NormalizeForComparison(
-      p1.GetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS), app_locale_));
-  const base::string16& address2 = NormalizeForComparison(
-      p2.GetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS), app_locale_));
+  const base::string16& address1 = rewriter.Rewrite(NormalizeForComparison(
+      p1.GetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS), app_locale_)));
+  const base::string16& address2 = rewriter.Rewrite(NormalizeForComparison(
+      p2.GetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS), app_locale_)));
   if (CompareTokens(address1, address2) == DIFFERENT_TOKENS) {
     return false;
   }
 
   return true;
 }
 
-bool AutofillProfileComparator::IsMatchingState(
-    const base::string16& country_code,
-    const base::string16& state1,
-    const base::string16& state2) const {
-  if (state1 == state2)
-    return true;
-
-  if (country_code != kUS)
-    return false;
-
-  // TODO(rogerm): Generalize this to all locals using string equivalence rules.
-  base::string16 name, abbreviation;
-  autofill::state_names::GetNameAndAbbreviation(state1, &name, &abbreviation);
-  if (abbreviation.empty()) {
-    // state1 wasn't recognized. There's no need to compare it to state2
-    return false;
-  }
-
-  return state2 == name || state2 == abbreviation;
-}
-
 }  // namespace autofill