[Sync] Replace ProfileSyncComponentsFactory with SyncClient

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 <utility>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 32 matching lines @@
 #include "components/autofill/core/browser/webdata/autocomplete_syncable_service.h"
 #include "components/autofill/core/browser/webdata/autofill_change.h"
 #include "components/autofill/core/browser/webdata/autofill_entry.h"
 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/sync_driver/data_type_controller.h"
-#include "components/sync_driver/profile_sync_components_factory.h"
+#include "components/sync_driver/fake_sync_client.h"
 #include "components/webdata/common/web_database.h"
 #include "components/webdata_services/web_data_service_test_util.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/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"
@@ skipping 74 matching lines @@
   MOCK_METHOD1(AddAutofillProfile,
                bool(const AutofillProfile&));  // NOLINT
   MOCK_METHOD1(RemoveAutofillProfile,
                bool(const std::string&));  // NOLINT
 };
 
 MATCHER_P(MatchProfiles, profile, "") {
   return (profile.Compare(arg) == 0);
 }
 
+class TestSyncClient : public sync_driver::FakeSyncClient {
+ public:
+  TestSyncClient(PersonalDataManager* pdm,
+                 const scoped_refptr<AutofillWebDataService>& web_data_service)
+      : pdm_(pdm),
+        web_data_service_(web_data_service) {}
+  ~TestSyncClient() override {}
+
+  // FakeSyncClient overrides.
+  autofill::PersonalDataManager* GetPersonalDataManager() override {
+    return pdm_;
+  }
+  scoped_refptr<autofill::AutofillWebDataService> GetWebDataService() override {
+    return web_data_service_;
+  }
+  base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
+      syncer::ModelType type) override {
+    DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
+    if (type == AUTOFILL) {
+      return AutocompleteSyncableService::FromWebDataService(
+          web_data_service_.get())->AsWeakPtr();
+    } else {
+      return AutofillProfileSyncableService::FromWebDataService(
+          web_data_service_.get())->AsWeakPtr();
+    }
+  }
+
+ private:
+  PersonalDataManager* pdm_;
+  scoped_refptr<AutofillWebDataService> web_data_service_;
+};
+
 class WebDatabaseFake : public WebDatabase {
  public:
   explicit WebDatabaseFake(AutofillTable* autofill_table) {
     AddTable(autofill_table);
   }
 };
 
 class MockAutofillBackend : public autofill::AutofillWebDataBackend {
  public:
   MockAutofillBackend(
@@ skipping 191 matching lines @@
 ACTION_P(ReturnNewDataTypeManagerWithDebugListener, debug_listener) {
   return new sync_driver::DataTypeManagerImpl(
       base::Closure(),
       debug_listener,
       arg1,
       arg2,
       arg3,
       arg4);
 }
 
-ACTION_P(MakeAutofillProfileSyncComponents, wds) {
-  EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  if (!BrowserThread::CurrentlyOn(BrowserThread::DB))
-    return base::WeakPtr<syncer::SyncableService>();
-  return AutofillProfileSyncableService::FromWebDataService(wds)->AsWeakPtr();
-}
-
-class AbstractAutofillFactory {
- public:
-  virtual DataTypeController* CreateDataTypeController(
-      ProfileSyncComponentsFactory* factory,
-      TestingProfile* profile,
-      ProfileSyncService* service) = 0;
-  virtual void SetExpectation(ProfileSyncComponentsFactoryMock* factory,
-                              ProfileSyncService* service,
-                              AutofillWebDataService* wds,
-                              DataTypeController* dtc) = 0;
-  virtual ~AbstractAutofillFactory() {}
-};
-
-class AutofillEntryFactory : public AbstractAutofillFactory {
- public:
-  DataTypeController* CreateDataTypeController(
-      ProfileSyncComponentsFactory* factory,
-      TestingProfile* profile,
-      ProfileSyncService* service) override {
-    return new AutofillDataTypeController(factory, profile);
-  }
-
-  void SetExpectation(ProfileSyncComponentsFactoryMock* factory,
-                      ProfileSyncService* service,
-                      AutofillWebDataService* wds,
-                      DataTypeController* dtc) override {
-    EXPECT_CALL(*factory, GetSyncableServiceForType(syncer::AUTOFILL)).
-        WillOnce(MakeAutocompleteSyncComponents(wds));
-  }
-};
-
-class AutofillProfileFactory : public AbstractAutofillFactory {
- public:
-  DataTypeController* CreateDataTypeController(
-      ProfileSyncComponentsFactory* factory,
-      TestingProfile* profile,
-      ProfileSyncService* service) override {
-    return new AutofillProfileDataTypeController(factory, profile);
-  }
-
-  void SetExpectation(ProfileSyncComponentsFactoryMock* factory,
-                      ProfileSyncService* service,
-                      AutofillWebDataService* wds,
-                      DataTypeController* dtc) override {
-    EXPECT_CALL(*factory,
-        GetSyncableServiceForType(syncer::AUTOFILL_PROFILE)).
-        WillOnce(MakeAutofillProfileSyncComponents(wds));
-  }
-};
-
 class MockPersonalDataManager : public PersonalDataManager {
  public:
   MockPersonalDataManager() : PersonalDataManager("en-US") {}
   MOCK_CONST_METHOD0(IsDataLoaded, bool());
   MOCK_METHOD0(LoadProfiles, void());
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
 
   static scoped_ptr<KeyedService> Build(content::BrowserContext* profile) {
     return make_scoped_ptr(new MockPersonalDataManager());
@@ skipping 13 matching lines @@
     association_stats_ = configuration_stats[0].association_stats;
   }
 
  protected:
   ProfileSyncServiceAutofillTest()
       : profile_manager_(TestingBrowserProcess::GetGlobal()),
         debug_ptr_factory_(this) {
   }
   ~ProfileSyncServiceAutofillTest() override {}
 
-  AutofillProfileFactory profile_factory_;
-  AutofillEntryFactory entry_factory_;
-
-  AbstractAutofillFactory* GetFactory(syncer::ModelType type) {
-    if (type == syncer::AUTOFILL) {
-      return &entry_factory_;
-    } else if (type == syncer::AUTOFILL_PROFILE) {
-      return &profile_factory_;
-    } else {
-      NOTREACHED();
-      return NULL;
-    }
-  }
-
   void SetUp() override {
     AbstractProfileSyncServiceTest::SetUp();
     ASSERT_TRUE(profile_manager_.SetUp());
     TestingProfile::TestingFactories testing_factories;
     testing_factories.push_back(std::make_pair(
         ProfileOAuth2TokenServiceFactory::GetInstance(),
         BuildAutoIssuingFakeProfileOAuth2TokenService));
     profile_ = profile_manager_.CreateTestingProfile(
         kTestProfileName,
         scoped_ptr<PrefServiceSyncable>(),
@@ skipping 20 matching lines @@
 
     personal_data_manager_->Init(
         WebDataServiceFactory::GetAutofillWebDataForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS),
         profile_->GetPrefs(),
         AccountTrackerServiceFactory::GetForProfile(profile_),
         profile_->IsOffTheRecord());
 
     web_data_service_->StartSyncableService();
 
+    sync_client_.reset(new TestSyncClient(personal_data_manager_,
+                                          web_data_service_));
+
     // When UpdateAutofillEntries() is called with an empty list, the return
     // value should be |true|, rather than the default of |false|.
     std::vector<AutofillEntry> empty;
     EXPECT_CALL(autofill_table_, UpdateAutofillEntries(empty))
         .WillRepeatedly(Return(true));
   }
 
   void TearDown() override {
     // Note: The tear down order is important.
     ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(profile_, NULL);
@@ skipping 11 matching lines @@
     syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode node(&trans);
     if (node.InitTypeRoot(type) != syncer::BaseNode::INIT_OK)
       return 0;
     return node.GetTotalNodeCount() - 1;
   }
 
   void StartSyncService(const base::Closure& callback,
                         bool will_fail_association,
                         syncer::ModelType type) {
-    AbstractAutofillFactory* factory = GetFactory(type);
     SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile_);
     signin->SetAuthenticatedAccountInfo("12345", "test_user@gmail.com");
     sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(profile_,
                                                                     callback);
 
     ProfileSyncComponentsFactoryMock* components =
         sync_service_->components_factory_mock();
-    DataTypeController* data_type_controller =
-        factory->CreateDataTypeController(components, profile_, sync_service_);
-    factory->SetExpectation(components,
-                            sync_service_,
-                            web_data_service_.get(),
-                            data_type_controller);
 
     EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _)).
         WillOnce(ReturnNewDataTypeManagerWithDebugListener(
                      syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
 
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
 
     // We need tokens to get the tests going
     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
         ->UpdateCredentials(signin->GetAuthenticatedAccountId(),
                             "oauth2_login_token");
 
-    sync_service_->RegisterDataTypeController(data_type_controller);
+    sync_service_->RegisterDataTypeController(CreateDataTypeController(type));
     sync_service_->Initialize();
     base::MessageLoop::current()->Run();
 
     // It's possible this test triggered an unrecoverable error, in which case
     // we can't get the sync count.
     if (sync_service_->IsSyncActive()) {
       EXPECT_EQ(GetSyncCount(type),
                 association_stats_.num_sync_items_after_association);
     }
     EXPECT_EQ(association_stats_.num_sync_items_after_association,
@@ skipping 124 matching lines @@
         AutofillKey(base::ASCIIToUTF16(name), base::ASCIIToUTF16(value)),
         date_created, date_last_used);
   }
 
   static AutofillEntry MakeAutofillEntry(const char* name,
                                          const char* value,
                                          int time_shift) {
     return MakeAutofillEntry(name, value, time_shift, -1);
   }
 
+  DataTypeController* CreateDataTypeController(syncer::ModelType type) {
+    DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
+    if (type == AUTOFILL)
+      return new AutofillDataTypeController(sync_client_.get());
+    else
+      return new AutofillProfileDataTypeController(sync_client_.get());
+  }
+
   friend class AddAutofillHelper<AutofillEntry>;
   friend class AddAutofillHelper<AutofillProfile>;
   friend class FakeServerUpdater;
 
   TestingProfileManager profile_manager_;
   TestingProfile* profile_;
   AutofillTableMock autofill_table_;
   scoped_ptr<WebDatabaseFake> web_database_;
   scoped_refptr<WebDataServiceFake> web_data_service_;
   MockPersonalDataManager* personal_data_manager_;
   syncer::DataTypeAssociationStats association_stats_;
   base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
+  scoped_ptr<TestSyncClient> sync_client_;
 };
 
 template <class T>
 class AddAutofillHelper {
  public:
   AddAutofillHelper(ProfileSyncServiceAutofillTest* test,
                     const std::vector<T>& entries)
       : callback_(base::Bind(&AddAutofillHelper::AddAutofillCallback,
                              base::Unretained(this), test, entries)),
         success_(false) {
@@ skipping 597 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();
   }
 }