Revert of 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 641 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 =
-      rewriter.Rewrite(NormalizeForComparison(p1.GetInfo(kState, app_locale_)));
+      NormalizeForComparison(p1.GetInfo(kState, app_locale_));
   const base::string16& state2 =
-      rewriter.Rewrite(NormalizeForComparison(p2.GetInfo(kState, app_locale_)));
-  if (CompareTokens(state1, state2) == DIFFERENT_TOKENS) {
+      NormalizeForComparison(p2.GetInfo(kState, app_locale_));
+  if (!IsMatchingState(GetNonEmptyOf(p1, p2, kCountryCode), state1, state2) &&
+      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 = 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_)));
+  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_));
   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 = 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_)));
+  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_));
   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