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

components/browser_sync/browser/profile_sync_service_autofill_unittest.cc

 // Copyright 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 27 matching lines @@
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/browser_sync/browser/abstract_profile_sync_service_test.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/browser_sync/browser/test_profile_sync_service.h"
 #include "components/sync_driver/data_type_controller.h"
 #include "components/sync_driver/data_type_manager_impl.h"
 #include "components/sync_driver/sync_api_component_factory_mock.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
+#include "components/version_info/version_info.h"
 #include "components/webdata/common/web_database.h"
 #include "components/webdata_services/web_data_service_test_util.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/data_type_debug_info_listener.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/syncable/mutable_entry.h"
@@ skipping 35 matching lines @@
 using testing::Not;
 using testing::SetArgumentPointee;
 using testing::Return;
 
 namespace {
 
 void RegisterAutofillPrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(autofill::prefs::kAutofillEnabled, true);
   registry->RegisterBooleanPref(autofill::prefs::kAutofillWalletImportEnabled,
                                 true);
+  registry->RegisterIntegerPref(autofill::prefs::kAutofillLastVersionDeduped,
+                                atoi(version_info::GetVersionNumber().c_str()));
 }
 
 void RunAndSignal(const base::Closure& cb, WaitableEvent* event) {
   cb.Run();
   event->Signal();
 }
 
 AutofillEntry MakeAutofillEntry(const char* name,
                                 const char* value,
                                 int time_shift0,
@@ skipping 49 matching lines @@
 
 class WebDatabaseFake : public WebDatabase {
  public:
   explicit WebDatabaseFake(AutofillTable* autofill_table) {
     AddTable(autofill_table);
   }
 };
 
 class MockAutofillBackend : public autofill::AutofillWebDataBackend {
  public:
-  MockAutofillBackend(WebDatabase* web_database,
-                      const base::Closure& on_changed,
-                      const scoped_refptr<base::SequencedTaskRunner>& ui_thread)
+  MockAutofillBackend(
+      WebDatabase* web_database,
+      const base::Closure& on_changed,
+      const base::Callback<void(syncer::ModelType)>& on_sync_started,
+      const scoped_refptr<base::SequencedTaskRunner>& ui_thread)
       : web_database_(web_database),
         on_changed_(on_changed),
+        on_sync_started_(on_sync_started),
         ui_thread_(ui_thread) {}
 
   ~MockAutofillBackend() override {}
   WebDatabase* GetDatabase() override { return web_database_; }
   void AddObserver(
       autofill::AutofillWebDataServiceObserverOnDBThread* observer) override {}
   void RemoveObserver(
       autofill::AutofillWebDataServiceObserverOnDBThread* observer) override {}
   void RemoveExpiredFormElements() override {}
   void NotifyOfMultipleAutofillChanges() override {
     DCHECK(!ui_thread_->RunsTasksOnCurrentThread());
     ui_thread_->PostTask(FROM_HERE, on_changed_);
   }
+  void NotifyThatSyncHasStarted(syncer::ModelType model_type) override {
+    DCHECK(!ui_thread_->RunsTasksOnCurrentThread());
+    ui_thread_->PostTask(FROM_HERE, base::Bind(on_sync_started_, model_type));
+  }
 
  private:
   WebDatabase* web_database_;
   base::Closure on_changed_;
+  base::Callback<void(syncer::ModelType)> on_sync_started_;
   const scoped_refptr<base::SequencedTaskRunner> ui_thread_;
 };
 
 class ProfileSyncServiceAutofillTest;
 
 template<class AutofillProfile>
 syncer::ModelType GetModelType() {
   return syncer::UNSPECIFIED;
 }
 
@@ skipping 52 matching lines @@
   void SetDatabase(WebDatabase* web_database) {
     web_database_ = web_database;
   }
 
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
     const base::Closure& on_changed_callback = base::Bind(
         &WebDataServiceFake::NotifyAutofillMultipleChangedOnUIThread,
         AsWeakPtr());
+    const base::Callback<void(syncer::ModelType)> on_sync_started_callback =
+        base::Bind(&WebDataServiceFake::NotifySyncStartedOnUIThread,
+                   AsWeakPtr());
 
-    db_thread_->PostTask(
-        FROM_HERE, base::Bind(&WebDataServiceFake::CreateSyncableService,
-                              base::Unretained(this), on_changed_callback));
+    db_thread_->PostTask(FROM_HERE,
+                         base::Bind(&WebDataServiceFake::CreateSyncableService,
+                                    base::Unretained(this), on_changed_callback,
+                                    on_sync_started_callback));
     syncable_service_created_or_destroyed_.Wait();
   }
 
   void ShutdownSyncableService() {
     // The |autofill_profile_syncable_service_| must be destructed on the DB
     // thread.
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&WebDataServiceFake::DestroySyncableService,
                                     base::Unretained(this)));
     syncable_service_created_or_destroyed_.Wait();
@@ skipping 25 matching lines @@
                    base::Unretained(autofill_profile_syncable_service_),
                    changes);
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
  private:
   ~WebDataServiceFake() override {}
 
-  void CreateSyncableService(const base::Closure& on_changed_callback) {
+  void CreateSyncableService(
+      const base::Closure& on_changed_callback,
+      const base::Callback<void(syncer::ModelType)>& on_sync_started) {
     ASSERT_TRUE(db_thread_->RunsTasksOnCurrentThread());
     // These services are deleted in DestroySyncableService().
     backend_.reset(new MockAutofillBackend(GetDatabase(), on_changed_callback,
-                                           ui_thread_.get()));
+                                           on_sync_started, ui_thread_.get()));
     AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
         this, backend_.get());
     AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
         this, backend_.get(), "en-US");
 
     autocomplete_syncable_service_ =
         AutocompleteSyncableService::FromWebDataService(this);
     autofill_profile_syncable_service_ =
         AutofillProfileSyncableService::FromWebDataService(this);
 
@@ skipping 1131 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }