[Autofill] Dedupe similar profiles on insertion.

components/autofill/core/browser/personal_data_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/personal_data_manager.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <list>
 #include <map>
@@ skipping 845 matching lines @@
   if (profile.IsPresentButInvalid(ADDRESS_HOME_STATE))
     return false;
 
   // Reject profiles with invalid US zip information.
   if (profile.IsPresentButInvalid(ADDRESS_HOME_ZIP))
     return false;
 
   return true;
 }
 
-// static
+// TODO(crbug.com/618448): Refactor MergeProfile to not depend on class
+// variables.
 std::string PersonalDataManager::MergeProfile(
     const AutofillProfile& new_profile,
     std::vector<AutofillProfile*> existing_profiles,
     const std::string& app_locale,
     std::vector<AutofillProfile>* merged_profiles) {
   merged_profiles->clear();
 
   // Sort the existing profiles in decreasing order of frecency, so the "best"
   // profiles are checked first.
   base::Time comparison_time = base::Time::Now();
   std::sort(existing_profiles.begin(), existing_profiles.end(),
             [comparison_time](const AutofillDataModel* a,
                               const AutofillDataModel* b) {
               return a->CompareFrecency(b, comparison_time);
             });
 
   // Set to true if |existing_profiles| already contains an equivalent profile.
   bool matching_profile_found = false;
   std::string guid = new_profile.guid();
 
   // If we have already saved this address, merge in any missing values.
   // Only merge with the first match.
   for (AutofillProfile* existing_profile : existing_profiles) {
-    if (!matching_profile_found && !new_profile.PrimaryValue().empty() &&
+    if (!matching_profile_found &&
+        !new_profile.PrimaryValue(app_locale_).empty() &&
         existing_profile->SaveAdditionalInfo(new_profile, app_locale)) {
       // Unverified profiles should always be updated with the newer data,
       // whereas verified profiles should only ever be overwritten by verified
       // data.  If an automatically aggregated profile would overwrite a
       // verified profile, just drop it.
       matching_profile_found = true;
       guid = existing_profile->guid();
 
+      // Look for duplicates of |existing_profile| to merge into.
+      FindMergeAndDeleteDuplicateProfiles(existing_profiles, existing_profile);
+
       // We set the modification date so that immediate requests for profiles
       // will properly reflect the fact that this profile has been modified
       // recently. After writing to the database and refreshing the local copies
       // the profile will have a very slightly newer time reflecting what's
       // actually stored in the database.
       existing_profile->set_modification_date(base::Time::Now());
     }
     merged_profiles->push_back(*existing_profile);
   }
 
@@ skipping 596 matching lines @@
   if (IsFeatureSubstringMatchEnabled()) {
     std::stable_sort(suggestions.begin(), suggestions.end(),
                      [](const Suggestion& a, const Suggestion& b) {
                        return a.match < b.match;
                      });
   }
 
   return suggestions;
 }
 
+void PersonalDataManager::FindMergeAndDeleteDuplicateProfiles(
+    const std::vector<AutofillProfile*>& existing_profiles,
+    AutofillProfile* profile_to_merge) {
+  std::vector<std::string> profile_guids_to_delete;
+
+  FindAndMergeDuplicateProfiles(existing_profiles, profile_to_merge,
+                                &profile_guids_to_delete);
+
+  // Delete the duplicate profiles.
+  for (std::string profile_guid_to_delete : profile_guids_to_delete) {

[Roger McFarlane (Chromium), 2016/06/13 15:12:52]

const ref

[sebsg, 2016/06/13 17:57:59]

Done.

+    RemoveByGUID(profile_guid_to_delete);
+  }
+}
+
+void PersonalDataManager::FindAndMergeDuplicateProfiles(
+    const std::vector<AutofillProfile*>& existing_profiles,
+    AutofillProfile* profile_to_merge,
+    std::vector<std::string>* profile_guids_to_delete) {
+  for (AutofillProfile* existing_profile : existing_profiles) {
+    // Don't try to merge a profile with itself or with any profile with a
+    // different PrimaryValue.
+    if (existing_profile->guid() != profile_to_merge->guid() &&
+        AutofillProfile::CanonicalizeProfileString(
+            existing_profile->PrimaryValue(app_locale_)) ==
+            AutofillProfile::CanonicalizeProfileString(
+                profile_to_merge->PrimaryValue(app_locale_))) {
+      if (existing_profile->SaveAdditionalInfo(*profile_to_merge,
+                                               app_locale_)) {
+        // Since |profile_to_merge| was a duplicate of |existing_profile| and
+        // was merged sucessfully, it can now be deleted.
+        profile_guids_to_delete->push_back(profile_to_merge->guid());
+
+        // Now try to merge the new resulting profile with the rest of the
+        // existing profiles.
+        profile_to_merge = existing_profile;
+      }
+    }
+  }
+}
+
 }  // namespace autofill