Adds feature flag to disable AutofillProfileComparator for card name.

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 1182 matching lines @@
   // 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.
   const base::string16 card_name =
       card.GetInfo(AutofillType(CREDIT_CARD_NAME_FULL), app_locale_);
   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()) {
+    bool found_conflicting_names = false;
+    if (base::FeatureList::IsEnabled(
+            kAutofillUpstreamUseAutofillProfileComparatorForName)) {
+      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())
+          continue;
         if (verified_name.empty() ||
             comparator.IsNameVariantOf(address_name, verified_name)) {
           verified_name = address_name;
         } else if (!comparator.IsNameVariantOf(verified_name, address_name)) {
-          if (!upload_decision_metrics)
-            *rappor_metric_name =
-                "Autofill.CardUploadNotOfferedConflictingNames";
-          upload_decision_metrics |=
-              AutofillMetrics::UPLOAD_NOT_OFFERED_CONFLICTING_NAMES;
+          found_conflicting_names = true;
+          break;
+        }
+      }
+    } else {
+      verified_name = RemoveMiddleInitial(card_name);
+      for (const AutofillProfile& profile : candidate_profiles) {
+        const base::string16 address_name = RemoveMiddleInitial(
+            profile.GetInfo(AutofillType(NAME_FULL), app_locale_));
+        if (address_name.empty())
+          continue;
+        if (verified_name.empty()) {
+          verified_name = address_name;
+        } else if (!base::EqualsCaseInsensitiveASCII(verified_name,
+                                                     address_name)) {
+          found_conflicting_names = true;
           break;
         }
       }
     }
+    if (found_conflicting_names) {
+      if (!upload_decision_metrics)
+        *rappor_metric_name = "Autofill.CardUploadNotOfferedConflictingNames";
+      upload_decision_metrics |=
+          AutofillMetrics::UPLOAD_NOT_OFFERED_CONFLICTING_NAMES;
+    }
   }
 
   // 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;
   }
 
@@ skipping 893 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