Use AutofillProfileComparator in place of ad-hoc merge logic.

components/autofill/core/browser/address.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.h"
 
 #include <stddef.h>
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_profile.h"
+#include "components/autofill/core/browser/autofill_profile_comparator.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_names.h"
 #include "components/autofill/core/browser/state_names.h"
 #include "components/autofill/core/common/autofill_l10n_util.h"
 
 namespace autofill {
 
 Address::Address() {}
 
 Address::Address(const Address& address) : FormGroup() {
   *this = address;
 }
 
 Address::~Address() {}
 
 Address& Address::operator=(const Address& address) {
   if (this == &address)
     return *this;
 
   street_address_ = address.street_address_;
   dependent_locality_ = address.dependent_locality_;
   city_ = address.city_;
   state_ = address.state_;
   country_code_ = address.country_code_;
   zip_code_ = address.zip_code_;
   sorting_code_ = address.sorting_code_;
   return *this;
 }
 
+bool Address::operator==(const Address& other) const {
+  if (this == &other)
+    return true;
+  return street_address_ == other.street_address_ &&
+         dependent_locality_ == other.dependent_locality_ &&
+         city_ == other.city_ && state_ == other.state_ &&
+         zip_code_ == other.zip_code_ && sorting_code_ == other.sorting_code_ &&
+         country_code_ == other.country_code_;
+}
+
 base::string16 Address::GetRawInfo(ServerFieldType type) const {
   DCHECK_EQ(ADDRESS_HOME, AutofillType(type).group());
   switch (type) {
     case ADDRESS_HOME_LINE1:
       return street_address_.size() > 0 ? street_address_[0] : base::string16();
 
     case ADDRESS_HOME_LINE2:
       return street_address_.size() > 1 ? street_address_[1] : base::string16();
 
     case ADDRESS_HOME_LINE3:
@@ skipping 13 matching lines @@
 
     case ADDRESS_HOME_SORTING_CODE:
       return sorting_code_;
 
     case ADDRESS_HOME_COUNTRY:
       return base::ASCIIToUTF16(country_code_);
 
     case ADDRESS_HOME_STREET_ADDRESS:
       return base::JoinString(street_address_, base::ASCIIToUTF16("\n"));
 
+    case ADDRESS_HOME_APT_NUM:
+      return base::string16();
+
     default:
-      NOTREACHED();
+      NOTREACHED() << "Unrecognized type: " << type;
       return base::string16();
   }
 }
 
 void Address::SetRawInfo(ServerFieldType type, const base::string16& value) {
   DCHECK_EQ(ADDRESS_HOME, AutofillType(type).group());
   switch (type) {
     case ADDRESS_HOME_LINE1:
       if (street_address_.empty())
         street_address_.resize(1);
@@ skipping 104 matching lines @@
 void Address::GetMatchingTypes(const base::string16& text,
                                const std::string& app_locale,
                                ServerFieldTypeSet* matching_types) const {
   FormGroup::GetMatchingTypes(text, app_locale, matching_types);
 
   // Check to see if the |text| canonicalized as a country name is a match.
   std::string country_code = CountryNames::GetInstance()->GetCountryCode(text);
   if (!country_code.empty() && country_code_ == country_code)
     matching_types->insert(ADDRESS_HOME_COUNTRY);
 
+  AutofillProfileComparator comparator(app_locale);
   // Check to see if the |text| could be the full name or abbreviation of a
   // state.
-  base::string16 canon_text = AutofillProfile::CanonicalizeProfileString(text);
+  base::string16 canon_text = comparator.NormalizeForComparison(text);
   base::string16 state_name;
   base::string16 state_abbreviation;
   state_names::GetNameAndAbbreviation(canon_text, &state_name,
                                       &state_abbreviation);
   if (!state_name.empty() || !state_abbreviation.empty()) {
     l10n::CaseInsensitiveCompare compare;
     base::string16 canon_profile_state =
-        AutofillProfile::CanonicalizeProfileString(
+        comparator.NormalizeForComparison(
             GetInfo(AutofillType(ADDRESS_HOME_STATE), app_locale));
     if ((!state_name.empty() &&
          compare.StringsEqual(state_name, canon_profile_state)) ||
         (!state_abbreviation.empty() &&
          compare.StringsEqual(state_abbreviation, canon_profile_state))) {
       matching_types->insert(ADDRESS_HOME_STATE);
     }
   }
 }
 
@@ skipping 10 matching lines @@
   supported_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
 void Address::TrimStreetAddress() {
   while (!street_address_.empty() && street_address_.back().empty()) {
     street_address_.pop_back();
   }
 }
 
 }  // namespace autofill