[Sync] Componentize ProfileSyncComponentsFactoryImpl

chrome/browser/sync/profile_sync_service_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 "base/basictypes.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 87 matching lines @@
 ACTION_P(ReturnNewDataTypeManager, configure_called) {
   return new FakeDataTypeManager(configure_called);
 }
 
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 class TestChromeSyncClient : public ChromeSyncClient {
  public:
-  TestChromeSyncClient(
-      Profile* profile,
-      scoped_ptr<sync_driver::SyncApiComponentFactory> component_factory,
-      sync_driver::ClearBrowsingDataCallback callback)
-      : ChromeSyncClient(profile, component_factory.Pass()),
-        callback_(callback) {}
+  TestChromeSyncClient(Profile* profile,
+                       sync_driver::ClearBrowsingDataCallback callback)
+      : ChromeSyncClient(profile), callback_(callback) {}
   ~TestChromeSyncClient() override {}
 
  private:
   // SyncClient:
   sync_driver::ClearBrowsingDataCallback GetClearBrowsingDataCallback()
       override {
     return callback_;
   }
 
   sync_driver::ClearBrowsingDataCallback callback_;
@@ skipping 169 matching lines @@
     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
         ->UpdateCredentials(account_id, "oauth2_login_token");
   }
 
   void CreateService(ProfileSyncServiceStartBehavior behavior) {
     SigninManagerBase* signin =
         SigninManagerFactory::GetForProfile(profile_);
     signin->SetAuthenticatedAccountInfo(kGaiaId, kEmail);
     ProfileOAuth2TokenService* oauth2_token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
-    scoped_ptr<SyncApiComponentFactoryMock> components_factory(
-        new SyncApiComponentFactoryMock());
-    components_factory_ = components_factory.get();
     scoped_ptr<ChromeSyncClient> sync_client(new TestChromeSyncClient(
-        profile_, components_factory.Pass(),
-        base::Bind(&ProfileSyncServiceTest::ClearBrowsingDataCallback,
-                   base::Unretained(this))));
+        profile_, base::Bind(&ProfileSyncServiceTest::ClearBrowsingDataCallback,
+                             base::Unretained(this))));
     service_.reset(new ProfileSyncService(
         sync_client.Pass(),
         make_scoped_ptr(new SigninManagerWrapper(signin)), oauth2_token_service,
         behavior, base::Bind(&EmptyNetworkTimeUpdate), profile_->GetPath(),
         profile_->GetRequestContext(), profile_->GetDebugName(),
         chrome::GetChannel(),
         content::BrowserThread::GetMessageLoopProxyForThread(
             content::BrowserThread::DB),
         content::BrowserThread::GetMessageLoopProxyForThread(
             content::BrowserThread::FILE),
         content::BrowserThread::GetBlockingPool()));
+
+    scoped_ptr<SyncApiComponentFactoryMock> components_factory(
+        new SyncApiComponentFactoryMock());
+    components_factory_ = components_factory.get();
+    service_->GetSyncClient()->Initialize(components_factory.Pass(),
+                                          service_.get());
     service_->RegisterDataTypeController(
         new sync_driver::FakeDataTypeController(syncer::BOOKMARKS));
   }
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
   void CreateServiceWithoutSignIn() {
     CreateService(browser_sync::AUTO_START);
     SigninManagerFactory::GetForProfile(profile())->SignOut(
         signin_metrics::SIGNOUT_TEST);
   }
@@ skipping 53 matching lines @@
 
   void ExpectDataTypeManagerCreation(
       int times,
       const FakeDataTypeManager::ConfigureCalled& callback) {
     EXPECT_CALL(*components_factory_, CreateDataTypeManager(_, _, _, _, _))
         .Times(times)
         .WillRepeatedly(ReturnNewDataTypeManager(callback));
   }
 
   void ExpectSyncBackendHostCreation(int times) {
-    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _))
+    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _))
         .Times(times)
         .WillRepeatedly(ReturnNewSyncBackendHostMock());
   }
 
   void ExpectSyncBackendHostCreationCollectDeleteDir(
       int times, std::vector<bool> *delete_dir_param) {
-    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _))
+    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _))
         .Times(times)
         .WillRepeatedly(
             ReturnNewMockHostCollectDeleteDirParam(delete_dir_param));
   }
 
   void ExpectSyncBackendHostCreationCaptureClearServerData(
       syncer::SyncManager::ClearServerDataCallback* captured_callback) {
-    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _))
+    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _))
         .Times(1)
         .WillOnce(ReturnNewMockHostCaptureClearServerData(captured_callback));
   }
 
   void PrepareDelayedInitSyncBackendHost() {
-    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _))
+    EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _))
         .WillOnce(ReturnNewSyncBackendHostNoReturn());
   }
 
   TestingProfile* profile() {
     return profile_;
   }
 
   ProfileSyncService* service() {
     return service_.get();
   }
@@ skipping 629 matching lines @@
   InitializeForNthSync();
 
   syncer::SyncProtocolError client_cmd;
   client_cmd.action = syncer::RESET_LOCAL_SYNC_DATA;
   service()->OnActionableError(client_cmd);
   EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode());
 }
 
 }  // namespace
 }  // namespace browser_sync