[Autofill] Improve the merging of two profiles' names.

components/autofill/core/browser/autofill_profile.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/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <memory>
@@ skipping 481 matching lines @@
         !imported_name.GetRawInfo(NAME_FULL).empty()) {
       name_.SetRawInfo(NAME_FULL, imported_name.GetRawInfo(NAME_FULL));
       return true;
     }
     return false;
   }
 
   l10n::CaseInsensitiveCompare compare;
   AutofillType type = AutofillType(NAME_FULL);
   base::string16 full_name = name_.GetInfo(type, app_locale);
-  if (compare.StringsEqual(full_name,
+  // Always overwrite if the name parts are empty.
+  if (!name_.NamePartsAreEmpty() &&
+      compare.StringsEqual(full_name,
                            imported_name.GetInfo(type, app_locale))) {
     // The imported name has the same full name string as the name for this
     // profile.  Because full names are _heuristically_ parsed into
     // {first, middle, last} name components, it's possible that either the
     // existing name or the imported name was misparsed.  Prefer to keep the
     // name whose {first, middle, last} components do not match those computed
     // by the heuristic parse, as this more likely represents the correct,
     // user-input parse of the name.
     NameInfo heuristically_parsed_name;
     heuristically_parsed_name.SetInfo(type, full_name, app_locale);
     if (imported_name.ParsedNamesAreEqual(heuristically_parsed_name))
       return false;
   }
 
-  name_ = imported_name;
+  name_.OverwriteName(imported_name);
   return true;
 }
 
 bool AutofillProfile::OverwriteWith(const AutofillProfile& profile,
                                     const std::string& app_locale) {
   // Verified profiles should never be overwritten with unverified data.
   DCHECK(!IsVerified() || profile.IsVerified());
   set_origin(profile.origin());
   set_language_code(profile.language_code());
   set_use_count(profile.use_count() + use_count());
@@ skipping 50 matching lines @@
   }
 
   return did_overwrite;
 }
 
 bool AutofillProfile::SaveAdditionalInfo(const AutofillProfile& profile,
                                          const std::string& app_locale) {
   ServerFieldTypeSet field_types, other_field_types;
   GetNonEmptyTypes(app_locale, &field_types);
   profile.GetNonEmptyTypes(app_locale, &other_field_types);
+
   // The address needs to be compared line by line to take into account the
   // logic for empty fields implemented in the loop.
   field_types.erase(ADDRESS_HOME_STREET_ADDRESS);
   l10n::CaseInsensitiveCompare compare;
   for (ServerFieldType field_type : field_types) {
     if (other_field_types.count(field_type)) {
       AutofillType type = AutofillType(field_type);
       // Special cases for name and phone. If the whole/full value matches, skip
       // the individual fields comparison.
       if (type.group() == NAME &&
@@ skipping 36 matching lines @@
                 CanonicalizeProfileString(profile.GetRawInfo(field_type)),
                 CanonicalizeProfileString(GetRawInfo(field_type))) &&
             !compare.StringsEqual(CanonicalizeProfileString(profile.GetRawInfo(
                                       ADDRESS_HOME_STREET_ADDRESS)),
                                   CanonicalizeProfileString(GetRawInfo(
                                       ADDRESS_HOME_STREET_ADDRESS)))) {
           return false;
         }
         continue;
       }
+
       // Special case for the state to support abbreviations. Currently only the
       // US states are supported.
       if (field_type == ADDRESS_HOME_STATE) {
         base::string16 full;
         base::string16 abbreviation;
         state_names::GetNameAndAbbreviation(GetRawInfo(ADDRESS_HOME_STATE),
                                             &full, &abbreviation);
         if (compare.StringsEqual(profile.GetRawInfo(ADDRESS_HOME_STATE),
                                  full) ||
             compare.StringsEqual(profile.GetRawInfo(ADDRESS_HOME_STATE),
                                  abbreviation))
           continue;
       }
 
       // Special case for company names to support cannonicalized variations.
       if (field_type == COMPANY_NAME) {
         if (compare.StringsEqual(
                 CanonicalizeProfileString(profile.GetRawInfo(field_type)),
                 CanonicalizeProfileString(GetRawInfo(field_type)))) {
           continue;
         }
       }
 
+      // Special case for middle name to support initials.
+      if (field_type == NAME_MIDDLE) {
+        base::string16 middle_name = GetRawInfo(NAME_MIDDLE);
+        base::string16 profile_middle_name = profile.GetRawInfo(NAME_MIDDLE);
+        // If one of the two middle names is an initial that match the first

[Mathieu, 2016/05/13 13:32:51]

matches

[sebsg, 2016/05/13 17:20:00]

Done.

+        // letter of the other middle name, they are considered equivalent.
+        if ((middle_name.size() == 1 || profile_middle_name.size() == 1) &&

[Mathieu, 2016/05/13 13:32:51]

what if exactly one of |middle_name| or |profile_middle_name| is empty string?
wouldn't checking for index [0] below be invalid?

Or is it a precondition of being in this loop? If so, perhaps a dcheck would be
good, above.

[sebsg, 2016/05/13 17:20:01]

Yes, it's a precondition in the loop. We get the non-empty types from profile.
Then there is a if in the loop that checks if that the type is not empty in
|this|. Dcheck sounds like a super idea, thanks!

+            middle_name[0] == profile_middle_name[0]) {
+          continue;
+        }
+      }
+
       if (!compare.StringsEqual(profile.GetRawInfo(field_type),
                                 GetRawInfo(field_type))) {
         return false;
       }
     }
   }
 
   if (!IsVerified() || profile.IsVerified()) {
     if (OverwriteWith(profile, app_locale)) {
       AutofillMetrics::LogProfileActionOnFormSubmitted(
@@ skipping 389 matching lines @@
             << " " << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY)) << " "
             << profile.language_code() << " "
             << UTF16ToUTF8(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
 }
 
 }  // namespace autofill