Hook up Autofill Backend interface to SyncableServices

chrome/browser/sync/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 <set>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 126 matching lines @@
   return (profile.Compare(arg) == 0);
 }
 
 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)
+      : web_database_(web_database),
+        on_changed_(on_changed) {
+  }
+
+  virtual ~MockAutofillBackend() {}
+  virtual WebDatabase* GetDatabase() OVERRIDE { return web_database_; }
+  virtual void AddObserver(
+      autofill::AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE {}
+  virtual void RemoveObserver(
+      autofill::AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE {}
+  virtual void RemoveExpiredFormElements() OVERRIDE {}
+  virtual void NotifyOfMultipleAutofillChanges() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, on_changed_);
+  }
+
+ private:
+  WebDatabase* web_database_;
+  base::Closure on_changed_;
+};
+
 class ProfileSyncServiceAutofillTest;
 
 template<class AutofillProfile>
 syncer::ModelType GetModelType() {
   return syncer::UNSPECIFIED;
 }
 
 template<>
 syncer::ModelType GetModelType<AutofillEntry>() {
   return syncer::AUTOFILL;
@@ skipping 42 matching lines @@
         syncable_service_created_or_destroyed_(false, false) {
   }
 
   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());
+
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&WebDataServiceFake::CreateSyncableService,
-                   base::Unretained(this)));
+                   base::Unretained(this),
+                   on_changed_callback));
     syncable_service_created_or_destroyed_.Wait();
   }
 
   void ShutdownSyncableService() {
     // The |autofill_profile_syncable_service_| must be destructed on the DB
     // thread.
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&WebDataServiceFake::DestroySyncableService,
                    base::Unretained(this)));
     syncable_service_created_or_destroyed_.Wait();
@@ skipping 33 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
  private:
   virtual ~WebDataServiceFake() {}
 
-  void CreateSyncableService() {
+  void CreateSyncableService(const base::Closure& on_changed_callback) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
-    AutocompleteSyncableService::CreateForWebDataService(this);
-    AutofillProfileSyncableService::CreateForWebDataService(this, "en-US");
+    backend_.reset(new MockAutofillBackend(
+        GetDatabase(), on_changed_callback));
+    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);
 
     syncable_service_created_or_destroyed_.Signal();
   }
 
   void DestroySyncableService() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     AutofillWebDataService::ShutdownOnDBThread();
     autocomplete_syncable_service_ = NULL;
     autofill_profile_syncable_service_ = NULL;
+    backend_.reset();
     syncable_service_created_or_destroyed_.Signal();
   }
 
   WebDatabase* web_database_;
   AutocompleteSyncableService* autocomplete_syncable_service_;
   AutofillProfileSyncableService* autofill_profile_syncable_service_;
+  scoped_ptr<autofill::AutofillWebDataBackend> backend_;
 
   WaitableEvent syncable_service_created_or_destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDataServiceFake);
 };
 
 BrowserContextKeyedService* BuildMockWebDataServiceWrapper(
     content::BrowserContext* profile) {
   return new MockWebDataServiceWrapper(
       new TokenWebDataServiceFake(),
@@ skipping 1064 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();
   }
 }