Moved WebDataService to ProfileKeyedService

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

 // Copyright (c) 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 28 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_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_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
 #include "chrome/browser/webdata/autofill_profile_syncable_service.h"
 #include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/web_database.h"
+#include "chrome/browser/webdata/web_data_service.h"
+#include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "content/public/browser/notification_source.h"
 #include "content/test/test_browser_thread.h"
 #include "sync/engine/model_changing_syncer_command.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/syncable/model_type.h"
 #include "sync/syncable/syncable.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 93 matching lines @@
   return syncable::AUTOFILL;
 }
 
 template<>
 syncable::ModelType GetModelType<AutofillProfile>() {
   return syncable::AUTOFILL_PROFILE;
 }
 
 class WebDataServiceFake : public WebDataService {
  public:
-  explicit WebDataServiceFake(WebDatabase* web_database)
-      : web_database_(web_database),
+  WebDataServiceFake()
+      : web_database_(NULL),
         syncable_service_created_or_destroyed_(false, false) {
   }
 
+  static scoped_refptr<RefcountedProfileKeyedService> Build(Profile* profile) {
+    return new WebDataServiceFake;
+  }
+
+  void SetDatabase(WebDatabase* web_database) {
+    web_database_ = web_database;
+  }
+
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&WebDataServiceFake::CreateSyncableService,
                    base::Unretained(this)));
     syncable_service_created_or_destroyed_.Wait();
   }
 
   void ShutdownSyncableService() {
@@ skipping 34 matching lines @@
   }
 
   virtual AutofillProfileSyncableService*
       GetAutofillProfileSyncableService() const OVERRIDE {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     EXPECT_TRUE(autofill_profile_syncable_service_);
 
     return autofill_profile_syncable_service_;
   }
 
+  virtual void ShutdownOnUIThread() OVERRIDE {}
+
  private:
   void CreateSyncableService() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
     autocomplete_syncable_service_ = new AutocompleteSyncableService(this);
     autofill_profile_syncable_service_ =
         new AutofillProfileSyncableService(this);
     syncable_service_created_or_destroyed_.Signal();
   }
 
@@ skipping 104 matching lines @@
   MOCK_METHOD0(LoadProfiles, void());
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
 };
 template <class T> class AddAutofillHelper;
 
 class ProfileSyncServiceAutofillTest : public AbstractProfileSyncServiceTest {
  protected:
   ProfileSyncServiceAutofillTest() {
   }
+  virtual ~ProfileSyncServiceAutofillTest() {
+  }
 
   AutofillProfileFactory profile_factory_;
   AutofillEntryFactory entry_factory_;
 
   AbstractAutofillFactory* GetFactory(syncable::ModelType type) {
     if (type == syncable::AUTOFILL) {
       return &entry_factory_;
     } else if (type == syncable::AUTOFILL_PROFILE) {
       return &profile_factory_;
     } else {
       NOTREACHED();
       return NULL;
     }
   }
 
   virtual void SetUp() OVERRIDE {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.CreateRequestContext();
     web_database_.reset(new WebDatabaseFake(&autofill_table_));
-    web_data_service_ = new WebDataServiceFake(web_database_.get());
+    web_data_service_ = static_cast<WebDataServiceFake*>(
+        WebDataServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+            &profile_, WebDataServiceFake::Build).get());
+    web_data_service_->SetDatabase(web_database_.get());
     personal_data_manager_ = static_cast<PersonalDataManagerMock*>(
         PersonalDataManagerFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, PersonalDataManagerMock::Build));
     token_service_ = static_cast<TokenService*>(
         TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, BuildTokenService));
     // GetHistoryService() gets called indirectly, but the result is ignored, so
     // it is safe to return NULL.
     EXPECT_CALL(profile_, GetHistoryService(_)).
         WillRepeatedly(Return(static_cast<HistoryService*>(NULL)));
     EXPECT_CALL(*personal_data_manager_, LoadProfiles()).Times(1);
     EXPECT_CALL(*personal_data_manager_, LoadCreditCards()).Times(1);
-    EXPECT_CALL(profile_, GetWebDataService(_)).
-        // TokenService::Initialize
-        // AutofillDataTypeController::StartModels()
-        // In some tests:
-        // AutofillProfileSyncableService::AutofillProfileSyncableService()
-        WillRepeatedly(Return(web_data_service_.get()));
+
     personal_data_manager_->Init(&profile_);
 
     // Note: This must be called *after* the notification service is created.
     web_data_service_->StartSyncableService();
   }
 
   virtual void TearDown() OVERRIDE {
     // Note: The tear down order is important.
     service_.reset();
     web_data_service_->ShutdownSyncableService();
@@ skipping 837 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();
   }
 }