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 22 matching lines @@
 #include "chrome/browser/sync/profile_sync_components_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/browser/webdata/autocomplete_syncable_service.h"
 #include "chrome/browser/webdata/autofill_profile_syncable_service.h"
 #include "chrome/browser/webdata/web_data_service_factory.h"
 #include "components/autofill/browser/autofill_common_test.h"
 #include "components/autofill/browser/personal_data_manager.h"
+#include "components/autofill/browser/webdata/autofill_backend_delegate.h"
 #include "components/autofill/browser/webdata/autofill_change.h"
 #include "components/autofill/browser/webdata/autofill_entry.h"
 #include "components/autofill/browser/webdata/autofill_table.h"
+#include "components/autofill/browser/webdata/autofill_webdata_backend.h"
 #include "components/autofill/browser/webdata/autofill_webdata_service.h"
 #include "components/webdata/common/web_data_service_test_util.h"
 #include "components/webdata/common/web_database.h"
 #include "content/public/test/test_browser_thread.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "sync/internal_api/public/base/model_type.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"
@@ skipping 79 matching lines @@
 
 MATCHER_P(MatchProfiles, profile, "") {
   return (profile.Compare(arg) == 0);
 }
 
 class WebDatabaseFake : public WebDatabase {
  public:
   explicit WebDatabaseFake(AutofillTable* autofill_table) {
     AddTable(autofill_table);
   }
+
+  void DetachFromThread() {
+    weak_ptr_factory_.DetachFromThread();
+  }
+
 };
 
 class ProfileSyncServiceAutofillTest;
 
 template<class AutofillProfile>
 syncer::ModelType GetModelType() {
   return syncer::UNSPECIFIED;
 }
 
 template<>
@@ skipping 64 matching lines @@
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&WebDataServiceFake::DestroySyncableService,
                    base::Unretained(this)));
     syncable_service_created_or_destroyed_.Wait();
   }
 
   virtual bool IsDatabaseLoaded() OVERRIDE {
     return true;
   }
 
-  virtual WebDatabase* GetDatabase() OVERRIDE {
+  WebDatabase* GetDatabase() {
     return web_database_;
   }
 
   virtual void ShutdownOnUIThread() OVERRIDE {}
 
   void OnAutofillEntriesChanged(const AutofillChangeList& changes) {
     WaitableEvent event(true, false);
 
     base::Closure notify_cb =
         base::Bind(&AutocompleteSyncableService::AutofillEntriesChanged,
@@ skipping 19 matching lines @@
         base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
  private:
   virtual ~WebDataServiceFake() {}
 
   void CreateSyncableService() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
-    AutocompleteSyncableService::CreateForWebDataService(this);
-    AutofillProfileSyncableService::CreateForWebDataService(this, "en-US");
+    delegate_.reset(new autofill::AutofillBackendDelegate(
+            GetDatabase()->AsWeakPtr(),
+            base::WeakPtr<autofill::AutofillWebDataBackend>()));
+    AutocompleteSyncableService::CreateForWebDataService(this, delegate_.get());
+    AutofillProfileSyncableService::CreateForWebDataService(
+        this, delegate_.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;
+    delegate_.reset();
     syncable_service_created_or_destroyed_.Signal();
   }
 
   WebDatabase* web_database_;
   AutocompleteSyncableService* autocomplete_syncable_service_;
   AutofillProfileSyncableService* autofill_profile_syncable_service_;
-
+  scoped_ptr<autofill::AutofillBackendDelegate> delegate_;
   WaitableEvent syncable_service_created_or_destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDataServiceFake);
 };
 
 ProfileKeyedService* BuildMockWebDataServiceWrapper(Profile* profile) {
   return new MockWebDataServiceWrapper(
       new TokenWebDataServiceFake(),
       new WebDataServiceFake());
 }
@@ skipping 193 matching lines @@
 
     web_data_service_->StartSyncableService();
   }
 
   virtual void TearDown() OVERRIDE {
     // Note: The tear down order is important.
     ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(
         profile_.get(), NULL);
     web_data_service_->ShutdownSyncableService();
     web_data_service_ = NULL;
+    web_database_->DetachFromThread();
     profile_->ResetRequestContext();
     // To prevent a leak, fully release TestURLRequestContext to ensure its
     // destruction on the IO message loop.
     profile_.reset();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
 
   int GetSyncCount(syncer::ModelType type) {
     syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
@@ skipping 850 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();
   }
 }