Uses AutofillProfileComparator to compare profile names.

components/autofill/core/browser/autofill_manager.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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 105 matching lines @@
 base::string16 SanitizeCreditCardFieldValue(const base::string16& value) {
   base::string16 sanitized;
   base::TrimWhitespace(value, base::TRIM_ALL, &sanitized);
   // Some sites have ____-____-____-____ in their credit card number fields, for
   // example.
   base::ReplaceChars(sanitized, base::ASCIIToUTF16("-_"),
                      base::ASCIIToUTF16(""), &sanitized);
   return sanitized;
 }
 
-// If |name| consists of three whitespace-separated parts and the second of the
-// three parts is a single character or a single character followed by a period,
-// returns the result of joining the first and third parts with a space.
-// Otherwise, returns |name|.
-//
-// Note that a better way to do this would be to use SplitName from
-// src/components/autofill/core/browser/contact_info.cc. However, for now we
-// want the logic of which variations of names are considered to be the same to
-// exactly match the logic applied on the Payments server.
-base::string16 RemoveMiddleInitial(const base::string16& name) {
-  std::vector<base::StringPiece16> parts =
-      base::SplitStringPiece(name, base::kWhitespaceUTF16,
-                             base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  if (parts.size() == 3 && (parts[1].length() == 1 ||
-                            (parts[1].length() == 2 &&
-                             base::EndsWith(parts[1], base::ASCIIToUTF16("."),
-                                            base::CompareCase::SENSITIVE)))) {
-    parts.erase(parts.begin() + 1);
-    return base::JoinString(parts, base::ASCIIToUTF16(" "));
-  }
-  return name;
-}
-
 // Returns whether the |field| is predicted as being any kind of name.
 bool IsNameType(const AutofillField& field) {
   return field.Type().group() == NAME || field.Type().group() == NAME_BILLING ||
          field.Type().GetStorableType() == CREDIT_CARD_NAME_FULL ||
          field.Type().GetStorableType() == CREDIT_CARD_NAME_FIRST ||
          field.Type().GetStorableType() == CREDIT_CARD_NAME_LAST;
 }
 
 // Selects the right name type from the |old_types| to insert into the
 // |new_types| based on |is_credit_card|.
@@ skipping 1146 matching lines @@
     if ((now - profile->use_date()) < fifteen_minutes ||
         (now - profile->modification_date()) < fifteen_minutes) {
       candidate_profiles.push_back(*profile);
     }
   }
   if (candidate_profiles.empty()) {
     upload_decision_metrics |= AutofillMetrics::UPLOAD_NOT_OFFERED_NO_ADDRESS;
     *rappor_metric_name = "Autofill.CardUploadNotOfferedNoAddress";
   }
 
-  // If any of the names on the card or the addresses don't match (where
-  // matching is case insensitive and ignores middle initials if present), the
+  // If any of the names on the card or the addresses don't match the
   // candidate set is invalid. This matches the rules for name matching applied
   // server-side by Google Payments and ensures that we don't send upload
   // requests that are guaranteed to fail.
-  base::string16 verified_name;
   const base::string16 card_name =
       card.GetInfo(AutofillType(CREDIT_CARD_NAME_FULL), app_locale_);
-  if (!card_name.empty()) {
-    verified_name = RemoveMiddleInitial(card_name);
-  }
-  for (const AutofillProfile& profile : candidate_profiles) {
-    const base::string16 address_name =
-        profile.GetInfo(AutofillType(NAME_FULL), app_locale_);
-    if (!address_name.empty()) {
-      if (verified_name.empty()) {
-        verified_name = RemoveMiddleInitial(address_name);
-      } else {
-        // TODO(crbug.com/590307): We'll need to make the name comparison more
-        // sophisticated.
-        if (!base::EqualsCaseInsensitiveASCII(
-                verified_name, RemoveMiddleInitial(address_name))) {
+  base::string16 verified_name;
+  if (candidate_profiles.empty()) {
+    verified_name = card_name;
+  } else {
+    AutofillProfileComparator comparator(app_locale_);
+    verified_name = comparator.NormalizeForComparison(card_name);
+    for (const AutofillProfile& profile : candidate_profiles) {
+      const base::string16 address_name = comparator.NormalizeForComparison(
+          profile.GetInfo(AutofillType(NAME_FULL), app_locale_));
+      if (!address_name.empty()) {
+        if (verified_name.empty() ||
+            comparator.IsNameVariantOf(address_name, verified_name)) {
+          verified_name = address_name;
+        } else if (!comparator.IsNameVariantOf(verified_name, address_name)) {

[Roger McFarlane (Chromium), 2017/05/05 16:05:30]

Would it be helpful to add the bidirectional name variant test  as a method on
the comparator? It's basically the last bits of HaveMergeableNames(), which
could also call that method.

There's also some CJK name handling that you might want to look at. in there as
well.

[csashi, 2017/05/05 16:22:30]

I prefer the current version because I would like to know if full_name_1 can be
derived from full_name_2, or is it vice versa.
AFAIK, We are not enabled in CJK countries yet (may be enabled in Japan - not
sure). So not worried about that just yet.

           if (!upload_decision_metrics)
             *rappor_metric_name =
                 "Autofill.CardUploadNotOfferedConflictingNames";
           upload_decision_metrics |=
               AutofillMetrics::UPLOAD_NOT_OFFERED_CONFLICTING_NAMES;
           break;
         }
       }
     }
   }
+
   // If neither the card nor any of the addresses have a name associated with
   // them, the candidate set is invalid.
   if (verified_name.empty()) {
     if (!upload_decision_metrics)
       *rappor_metric_name = "Autofill.CardUploadNotOfferedNoName";
     upload_decision_metrics |= AutofillMetrics::UPLOAD_NOT_OFFERED_NO_NAME;
   }
 
   // If any of the candidate addresses have a non-empty zip that doesn't match
   // any other non-empty zip, then the candidate set is invalid.
@@ skipping 891 matching lines @@
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 void AutofillManager::LogCardUploadDecisions(int upload_decision_metrics) {
   AutofillMetrics::LogCardUploadDecisionMetrics(upload_decision_metrics);
   AutofillMetrics::LogCardUploadDecisionsUkm(client_->GetUkmService(),
                                              pending_upload_request_url_,
                                              upload_decision_metrics);
 }
 
 }  // namespace autofill