Home | History | Annotate | Download | only in browser 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/autofill/core/browser/autofill_profile.h"
      6 
      7 #include <algorithm>
      8 #include <functional>
      9 #include <map>
     10 #include <ostream>
     11 #include <set>
     12 
     13 #include "base/basictypes.h"
     14 #include "base/guid.h"
     15 #include "base/logging.h"
     16 #include "base/strings/string_util.h"
     17 #include "base/strings/utf_string_conversions.h"
     18 #include "components/autofill/core/browser/address.h"
     19 #include "components/autofill/core/browser/address_i18n.h"
     20 #include "components/autofill/core/browser/autofill_country.h"
     21 #include "components/autofill/core/browser/autofill_field.h"
     22 #include "components/autofill/core/browser/autofill_type.h"
     23 #include "components/autofill/core/browser/contact_info.h"
     24 #include "components/autofill/core/browser/phone_number.h"
     25 #include "components/autofill/core/browser/phone_number_i18n.h"
     26 #include "components/autofill/core/browser/validation.h"
     27 #include "components/autofill/core/common/form_field_data.h"
     28 #include "grit/components_strings.h"
     29 #include "third_party/libaddressinput/chromium/addressinput_util.h"
     30 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
     31 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_formatter.h"
     32 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_metadata.h"
     33 #include "ui/base/l10n/l10n_util.h"
     34 
     35 using base::ASCIIToUTF16;
     36 using base::UTF16ToUTF8;
     37 using i18n::addressinput::AddressData;
     38 using i18n::addressinput::AddressField;
     39 
     40 namespace autofill {
     41 namespace {
     42 
     43 // Like |AutofillType::GetStorableType()|, but also returns |NAME_FULL| for
     44 // first, middle, and last name field types.
     45 ServerFieldType GetStorableTypeCollapsingNames(ServerFieldType type) {
     46   ServerFieldType storable_type = AutofillType(type).GetStorableType();
     47   if (AutofillType(storable_type).group() == NAME)
     48     return NAME_FULL;
     49 
     50   return storable_type;
     51 }
     52 
     53 // Fills |distinguishing_fields| with a list of fields to use when creating
     54 // labels that can help to distinguish between two profiles. Draws fields from
     55 // |suggested_fields| if it is non-NULL; otherwise returns a default list.
     56 // If |suggested_fields| is non-NULL, does not include |excluded_field| in the
     57 // list. Otherwise, |excluded_field| is ignored, and should be set to
     58 // |UNKNOWN_TYPE| by convention. The resulting list of fields is sorted in
     59 // decreasing order of importance.
     60 void GetFieldsForDistinguishingProfiles(
     61     const std::vector<ServerFieldType>* suggested_fields,
     62     ServerFieldType excluded_field,
     63     std::vector<ServerFieldType>* distinguishing_fields) {
     64   static const ServerFieldType kDefaultDistinguishingFields[] = {
     65     NAME_FULL,
     66     ADDRESS_HOME_LINE1,
     67     ADDRESS_HOME_LINE2,
     68     ADDRESS_HOME_DEPENDENT_LOCALITY,
     69     ADDRESS_HOME_CITY,
     70     ADDRESS_HOME_STATE,
     71     ADDRESS_HOME_ZIP,
     72     ADDRESS_HOME_SORTING_CODE,
     73     ADDRESS_HOME_COUNTRY,
     74     EMAIL_ADDRESS,
     75     PHONE_HOME_WHOLE_NUMBER,
     76     COMPANY_NAME,
     77   };
     78 
     79   std::vector<ServerFieldType> default_fields;
     80   if (!suggested_fields) {
     81     default_fields.assign(
     82         kDefaultDistinguishingFields,
     83         kDefaultDistinguishingFields + arraysize(kDefaultDistinguishingFields));
     84     if (excluded_field == UNKNOWN_TYPE) {
     85       distinguishing_fields->swap(default_fields);
     86       return;
     87     }
     88     suggested_fields = &default_fields;
     89   }
     90 
     91   // Keep track of which fields we've seen so that we avoid duplicate entries.
     92   // Always ignore fields of unknown type and the excluded field.
     93   std::set<ServerFieldType> seen_fields;
     94   seen_fields.insert(UNKNOWN_TYPE);
     95   seen_fields.insert(GetStorableTypeCollapsingNames(excluded_field));
     96 
     97   distinguishing_fields->clear();
     98   for (std::vector<ServerFieldType>::const_iterator it =
     99            suggested_fields->begin();
    100        it != suggested_fields->end(); ++it) {
    101     ServerFieldType suggested_type = GetStorableTypeCollapsingNames(*it);
    102     if (seen_fields.insert(suggested_type).second)
    103       distinguishing_fields->push_back(suggested_type);
    104   }
    105 
    106   // Special case: If the excluded field is a partial name (e.g. first name) and
    107   // the suggested fields include other name fields, include |NAME_FULL| in the
    108   // list of distinguishing fields as a last-ditch fallback. This allows us to
    109   // distinguish between profiles that are identical except for the name.
    110   if (excluded_field != NAME_FULL &&
    111       GetStorableTypeCollapsingNames(excluded_field) == NAME_FULL) {
    112     for (std::vector<ServerFieldType>::const_iterator it =
    113              suggested_fields->begin();
    114          it != suggested_fields->end(); ++it) {
    115       if (*it != excluded_field &&
    116           GetStorableTypeCollapsingNames(*it) == NAME_FULL) {
    117         distinguishing_fields->push_back(NAME_FULL);
    118         break;
    119       }
    120     }
    121   }
    122 }
    123 
    124 // A helper function for string streaming.  Concatenates multi-valued entries
    125 // stored for a given |type| into a single string.  This string is returned.
    126 const base::string16 MultiString(const AutofillProfile& p,
    127                                  ServerFieldType type) {
    128   std::vector<base::string16> values;
    129   p.GetRawMultiInfo(type, &values);
    130   base::string16 accumulate;
    131   for (size_t i = 0; i < values.size(); ++i) {
    132     if (i > 0)
    133       accumulate += ASCIIToUTF16(" ");
    134     accumulate += values[i];
    135   }
    136   return accumulate;
    137 }
    138 
    139 base::string16 GetFormGroupInfo(const FormGroup& form_group,
    140                                 const AutofillType& type,
    141                                 const std::string& app_locale) {
    142   return app_locale.empty() ?
    143       form_group.GetRawInfo(type.GetStorableType()) :
    144       form_group.GetInfo(type, app_locale);
    145 }
    146 
    147 template <class T>
    148 void CopyRawValuesToItems(ServerFieldType type,
    149                           const std::vector<base::string16>& values,
    150                           const T& prototype,
    151                           std::vector<T>* form_group_items) {
    152   form_group_items->resize(values.size(), prototype);
    153   for (size_t i = 0; i < form_group_items->size(); ++i) {
    154     (*form_group_items)[i].SetRawInfo(type, values[i]);
    155   }
    156   // Must have at least one (possibly empty) element.
    157   form_group_items->resize(std::max<size_t>(1UL, values.size()), prototype);
    158 }
    159 
    160 template <class T>
    161 void CopyValuesToItems(AutofillType type,
    162                        const std::vector<base::string16>& values,
    163                        const T& prototype,
    164                        const std::string& app_locale,
    165                        std::vector<T>* form_group_items) {
    166   form_group_items->resize(values.size(), prototype);
    167   for (size_t i = 0; i < form_group_items->size(); ++i) {
    168     (*form_group_items)[i].SetInfo(type, values[i], app_locale);
    169   }
    170   // Must have at least one (possibly empty) element.
    171   form_group_items->resize(std::max<size_t>(1UL, values.size()), prototype);
    172 }
    173 
    174 template <class T>
    175 void CopyItemsToValues(const AutofillType& type,
    176                        const std::vector<T>& form_group_items,
    177                        const std::string& app_locale,
    178                        std::vector<base::string16>* values) {
    179   values->resize(form_group_items.size());
    180   for (size_t i = 0; i < values->size(); ++i) {
    181     (*values)[i] = GetFormGroupInfo(form_group_items[i], type, app_locale);
    182   }
    183 }
    184 
    185 // Collapse compound field types to their "full" type.  I.e. First name
    186 // collapses to full name, area code collapses to full phone, etc.
    187 void CollapseCompoundFieldTypes(ServerFieldTypeSet* type_set) {
    188   ServerFieldTypeSet collapsed_set;
    189   for (ServerFieldTypeSet::iterator it = type_set->begin();
    190        it != type_set->end(); ++it) {
    191     switch (*it) {
    192       case NAME_FIRST:
    193       case NAME_MIDDLE:
    194       case NAME_LAST:
    195       case NAME_MIDDLE_INITIAL:
    196       case NAME_FULL:
    197       case NAME_SUFFIX:
    198         collapsed_set.insert(NAME_FULL);
    199         break;
    200 
    201       case PHONE_HOME_NUMBER:
    202       case PHONE_HOME_CITY_CODE:
    203       case PHONE_HOME_COUNTRY_CODE:
    204       case PHONE_HOME_CITY_AND_NUMBER:
    205       case PHONE_HOME_WHOLE_NUMBER:
    206         collapsed_set.insert(PHONE_HOME_WHOLE_NUMBER);
    207         break;
    208 
    209       default:
    210         collapsed_set.insert(*it);
    211     }
    212   }
    213   std::swap(*type_set, collapsed_set);
    214 }
    215 
    216 class FindByPhone {
    217  public:
    218   FindByPhone(const base::string16& phone,
    219               const std::string& country_code,
    220               const std::string& app_locale)
    221       : phone_(phone),
    222         country_code_(country_code),
    223         app_locale_(app_locale) {}
    224 
    225   bool operator()(const base::string16& phone) {
    226     return i18n::PhoneNumbersMatch(phone, phone_, country_code_, app_locale_);
    227   }
    228 
    229  private:
    230   base::string16 phone_;
    231   std::string country_code_;
    232   std::string app_locale_;
    233 };
    234 
    235 // Functor used to check for case-insensitive equality of two strings.
    236 struct CaseInsensitiveStringEquals {
    237  public:
    238   CaseInsensitiveStringEquals(const base::string16& other)
    239       : other_(other) {}
    240 
    241   bool operator()(const base::string16& x) const {
    242     return x.size() == other_.size() &&
    243         base::StringToLowerASCII(x) == base::StringToLowerASCII(other_);
    244   }
    245 
    246  private:
    247   const base::string16& other_;
    248 };
    249 
    250 }  // namespace
    251 
    252 AutofillProfile::AutofillProfile(const std::string& guid,
    253                                  const std::string& origin)
    254     : AutofillDataModel(guid, origin),
    255       name_(1),
    256       email_(1),
    257       phone_number_(1, PhoneNumber(this)) {
    258 }
    259 
    260 AutofillProfile::AutofillProfile()
    261     : AutofillDataModel(base::GenerateGUID(), std::string()),
    262       name_(1),
    263       email_(1),
    264       phone_number_(1, PhoneNumber(this)) {
    265 }
    266 
    267 AutofillProfile::AutofillProfile(const AutofillProfile& profile)
    268     : AutofillDataModel(std::string(), std::string()) {
    269   operator=(profile);
    270 }
    271 
    272 AutofillProfile::~AutofillProfile() {
    273 }
    274 
    275 AutofillProfile& AutofillProfile::operator=(const AutofillProfile& profile) {
    276   if (this == &profile)
    277     return *this;
    278 
    279   set_guid(profile.guid());
    280   set_origin(profile.origin());
    281 
    282   name_ = profile.name_;
    283   email_ = profile.email_;
    284   company_ = profile.company_;
    285   phone_number_ = profile.phone_number_;
    286 
    287   for (size_t i = 0; i < phone_number_.size(); ++i)
    288     phone_number_[i].set_profile(this);
    289 
    290   address_ = profile.address_;
    291   set_language_code(profile.language_code());
    292 
    293   return *this;
    294 }
    295 
    296 void AutofillProfile::GetMatchingTypes(
    297     const base::string16& text,
    298     const std::string& app_locale,
    299     ServerFieldTypeSet* matching_types) const {
    300   FormGroupList info = FormGroups();
    301   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
    302     (*it)->GetMatchingTypes(text, app_locale, matching_types);
    303 }
    304 
    305 base::string16 AutofillProfile::GetRawInfo(ServerFieldType type) const {
    306   const FormGroup* form_group = FormGroupForType(AutofillType(type));
    307   if (!form_group)
    308     return base::string16();
    309 
    310   return form_group->GetRawInfo(type);
    311 }
    312 
    313 void AutofillProfile::SetRawInfo(ServerFieldType type,
    314                                  const base::string16& value) {
    315   FormGroup* form_group = MutableFormGroupForType(AutofillType(type));
    316   if (form_group)
    317     form_group->SetRawInfo(type, value);
    318 }
    319 
    320 base::string16 AutofillProfile::GetInfo(const AutofillType& type,
    321                                         const std::string& app_locale) const {
    322   if (type.html_type() == HTML_TYPE_FULL_ADDRESS) {
    323     scoped_ptr<AddressData> address_data =
    324         i18n::CreateAddressDataFromAutofillProfile(*this, app_locale);
    325     if (!addressinput::HasAllRequiredFields(*address_data))
    326       return base::string16();
    327 
    328     std::vector<std::string> lines;
    329     ::i18n::addressinput::GetFormattedNationalAddress(*address_data, &lines);
    330     return base::UTF8ToUTF16(JoinString(lines, '\n'));
    331   }
    332 
    333   const FormGroup* form_group = FormGroupForType(type);
    334   if (!form_group)
    335     return base::string16();
    336 
    337   return form_group->GetInfo(type, app_locale);
    338 }
    339 
    340 bool AutofillProfile::SetInfo(const AutofillType& type,
    341                               const base::string16& value,
    342                               const std::string& app_locale) {
    343   FormGroup* form_group = MutableFormGroupForType(type);
    344   if (!form_group)
    345     return false;
    346 
    347   base::string16 trimmed_value;
    348   base::TrimWhitespace(value, base::TRIM_ALL, &trimmed_value);
    349   return form_group->SetInfo(type, trimmed_value, app_locale);
    350 }
    351 
    352 base::string16 AutofillProfile::GetInfoForVariant(
    353     const AutofillType& type,
    354     size_t variant,
    355     const std::string& app_locale) const {
    356   std::vector<base::string16> values;
    357   GetMultiInfo(type, app_locale, &values);
    358 
    359   if (variant >= values.size()) {
    360     // If the variant is unavailable, bail. This case is reachable, for
    361     // example if Sync updates a profile during the filling process.
    362     return base::string16();
    363   }
    364 
    365   return values[variant];
    366 }
    367 
    368 void AutofillProfile::SetRawMultiInfo(
    369     ServerFieldType type,
    370     const std::vector<base::string16>& values) {
    371   switch (AutofillType(type).group()) {
    372     case NAME:
    373     case NAME_BILLING:
    374       CopyRawValuesToItems(type, values, NameInfo(), &name_);
    375       break;
    376 
    377     case EMAIL:
    378       CopyRawValuesToItems(type, values, EmailInfo(), &email_);
    379       break;
    380 
    381     case PHONE_HOME:
    382     case PHONE_BILLING:
    383       CopyRawValuesToItems(type, values, PhoneNumber(this), &phone_number_);
    384       break;
    385 
    386     default:
    387       if (values.size() == 1U) {
    388         SetRawInfo(type, values[0]);
    389       } else if (values.empty()) {
    390         SetRawInfo(type, base::string16());
    391       } else {
    392         // Shouldn't attempt to set multiple values on single-valued field.
    393         NOTREACHED();
    394       }
    395       break;
    396   }
    397 }
    398 
    399 void AutofillProfile::GetRawMultiInfo(
    400     ServerFieldType type,
    401     std::vector<base::string16>* values) const {
    402   GetMultiInfoImpl(AutofillType(type), std::string(), values);
    403 }
    404 
    405 void AutofillProfile::SetMultiInfo(const AutofillType& type,
    406                                    const std::vector<base::string16>& values,
    407                                    const std::string& app_locale) {
    408   switch (AutofillType(type).group()) {
    409     case NAME:
    410     case NAME_BILLING:
    411       CopyValuesToItems(type, values, NameInfo(), app_locale, &name_);
    412       break;
    413 
    414     case EMAIL:
    415       CopyValuesToItems(type, values, EmailInfo(), app_locale, &email_);
    416       break;
    417 
    418     case PHONE_HOME:
    419     case PHONE_BILLING:
    420       CopyValuesToItems(
    421           type, values, PhoneNumber(this), app_locale, &phone_number_);
    422       break;
    423 
    424     default:
    425       if (values.size() == 1U) {
    426         SetInfo(type, values[0], app_locale);
    427       } else if (values.empty()) {
    428         SetInfo(type, base::string16(), app_locale);
    429       } else {
    430         // Shouldn't attempt to set multiple values on single-valued field.
    431         NOTREACHED();
    432       }
    433       break;
    434   }
    435 }
    436 
    437 void AutofillProfile::GetMultiInfo(const AutofillType& type,
    438                                    const std::string& app_locale,
    439                                    std::vector<base::string16>* values) const {
    440   GetMultiInfoImpl(type, app_locale, values);
    441 }
    442 
    443 bool AutofillProfile::IsEmpty(const std::string& app_locale) const {
    444   ServerFieldTypeSet types;
    445   GetNonEmptyTypes(app_locale, &types);
    446   return types.empty();
    447 }
    448 
    449 bool AutofillProfile::IsPresentButInvalid(ServerFieldType type) const {
    450   std::string country = UTF16ToUTF8(GetRawInfo(ADDRESS_HOME_COUNTRY));
    451   base::string16 data = GetRawInfo(type);
    452   if (data.empty())
    453     return false;
    454 
    455   switch (type) {
    456     case ADDRESS_HOME_STATE:
    457       return country == "US" && !autofill::IsValidState(data);
    458 
    459     case ADDRESS_HOME_ZIP:
    460       return country == "US" && !autofill::IsValidZip(data);
    461 
    462     case PHONE_HOME_WHOLE_NUMBER:
    463       return !i18n::PhoneObject(data, country).IsValidNumber();
    464 
    465     case EMAIL_ADDRESS:
    466       return !autofill::IsValidEmailAddress(data);
    467 
    468     default:
    469       NOTREACHED();
    470       return false;
    471   }
    472 }
    473 
    474 int AutofillProfile::Compare(const AutofillProfile& profile) const {
    475   const ServerFieldType single_value_types[] = {
    476     COMPANY_NAME,
    477     ADDRESS_HOME_STREET_ADDRESS,
    478     ADDRESS_HOME_DEPENDENT_LOCALITY,
    479     ADDRESS_HOME_CITY,
    480     ADDRESS_HOME_STATE,
    481     ADDRESS_HOME_ZIP,
    482     ADDRESS_HOME_SORTING_CODE,
    483     ADDRESS_HOME_COUNTRY,
    484   };
    485 
    486   for (size_t i = 0; i < arraysize(single_value_types); ++i) {
    487     int comparison = GetRawInfo(single_value_types[i]).compare(
    488         profile.GetRawInfo(single_value_types[i]));
    489     if (comparison != 0)
    490       return comparison;
    491   }
    492 
    493   const ServerFieldType multi_value_types[] = { NAME_FULL,
    494                                                 NAME_FIRST,
    495                                                 NAME_MIDDLE,
    496                                                 NAME_LAST,
    497                                                 EMAIL_ADDRESS,
    498                                                 PHONE_HOME_WHOLE_NUMBER };
    499 
    500   for (size_t i = 0; i < arraysize(multi_value_types); ++i) {
    501     std::vector<base::string16> values_a;
    502     std::vector<base::string16> values_b;
    503     GetRawMultiInfo(multi_value_types[i], &values_a);
    504     profile.GetRawMultiInfo(multi_value_types[i], &values_b);
    505     if (values_a.size() < values_b.size())
    506       return -1;
    507     if (values_a.size() > values_b.size())
    508       return 1;
    509     for (size_t j = 0; j < values_a.size(); ++j) {
    510       int comparison = values_a[j].compare(values_b[j]);
    511       if (comparison != 0)
    512         return comparison;
    513     }
    514   }
    515 
    516   return 0;
    517 }
    518 
    519 bool AutofillProfile::EqualsSansOrigin(const AutofillProfile& profile) const {
    520   return guid() == profile.guid() &&
    521          language_code() == profile.language_code() &&
    522          Compare(profile) == 0;
    523 }
    524 
    525 bool AutofillProfile::EqualsSansGuid(const AutofillProfile& profile) const {
    526   return origin() == profile.origin() &&
    527          language_code() == profile.language_code() &&
    528          Compare(profile) == 0;
    529 }
    530 
    531 bool AutofillProfile::operator==(const AutofillProfile& profile) const {
    532   return guid() == profile.guid() && EqualsSansGuid(profile);
    533 }
    534 
    535 bool AutofillProfile::operator!=(const AutofillProfile& profile) const {
    536   return !operator==(profile);
    537 }
    538 
    539 const base::string16 AutofillProfile::PrimaryValue() const {
    540   return GetRawInfo(ADDRESS_HOME_LINE1) + GetRawInfo(ADDRESS_HOME_CITY);
    541 }
    542 
    543 bool AutofillProfile::IsSubsetOf(const AutofillProfile& profile,
    544                                  const std::string& app_locale) const {
    545   ServerFieldTypeSet types;
    546   GetNonEmptyTypes(app_locale, &types);
    547 
    548   for (ServerFieldTypeSet::const_iterator it = types.begin(); it != types.end();
    549        ++it) {
    550     if (*it == NAME_FULL || *it == ADDRESS_HOME_STREET_ADDRESS) {
    551       // Ignore the compound "full name" field type.  We are only interested in
    552       // comparing the constituent parts.  For example, if |this| has a middle
    553       // name saved, but |profile| lacks one, |profile| could still be a subset
    554       // of |this|.  Likewise, ignore the compound "street address" type, as we
    555       // are only interested in matching line-by-line.
    556       continue;
    557     } else if (AutofillType(*it).group() == PHONE_HOME) {
    558       // Phone numbers should be canonicalized prior to being compared.
    559       if (*it != PHONE_HOME_WHOLE_NUMBER) {
    560         continue;
    561       } else if (!i18n::PhoneNumbersMatch(
    562             GetRawInfo(*it),
    563             profile.GetRawInfo(*it),
    564             base::UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY)),
    565             app_locale)) {
    566         return false;
    567       }
    568     } else if (base::StringToLowerASCII(GetRawInfo(*it)) !=
    569                    base::StringToLowerASCII(profile.GetRawInfo(*it))) {
    570       return false;
    571     }
    572   }
    573 
    574   return true;
    575 }
    576 
    577 void AutofillProfile::OverwriteOrAppendNames(
    578     const std::vector<NameInfo>& names,
    579     const std::string& app_locale) {
    580   std::vector<NameInfo> results(name_);
    581   for (std::vector<NameInfo>::const_iterator it = names.begin();
    582        it != names.end();
    583        ++it) {
    584     NameInfo imported_name = *it;
    585     bool should_append_imported_name = true;
    586 
    587     for (size_t index = 0; index < name_.size(); ++index) {
    588       NameInfo current_name = name_[index];
    589       if (current_name.ParsedNamesAreEqual(imported_name)) {
    590         if (current_name.GetRawInfo(NAME_FULL).empty()) {
    591           current_name.SetRawInfo(NAME_FULL,
    592                                   imported_name.GetRawInfo(NAME_FULL));
    593         }
    594 
    595         should_append_imported_name = false;
    596         break;
    597       }
    598 
    599       AutofillType type = AutofillType(NAME_FULL);
    600       base::string16 full_name = current_name.GetInfo(type, app_locale);
    601       if (base::StringToLowerASCII(full_name) ==
    602           base::StringToLowerASCII(imported_name.GetInfo(type, app_locale))) {
    603         // The imported name has the same full name string as one of the
    604         // existing names for this profile.  Because full names are
    605         // _heuristically_ parsed into {first, middle, last} name components,
    606         // it's possible that either the existing name or the imported name
    607         // was misparsed.  Prefer to keep the name whose {first, middle,
    608         // last} components do not match those computed by the heuristic
    609         // parse, as this more likely represents the correct, user-input parse
    610         // of the name.
    611         NameInfo heuristically_parsed_name;
    612         heuristically_parsed_name.SetInfo(type, full_name, app_locale);
    613         if (imported_name.ParsedNamesAreEqual(heuristically_parsed_name)) {
    614           should_append_imported_name = false;
    615           break;
    616         }
    617 
    618         if (current_name.ParsedNamesAreEqual(heuristically_parsed_name)) {
    619           results[index] = imported_name;
    620           should_append_imported_name = false;
    621           break;
    622         }
    623       }
    624     }
    625 
    626     // Append unique names to the list.
    627     if (should_append_imported_name)
    628       results.push_back(imported_name);
    629   }
    630 
    631   name_.swap(results);
    632 }
    633 
    634 void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile,
    635                                            const std::string& app_locale) {
    636   // Verified profiles should never be overwritten with unverified data.
    637   DCHECK(!IsVerified() || profile.IsVerified());
    638   set_origin(profile.origin());
    639   set_language_code(profile.language_code());
    640 
    641   ServerFieldTypeSet field_types;
    642   profile.GetNonEmptyTypes(app_locale, &field_types);
    643 
    644   // Only transfer "full" types (e.g. full name) and not fragments (e.g.
    645   // first name, last name).
    646   CollapseCompoundFieldTypes(&field_types);
    647 
    648   // TODO(isherman): Revisit this decision in the context of i18n and storing
    649   // full addresses rather than storing 1-to-2 lines of an address.
    650   // For addresses, do the opposite: transfer individual address lines, rather
    651   // than full addresses.
    652   field_types.erase(ADDRESS_HOME_STREET_ADDRESS);
    653 
    654   for (ServerFieldTypeSet::const_iterator iter = field_types.begin();
    655        iter != field_types.end(); ++iter) {
    656     FieldTypeGroup group = AutofillType(*iter).group();
    657     // Special case names.
    658     if (group == NAME) {
    659       OverwriteOrAppendNames(profile.name_, app_locale);
    660       continue;
    661     }
    662 
    663     // Single value field --- overwrite.
    664     if (!AutofillProfile::SupportsMultiValue(*iter)) {
    665       base::string16 new_value = profile.GetRawInfo(*iter);
    666       if (base::StringToLowerASCII(GetRawInfo(*iter)) !=
    667               base::StringToLowerASCII(new_value)) {
    668         SetRawInfo(*iter, new_value);
    669       }
    670       continue;
    671     }
    672 
    673     // Multi value field --- overwrite/append.
    674     std::vector<base::string16> new_values;
    675     profile.GetRawMultiInfo(*iter, &new_values);
    676     std::vector<base::string16> existing_values;
    677     GetRawMultiInfo(*iter, &existing_values);
    678 
    679     // GetMultiInfo always returns at least one element, even if the profile
    680     // has no data stored for this field type.
    681     if (existing_values.size() == 1 && existing_values.front().empty())
    682       existing_values.clear();
    683 
    684     for (std::vector<base::string16>::iterator value_iter =
    685              new_values.begin();
    686          value_iter != new_values.end(); ++value_iter) {
    687       // Don't add duplicates. Most types get case insensitive matching.
    688       std::vector<base::string16>::const_iterator existing_iter;
    689 
    690       if (group == PHONE_HOME) {
    691         // Phones allow "fuzzy" matching, so "1-800-FLOWERS", "18003569377",
    692         // "(800)356-9377" and "356-9377" are considered the same.
    693         std::string country_code =
    694             base::UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY));
    695         existing_iter =
    696             std::find_if(existing_values.begin(), existing_values.end(),
    697                          FindByPhone(*value_iter, country_code, app_locale));
    698       } else {
    699         existing_iter =
    700             std::find_if(existing_values.begin(), existing_values.end(),
    701                          CaseInsensitiveStringEquals(*value_iter));
    702       }
    703 
    704       if (existing_iter == existing_values.end())
    705         existing_values.insert(existing_values.end(), *value_iter);
    706     }
    707 
    708     SetRawMultiInfo(*iter, existing_values);
    709   }
    710 }
    711 
    712 // static
    713 bool AutofillProfile::SupportsMultiValue(ServerFieldType type) {
    714   FieldTypeGroup group = AutofillType(type).group();
    715   return group == NAME ||
    716          group == NAME_BILLING ||
    717          group == EMAIL ||
    718          group == PHONE_HOME ||
    719          group == PHONE_BILLING;
    720 }
    721 
    722 // static
    723 void AutofillProfile::CreateDifferentiatingLabels(
    724     const std::vector<AutofillProfile*>& profiles,
    725     const std::string& app_locale,
    726     std::vector<base::string16>* labels) {
    727   const size_t kMinimalFieldsShown = 2;
    728   CreateInferredLabels(profiles, NULL, UNKNOWN_TYPE, kMinimalFieldsShown,
    729                        app_locale, labels);
    730   DCHECK_EQ(profiles.size(), labels->size());
    731 }
    732 
    733 // static
    734 void AutofillProfile::CreateInferredLabels(
    735     const std::vector<AutofillProfile*>& profiles,
    736     const std::vector<ServerFieldType>* suggested_fields,
    737     ServerFieldType excluded_field,
    738     size_t minimal_fields_shown,
    739     const std::string& app_locale,
    740     std::vector<base::string16>* labels) {
    741   std::vector<ServerFieldType> fields_to_use;
    742   GetFieldsForDistinguishingProfiles(suggested_fields, excluded_field,
    743                                      &fields_to_use);
    744 
    745   // Construct the default label for each profile. Also construct a map that
    746   // associates each label with the profiles that have this label. This map is
    747   // then used to detect which labels need further differentiating fields.
    748   std::map<base::string16, std::list<size_t> > labels_to_profiles;
    749   for (size_t i = 0; i < profiles.size(); ++i) {
    750     base::string16 label =
    751         profiles[i]->ConstructInferredLabel(fields_to_use,
    752                                             minimal_fields_shown,
    753                                             app_locale);
    754     labels_to_profiles[label].push_back(i);
    755   }
    756 
    757   labels->resize(profiles.size());
    758   for (std::map<base::string16, std::list<size_t> >::const_iterator it =
    759            labels_to_profiles.begin();
    760        it != labels_to_profiles.end(); ++it) {
    761     if (it->second.size() == 1) {
    762       // This label is unique, so use it without any further ado.
    763       base::string16 label = it->first;
    764       size_t profile_index = it->second.front();
    765       (*labels)[profile_index] = label;
    766     } else {
    767       // We have more than one profile with the same label, so add
    768       // differentiating fields.
    769       CreateInferredLabelsHelper(profiles, it->second, fields_to_use,
    770                                  minimal_fields_shown, app_locale, labels);
    771     }
    772   }
    773 }
    774 
    775 void AutofillProfile::GetSupportedTypes(
    776     ServerFieldTypeSet* supported_types) const {
    777   FormGroupList info = FormGroups();
    778   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
    779     (*it)->GetSupportedTypes(supported_types);
    780 }
    781 
    782 void AutofillProfile::GetMultiInfoImpl(
    783     const AutofillType& type,
    784     const std::string& app_locale,
    785     std::vector<base::string16>* values) const {
    786   switch (type.group()) {
    787     case NAME:
    788     case NAME_BILLING:
    789       CopyItemsToValues(type, name_, app_locale, values);
    790       break;
    791     case EMAIL:
    792       CopyItemsToValues(type, email_, app_locale, values);
    793       break;
    794     case PHONE_HOME:
    795     case PHONE_BILLING:
    796       CopyItemsToValues(type, phone_number_, app_locale, values);
    797       break;
    798     default:
    799       values->resize(1);
    800       (*values)[0] = GetFormGroupInfo(*this, type, app_locale);
    801   }
    802 }
    803 
    804 base::string16 AutofillProfile::ConstructInferredLabel(
    805     const std::vector<ServerFieldType>& included_fields,
    806     size_t num_fields_to_use,
    807     const std::string& app_locale) const {
    808   base::string16 separator =
    809       l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR);
    810 
    811   AutofillType region_code_type(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
    812   const base::string16& profile_region_code =
    813       GetInfo(region_code_type, app_locale);
    814   std::string address_region_code = UTF16ToUTF8(profile_region_code);
    815 
    816   // A copy of |this| pruned down to contain only data for the address fields in
    817   // |included_fields|.
    818   AutofillProfile trimmed_profile(guid(), origin());
    819   trimmed_profile.SetInfo(region_code_type, profile_region_code, app_locale);
    820   trimmed_profile.set_language_code(language_code());
    821 
    822   std::vector<ServerFieldType> remaining_fields;
    823   for (std::vector<ServerFieldType>::const_iterator it =
    824            included_fields.begin();
    825        it != included_fields.end() && num_fields_to_use > 0;
    826        ++it) {
    827     AddressField address_field;
    828     if (!i18n::FieldForType(*it, &address_field) ||
    829         !::i18n::addressinput::IsFieldUsed(
    830             address_field, address_region_code) ||
    831         address_field == ::i18n::addressinput::COUNTRY) {
    832       remaining_fields.push_back(*it);
    833       continue;
    834     }
    835 
    836     AutofillType autofill_type(*it);
    837     const base::string16& field_value = GetInfo(autofill_type, app_locale);
    838     if (field_value.empty())
    839       continue;
    840 
    841     trimmed_profile.SetInfo(autofill_type, field_value, app_locale);
    842     --num_fields_to_use;
    843   }
    844 
    845   scoped_ptr<AddressData> address_data =
    846       i18n::CreateAddressDataFromAutofillProfile(trimmed_profile, app_locale);
    847   std::string address_line;
    848   ::i18n::addressinput::GetFormattedNationalAddressLine(
    849       *address_data, &address_line);
    850   base::string16 label = base::UTF8ToUTF16(address_line);
    851 
    852   for (std::vector<ServerFieldType>::const_iterator it =
    853            remaining_fields.begin();
    854        it != remaining_fields.end() && num_fields_to_use > 0;
    855        ++it) {
    856     const base::string16& field_value = GetInfo(AutofillType(*it), app_locale);
    857     if (field_value.empty())
    858       continue;
    859 
    860     if (!label.empty())
    861       label.append(separator);
    862 
    863     label.append(field_value);
    864     --num_fields_to_use;
    865   }
    866 
    867   // If country code is missing, libaddressinput won't be used to format the
    868   // address. In this case the suggestion might include a multi-line street
    869   // address which needs to be flattened.
    870   base::ReplaceChars(label, base::ASCIIToUTF16("\n"), separator, &label);
    871 
    872   return label;
    873 }
    874 
    875 // static
    876 void AutofillProfile::CreateInferredLabelsHelper(
    877     const std::vector<AutofillProfile*>& profiles,
    878     const std::list<size_t>& indices,
    879     const std::vector<ServerFieldType>& fields,
    880     size_t num_fields_to_include,
    881     const std::string& app_locale,
    882     std::vector<base::string16>* labels) {
    883   // For efficiency, we first construct a map of fields to their text values and
    884   // each value's frequency.
    885   std::map<ServerFieldType,
    886            std::map<base::string16, size_t> > field_text_frequencies_by_field;
    887   for (std::vector<ServerFieldType>::const_iterator field = fields.begin();
    888        field != fields.end(); ++field) {
    889     std::map<base::string16, size_t>& field_text_frequencies =
    890         field_text_frequencies_by_field[*field];
    891 
    892     for (std::list<size_t>::const_iterator it = indices.begin();
    893          it != indices.end(); ++it) {
    894       const AutofillProfile* profile = profiles[*it];
    895       base::string16 field_text =
    896           profile->GetInfo(AutofillType(*field), app_locale);
    897 
    898       // If this label is not already in the map, add it with frequency 0.
    899       if (!field_text_frequencies.count(field_text))
    900         field_text_frequencies[field_text] = 0;
    901 
    902       // Now, increment the frequency for this label.
    903       ++field_text_frequencies[field_text];
    904     }
    905   }
    906 
    907   // Now comes the meat of the algorithm. For each profile, we scan the list of
    908   // fields to use, looking for two things:
    909   //  1. A (non-empty) field that differentiates the profile from all others
    910   //  2. At least |num_fields_to_include| non-empty fields
    911   // Before we've satisfied condition (2), we include all fields, even ones that
    912   // are identical across all the profiles. Once we've satisfied condition (2),
    913   // we only include fields that that have at last two distinct values.
    914   for (std::list<size_t>::const_iterator it = indices.begin();
    915        it != indices.end(); ++it) {
    916     const AutofillProfile* profile = profiles[*it];
    917 
    918     std::vector<ServerFieldType> label_fields;
    919     bool found_differentiating_field = false;
    920     for (std::vector<ServerFieldType>::const_iterator field = fields.begin();
    921          field != fields.end(); ++field) {
    922       // Skip over empty fields.
    923       base::string16 field_text =
    924           profile->GetInfo(AutofillType(*field), app_locale);
    925       if (field_text.empty())
    926         continue;
    927 
    928       std::map<base::string16, size_t>& field_text_frequencies =
    929           field_text_frequencies_by_field[*field];
    930       found_differentiating_field |=
    931           !field_text_frequencies.count(base::string16()) &&
    932           (field_text_frequencies[field_text] == 1);
    933 
    934       // Once we've found enough non-empty fields, skip over any remaining
    935       // fields that are identical across all the profiles.
    936       if (label_fields.size() >= num_fields_to_include &&
    937           (field_text_frequencies.size() == 1))
    938         continue;
    939 
    940       label_fields.push_back(*field);
    941 
    942       // If we've (1) found a differentiating field and (2) found at least
    943       // |num_fields_to_include| non-empty fields, we're done!
    944       if (found_differentiating_field &&
    945           label_fields.size() >= num_fields_to_include)
    946         break;
    947     }
    948 
    949     (*labels)[*it] = profile->ConstructInferredLabel(
    950         label_fields, label_fields.size(), app_locale);
    951   }
    952 }
    953 
    954 AutofillProfile::FormGroupList AutofillProfile::FormGroups() const {
    955   FormGroupList v(5);
    956   v[0] = &name_[0];
    957   v[1] = &email_[0];
    958   v[2] = &company_;
    959   v[3] = &phone_number_[0];
    960   v[4] = &address_;
    961   return v;
    962 }
    963 
    964 const FormGroup* AutofillProfile::FormGroupForType(
    965     const AutofillType& type) const {
    966   return const_cast<AutofillProfile*>(this)->MutableFormGroupForType(type);
    967 }
    968 
    969 FormGroup* AutofillProfile::MutableFormGroupForType(const AutofillType& type) {
    970   switch (type.group()) {
    971     case NAME:
    972     case NAME_BILLING:
    973       return &name_[0];
    974 
    975     case EMAIL:
    976       return &email_[0];
    977 
    978     case COMPANY:
    979       return &company_;
    980 
    981     case PHONE_HOME:
    982     case PHONE_BILLING:
    983       return &phone_number_[0];
    984 
    985     case ADDRESS_HOME:
    986     case ADDRESS_BILLING:
    987       return &address_;
    988 
    989     case NO_GROUP:
    990     case CREDIT_CARD:
    991     case PASSWORD_FIELD:
    992     case TRANSACTION:
    993         return NULL;
    994   }
    995 
    996   NOTREACHED();
    997   return NULL;
    998 }
    999 
   1000 // So we can compare AutofillProfiles with EXPECT_EQ().
   1001 std::ostream& operator<<(std::ostream& os, const AutofillProfile& profile) {
   1002   return os
   1003       << profile.guid()
   1004       << " "
   1005       << profile.origin()
   1006       << " "
   1007       << UTF16ToUTF8(MultiString(profile, NAME_FIRST))
   1008       << " "
   1009       << UTF16ToUTF8(MultiString(profile, NAME_MIDDLE))
   1010       << " "
   1011       << UTF16ToUTF8(MultiString(profile, NAME_LAST))
   1012       << " "
   1013       << UTF16ToUTF8(MultiString(profile, EMAIL_ADDRESS))
   1014       << " "
   1015       << UTF16ToUTF8(profile.GetRawInfo(COMPANY_NAME))
   1016       << " "
   1017       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE1))
   1018       << " "
   1019       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE2))
   1020       << " "
   1021       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY))
   1022       << " "
   1023       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY))
   1024       << " "
   1025       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE))
   1026       << " "
   1027       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP))
   1028       << " "
   1029       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE))
   1030       << " "
   1031       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))
   1032       << " "
   1033       << profile.language_code()
   1034       << " "
   1035       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
   1036 }
   1037 
   1038 }  // namespace autofill
   1039