[autofill] Add address comparison/merge logic for dependent locality and sorting codes

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"
@@ skipping 490 matching lines @@
         break;
       case DIFFERENT_TOKENS:
       default:
         // The addresses aren't mergeable and we shouldn't be doing any of
         // this.
         NOTREACHED();
         return false;
     }
   }
 
+  // One of the dependend localities is empty or one of the localities has a
+  // subset of tokens from the other. Pick the locality name with more tokens;
+  // this is usually the most explicit one.
+  const AutofillType kDependentLocality(ADDRESS_HOME_DEPENDENT_LOCALITY);
+  const base::string16& locality1 = p1.GetInfo(kDependentLocality, app_locale_);
+  const base::string16& locality2 = p2.GetInfo(kDependentLocality, app_locale_);
+  if (locality1.empty()) {
+    address->SetInfo(kDependentLocality, locality2, app_locale_);
+  } else if (locality2.empty()) {
+    address->SetInfo(kDependentLocality, locality1, app_locale_);
+  } else {
+    // Prefer the one with more tokens, making sure to apply address
+    // normalization and rewriting before doing the comparison.
+    CompareTokensResult result =
+        CompareTokens(rewriter.Rewrite(NormalizeForComparison(locality1)),
+                      rewriter.Rewrite(NormalizeForComparison(locality2)));
+    switch (result) {
+      case SAME_TOKENS:
+        // They have the same set of unique tokens. Let's pick the more recently
+        // used one.
+        address->SetInfo(
+            kDependentLocality,
+            (p2.use_date() > p1.use_date() ? locality2 : locality1),
+            app_locale_);
+        break;
+      case S1_CONTAINS_S2:
+        // locality1 has more unique tokens than locality2.
+        address->SetInfo(kDependentLocality, locality1, app_locale_);
+        break;
+      case S2_CONTAINS_S1:
+        // locality2 has more unique tokens than locality1.
+        address->SetInfo(kDependentLocality, locality2, app_locale_);
+        break;
+      case DIFFERENT_TOKENS:
+      default:
+        // The localities aren't mergeable and we shouldn't be doing any of
+        // this.
+        NOTREACHED();

[Mathieu, 2016/11/12 13:02:30]

suggestion: let's be more specific on the NOTREACHED():

NOTREACHED() << "Localities not mergeable " << locality1 << " " << locality2;

(Same with other NOTREACHED(). A Debug crash was filed with us the other day and
I would have loved to have the values responsible for the DCHECK in the stack
trace. What do you think?)

[Roger McFarlane (Chromium), 2016/11/21 18:39:51]

Done. But note that this only applies to dev/debug builds. NOTREACHED() is a
DCHECK.

+        return false;
+    }
+  }
+
+  // One of the sorting codes is empty, they are the same, or one is a substring
+  // of the other. We prefer the most recently used sorting code.
+  const AutofillType kSortingCode(ADDRESS_HOME_SORTING_CODE);
+  const base::string16& sorting1 = p1.GetInfo(kSortingCode, app_locale_);
+  const base::string16& sorting2 = p2.GetInfo(kSortingCode, app_locale_);
+  if (sorting1.empty()) {
+    address->SetInfo(kSortingCode, sorting2, app_locale_);
+  } else if (sorting2.empty()) {
+    address->SetInfo(kSortingCode, sorting1, app_locale_);
+  } else {
+    address->SetInfo(kSortingCode,
+                     (p2.use_date() > p1.use_date() ? sorting2 : sorting1),
+                     app_locale_);
+  }
+
   // One of the addresses is empty or one of the addresses has a subset of
   // tokens from the other. Prefer the more verbosely expressed one.
   const AutofillType kStreetAddress(ADDRESS_HOME_STREET_ADDRESS);
   const base::string16& address1 = p1.GetInfo(kStreetAddress, app_locale_);
   const base::string16& address2 = p2.GetInfo(kStreetAddress, app_locale_);
   // If one of the addresses is empty then use the other.
   if (address1.empty()) {
     address->SetInfo(kStreetAddress, address2, app_locale_);
   } else if (address2.empty()) {
     address->SetInfo(kStreetAddress, address1, app_locale_);
@@ skipping 269 matching lines @@
   // If the address are not in the same country, then they're not the same. If
   // one of the address countries is unknown/invalid the comparison continues.
   const AutofillType kCountryCode(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
   const base::string16& country1 = p1.GetInfo(kCountryCode, app_locale_);
   const base::string16& country2 = p2.GetInfo(kCountryCode, app_locale_);
   if (!country1.empty() && !country2.empty() &&
       !case_insensitive_compare_.StringsEqual(country1, country2)) {
     return false;
   }
 
-  // TODO(rogerm): Lookup the normalization rules for the (common) country of
-  // the address. The rules should be applied post NormalizeForComparison to
-  // the state, city, and address bag of words comparisons.
-
   // Zip
   // ----
   // If the addresses are definitely not in the same zip/area code then we're
   // done. Otherwise,the comparison continues.
   const AutofillType kZipCode(ADDRESS_HOME_ZIP);
   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;
   }
 
+  // Use the token rewrite rules for the (common) country of the address to
+  // transform equivalent substrings to a representative token for comparison.
   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_)));
   const base::string16& state2 =
       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 = 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 AutofillType kCity(ADDRESS_HOME_CITY);
+  const base::string16& city1 =
+      rewriter.Rewrite(NormalizeForComparison(p1.GetInfo(kCity, app_locale_)));
+  const base::string16& city2 =
+      rewriter.Rewrite(NormalizeForComparison(p2.GetInfo(kCity, app_locale_)));
   if (CompareTokens(city1, city2) == DIFFERENT_TOKENS) {
     return false;
   }
 
+  // Dependent Locality
+  // -------------------
+  // Heuristic: Dependent Localities are mergeable if one is a (possibly empty)
+  // bag of words subset of the other.
+  const AutofillType kDependentLocality(ADDRESS_HOME_DEPENDENT_LOCALITY);
+  const base::string16& locality1 = rewriter.Rewrite(
+      NormalizeForComparison(p1.GetInfo(kDependentLocality, app_locale_)));
+  const base::string16& locality2 = rewriter.Rewrite(
+      NormalizeForComparison(p2.GetInfo(kDependentLocality, app_locale_)));
+  if (CompareTokens(locality1, locality2) == DIFFERENT_TOKENS) {
+    return false;
+  }
+
+  // Sorting Code
+  // -------------
+  // Heuristic: Sorting codes are mergeable if one is empty or one is a
+  // substring of the other, post normalization and whitespace removed. This
+  // is similar to postal/zip codes.
+  const AutofillType kSortingCode(ADDRESS_HOME_SORTING_CODE);
+  const base::string16& sorting1 = NormalizeForComparison(
+      p1.GetInfo(kSortingCode, app_locale_), DISCARD_WHITESPACE);
+  const base::string16& sorting2 = NormalizeForComparison(
+      p2.GetInfo(kSortingCode, app_locale_), DISCARD_WHITESPACE);
+  if (!sorting1.empty() && !sorting2.empty() &&
+      sorting1.find(sorting2) == base::string16::npos &&
+      sorting2.find(sorting1) == base::string16::npos) {
+    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_)));
   if (CompareTokens(address1, address2) == DIFFERENT_TOKENS) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace autofill