[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 17 matching lines @@
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/browser_sync/common/browser_sync_switches.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidation_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/signin/core/browser/signin_manager.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/sync_driver/data_type_manager.h"
 #include "components/sync_driver/data_type_manager_observer.h"
 #include "components/sync_driver/fake_data_type_controller.h"
 #include "components/sync_driver/glue/sync_backend_host_mock.h"
 #include "components/sync_driver/pref_names.h"
 #include "components/sync_driver/signin_manager_wrapper.h"
 #include "components/sync_driver/sync_api_component_factory_mock.h"
 #include "components/sync_driver/sync_driver_switches.h"
 #include "components/sync_driver/sync_prefs.h"
@@ skipping 50 matching lines @@
   return new FakeDataTypeManager(configure_called);
 }
 
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 class TestChromeSyncClient : public ChromeSyncClient {
  public:
   TestChromeSyncClient(
+      scoped_ptr<sync_driver::SyncApiComponentFactory> component_factory,
       Profile* profile,
-      scoped_ptr<sync_driver::SyncApiComponentFactory> component_factory,
       sync_driver::ClearBrowsingDataCallback callback)
-      : ChromeSyncClient(profile, component_factory.Pass()),
-        callback_(callback) {}
+      : ChromeSyncClient(profile),
+        callback_(callback),
+        component_factory_(component_factory.Pass()) {}
   ~TestChromeSyncClient() override {}
 
  private:
   // SyncClient:
   sync_driver::ClearBrowsingDataCallback GetClearBrowsingDataCallback()
       override {
     return callback_;
   }
+  sync_driver::SyncApiComponentFactory* GetSyncApiComponentFactory() override {
+    return component_factory_.get();
+  }
 
   sync_driver::ClearBrowsingDataCallback callback_;
+  scoped_ptr<sync_driver::SyncApiComponentFactory> component_factory_;
 };
 
 class TestSyncServiceObserver : public sync_driver::SyncServiceObserver {
  public:
   explicit TestSyncServiceObserver(ProfileSyncService* service)
       : service_(service), first_setup_in_progress_(false) {}
   void OnStateChanged() override {
     first_setup_in_progress_ = service_->IsFirstSetupInProgress();
   }
   bool first_setup_in_progress() const { return first_setup_in_progress_; }
@@ skipping 114 matching lines @@
 
 // A test harness that uses a real ProfileSyncService and in most cases a
 // MockSyncBackendHost.
 //
 // This is useful if we want to test the ProfileSyncService and don't care about
 // testing the SyncBackendHost.
 class ProfileSyncServiceTest : public ::testing::Test {
  protected:
   ProfileSyncServiceTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        profile_manager_(TestingBrowserProcess::GetGlobal()) {}
+        profile_manager_(TestingBrowserProcess::GetGlobal()),
+        profile_(NULL),
+        components_factory_(NULL) {}
   ~ProfileSyncServiceTest() override {}
 
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kSyncDeferredStartupTimeoutSeconds, "0");
 
     CHECK(profile_manager_.SetUp());
 
     TestingProfile::TestingFactories testing_factories;
     testing_factories.push_back(
@@ skipping 28 matching lines @@
   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(),
+        components_factory.Pass(), 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),
@@ skipping 66 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