[Autofill] Run autofill-profile de-dupe after sync starts if sync is enabled.

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 21 matching lines @@
 #include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/browser/phone_number_i18n.h"
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/signin_pref_names.h"
+#include "components/sync_driver/sync_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "components/version_info/version_info.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_formatter.h"
 
 namespace autofill {
 namespace {
 
 using ::i18n::addressinput::AddressField;
 using ::i18n::addressinput::GetStreetAddressLinesAsSingleLine;
@@ skipping 228 matching lines @@
     AutofillMetrics::LogIsAutofillEnabledAtStartup(IsAutofillEnabled());
 
   // WebDataService may not be available in tests.
   if (!database_.get())
     return;
 
   LoadProfiles();
   LoadCreditCards();
 
   database_->AddObserver(this);
+  is_autofill_profile_dedupe_pending_ = IsAutofillProfileCleanupEnabled();
 }
 
 PersonalDataManager::~PersonalDataManager() {
   CancelPendingQuery(&pending_profiles_query_);
   CancelPendingQuery(&pending_server_profiles_query_);
   CancelPendingQuery(&pending_creditcards_query_);
   CancelPendingQuery(&pending_server_creditcards_query_);
 
   if (database_.get())
     database_->RemoveObserver(this);
 }
 
+void PersonalDataManager::OnSyncServiceConfigured(
+    sync_driver::SyncService* sync_service) {
+  // We want to know if we when, if at all, we need to run autofill profile

[sebsg, 2016/07/12 18:59:53]

nit: We want to know if we when, ... -> We want to know when, ... ?

[Roger McFarlane (Chromium), 2016/07/12 19:52:48]

Done.

+  // de-duplication: now or after waiting until sync has started.
+  if (!is_autofill_profile_dedupe_pending_) {
+    // De-duplication isn't enabled.
+    return;
+  }
+
+  // If the sync service is configured to start and to sync autofill profiles,
+  // then we can just let the notification that sync has started trigger the
+  // de-duplication.
+  if (sync_service && sync_service->CanSyncStart() &&
+      sync_service->GetPreferredDataTypes().Has(syncer::AUTOFILL_PROFILE)) {
+    return;
+  }
+
+  // Otherwise, Refresh() will attempt the de-duplication now.
+  Refresh();
+}
+
 void PersonalDataManager::OnWebDataServiceRequestDone(
     WebDataServiceBase::Handle h,
     const WDTypedResult* result) {
   DCHECK(pending_profiles_query_ || pending_server_profiles_query_ ||
          pending_creditcards_query_ || pending_server_creditcards_query_);
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 PersonalDataManager::OnWebDataServiceRequestDone"));
 
   if (!result) {
     // Error from the web database.
     if (h == pending_creditcards_query_)
       pending_creditcards_query_ = 0;
     else if (h == pending_profiles_query_)
       pending_profiles_query_ = 0;
     return;
   }
 
   switch (result->GetType()) {
     case AUTOFILL_PROFILES_RESULT:
       if (h == pending_profiles_query_) {
         ReceiveLoadedDbValues(h, result, &pending_profiles_query_,
                               &web_profiles_);
         LogProfileCount();  // This only logs local profiles.
-        // Since these two routines both re-launch the database queries, don't
-        // run them on the same query response.
-        if (!ApplyDedupingRoutine())
-          ApplyProfileUseDatesFix();
+        ApplyProfileUseDatesFix();
       } else {
         ReceiveLoadedDbValues(h, result, &pending_server_profiles_query_,
                               &server_profiles_);
 
         if (!server_profiles_.empty()) {
           std::string account_id = signin_manager_->GetAuthenticatedAccountId();
           base::string16 email =
               base::UTF8ToUTF16(
                   account_tracker_->GetAccountInfo(account_id).email);
 
@@ skipping 374 matching lines @@
     credit_cards_.insert(credit_cards_.end(), server_credit_cards_.begin(),
                          server_credit_cards_.end());
   }
   return credit_cards_;
 }
 
 bool PersonalDataManager::HasServerData() const {
   return !server_credit_cards_.empty() || !server_profiles_.empty();
 }
 
 void PersonalDataManager::Refresh() {

[Mathieu, 2016/07/12 18:10:12]

Refresh is called all over the place in this file. Could there be a more
appropriate place to start the dedupe? I don't know that it's guaranteed that
sync is initialized at this point.

[Roger McFarlane (Chromium), 2016/07/12 18:42:19]

Done.

+  if (is_autofill_profile_dedupe_pending_)
+    ApplyDedupingRoutine();
+
   LoadProfiles();
   LoadCreditCards();
 }
 
 const std::vector<AutofillProfile*> PersonalDataManager::GetProfilesToSuggest()
     const {
   std::vector<AutofillProfile*> profiles = GetProfiles(true);
 
   // Rank the suggestions by frecency (see AutofillDataModel for details).
   base::Time comparison_time = base::Time::Now();
@@ skipping 861 matching lines @@
   }
 
   // Set the pref so that this fix is never run again.
   pref_service_->SetBoolean(prefs::kAutofillProfileUseDatesFixed, true);
 
   if (has_changed_data)
     SetProfiles(&profiles);
 }
 
 bool PersonalDataManager::ApplyDedupingRoutine() {
-  if (!IsAutofillProfileCleanupEnabled())
+  if (!is_autofill_profile_dedupe_pending_) {
     return false;
+  }
 
-  int current_major_version = atoi(version_info::GetVersionNumber().c_str());
+  DCHECK(IsAutofillProfileCleanupEnabled());
+  is_autofill_profile_dedupe_pending_ = false;
 
   // Check if the deduping routine has already been run on this major version.
+  int current_major_version = atoi(version_info::GetVersionNumber().c_str());
   if (pref_service_->GetInteger(prefs::kAutofillLastVersionDeduped) >=
-      current_major_version)
+      current_major_version) {
+    VLOG(1)
+        << "Autofill profile de-duplication already performed for this version";
     return false;
+  }
 
+  VLOG(1) << "Starting autofill profile de-duplication.";
   std::vector<AutofillProfile*> existing_profiles = web_profiles_.get();
   std::unordered_set<AutofillProfile*> profiles_to_delete;
   profiles_to_delete.reserve(existing_profiles.size());
 
   DedupeProfiles(&existing_profiles, &profiles_to_delete);
 
   // Apply the changes to the database.
   for (AutofillProfile* profile : existing_profiles) {
     // If the profile was set to be deleted, remove it from the database.
     if (profiles_to_delete.count(profile)) {
       database_->RemoveAutofillProfile(profile->guid());
     } else {
       // Otherwise, update the profile in the database.
       database_->UpdateAutofillProfile(*profile);
     }
   }
 
   // Set the pref to the current major version.
   pref_service_->SetInteger(prefs::kAutofillLastVersionDeduped,
                             current_major_version);
 
-  // Refresh the local cache and send notifications to observers.
-  Refresh();
-
   return true;
 }
 
 void PersonalDataManager::DedupeProfiles(
     std::vector<AutofillProfile*>* existing_profiles,
     std::unordered_set<AutofillProfile*>* profiles_to_delete) {
   AutofillMetrics::LogNumberOfProfilesConsideredForDedupe(
       existing_profiles->size());
 
   // Sort the profiles by frecency with all the verified profiles at the end.
@@ skipping 59 matching lines @@
         if (profile_to_merge->IsVerified())
           break;
       }
     }
   }
   AutofillMetrics::LogNumberOfProfilesRemovedDuringDedupe(
       profiles_to_delete->size());
 }
 
 }  // namespace autofill