[Sync] Componentize ProfileSyncComponentsFactoryImpl

components/browser_sync/browser/profile_sync_service.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 "components/browser_sync/browser/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <vector>
 
@@ skipping 193 matching lines @@
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_allowed_(true),
       encrypt_everything_(false),
       encryption_pending_(false),
       configure_status_(DataTypeManager::UNKNOWN),
       oauth2_token_service_(oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
       last_get_token_error_(GoogleServiceAuthError::AuthErrorNone()),
       network_resources_(new syncer::HttpBridgeNetworkResources),
+      start_behavior_(start_behavior),
       backend_mode_(IDLE),
       need_backup_(false),
       backup_finished_(false),
       catch_up_configure_in_progress_(false),
       passphrase_prompt_triggered_by_version_(false),
       weak_factory_(this),
       startup_controller_weak_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(sync_client_);
-  startup_controller_.reset(new browser_sync::StartupController(
-      start_behavior,
-      oauth2_token_service,
-      &sync_prefs_,
-      signin_.get(),
-      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                 startup_controller_weak_factory_.GetWeakPtr(),
-                 SYNC)));
-  backup_rollback_controller_.reset(new sync_driver::BackupRollbackController(
-      &sync_prefs_,
-      signin_.get(),
-      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                 startup_controller_weak_factory_.GetWeakPtr(),
-                 BACKUP),
-      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                 startup_controller_weak_factory_.GetWeakPtr(),
-                 ROLLBACK)));
-  scoped_ptr<browser_sync::LocalSessionEventRouter> router(
-      sync_client_->GetSyncSessionsClient()->GetLocalSessionEventRouter());
-  local_device_ = sync_client_->GetSyncApiComponentFactory()
-                      ->CreateLocalDeviceInfoProvider();
-  sync_stopped_reporter_.reset(new browser_sync::SyncStoppedReporter(
-      sync_service_url_, local_device_->GetSyncUserAgent(),
-      url_request_context_,
-      browser_sync::SyncStoppedReporter::ResultCallback()));
-  sessions_sync_manager_.reset(new SessionsSyncManager(
-      sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(),
-      router.Pass(),
-      base::Bind(&ProfileSyncService::NotifyForeignSessionUpdated,
-                 weak_factory_.GetWeakPtr()),
-      base::Bind(&ProfileSyncService::TriggerRefresh,
-                 weak_factory_.GetWeakPtr(),
-                 syncer::ModelTypeSet(syncer::SESSIONS))));
-  device_info_sync_service_.reset(
-      new DeviceInfoSyncService(local_device_.get()));
-
   std::string last_version = sync_prefs_.GetLastRunVersion();
   std::string current_version = PRODUCT_VERSION;
   sync_prefs_.SetLastRunVersion(current_version);
 
   // Check for a major version change. Note that the versions have format
   // MAJOR.MINOR.BUILD.PATCH.
   if (last_version.substr(0, last_version.find('.')) !=
       current_version.substr(0, current_version.find('.'))) {
     passphrase_prompt_triggered_by_version_ = true;
   }
@@ skipping 13 matching lines @@
   if (!oauth2_token_service_)
     return false;
 
   return oauth2_token_service_->RefreshTokenIsAvailable(
       signin_->GetAccountIdToUse());
 }
 
 void ProfileSyncService::Initialize() {
   sync_client_->Initialize(this);
 
+  startup_controller_.reset(new browser_sync::StartupController(
+      start_behavior_, oauth2_token_service_, &sync_prefs_, signin_.get(),
+      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+                 startup_controller_weak_factory_.GetWeakPtr(), SYNC)));
+  backup_rollback_controller_.reset(new sync_driver::BackupRollbackController(
+      &sync_prefs_, signin_.get(),
+      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+                 startup_controller_weak_factory_.GetWeakPtr(), BACKUP),
+      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+                 startup_controller_weak_factory_.GetWeakPtr(), ROLLBACK)));
+  scoped_ptr<browser_sync::LocalSessionEventRouter> router(
+      sync_client_->GetSyncSessionsClient()->GetLocalSessionEventRouter());
+  local_device_ = sync_client_->GetSyncApiComponentFactory()
+                      ->CreateLocalDeviceInfoProvider();
+  sync_stopped_reporter_.reset(new browser_sync::SyncStoppedReporter(
+      sync_service_url_, local_device_->GetSyncUserAgent(),
+      url_request_context_,
+      browser_sync::SyncStoppedReporter::ResultCallback()));
+  sessions_sync_manager_.reset(new SessionsSyncManager(
+      sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(),
+      router.Pass(),
+      base::Bind(&ProfileSyncService::NotifyForeignSessionUpdated,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&ProfileSyncService::TriggerRefresh,
+                 weak_factory_.GetWeakPtr(),
+                 syncer::ModelTypeSet(syncer::SESSIONS))));
+  device_info_sync_service_.reset(
+      new DeviceInfoSyncService(local_device_.get()));
+
+  sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod
+      register_platform_types_callback =
+          sync_client_->GetRegisterPlatformTypesCallback();
+  sync_client_->GetSyncApiComponentFactory()->RegisterDataTypes(
+      register_platform_types_callback);
+
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
   ClearStaleErrors();
 
   sync_prefs_.AddSyncPrefObserver(this);
 
   // If sync isn't allowed, the only thing to do is to turn it off.
   if (!IsSyncAllowed()) {
     RequestStop(CLEAR_DATA);
@@ skipping 363 matching lines @@
       base::FilePath(kSyncDataFolderName) :
       base::FilePath(kSyncBackupDataFolderName);
 
   invalidation::InvalidationService* invalidator =
       backend_mode_ == SYNC ? sync_client_->GetInvalidationService() : nullptr;
 
   directory_path_ = base_directory_.Append(sync_folder);
 
   backend_.reset(
       sync_client_->GetSyncApiComponentFactory()->CreateSyncBackendHost(
-          debug_identifier_, sync_client_.get(), invalidator,
-          sync_prefs_.AsWeakPtr(), directory_path_));
+          debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(),
+          directory_path_));
 
   // Initialize the backend.  Every time we start up a new SyncBackendHost,
   // we'll want to start from a fresh SyncDB, so delete any old one that might
   // be there.
   InitializeBackend(ShouldDeleteSyncFolder());
 
   UpdateFirstSyncTimePref();
 
   ReportPreviousSessionMemoryWarningCount();
 }
@@ skipping 2009 matching lines @@
 }
 
 std::string ProfileSyncService::unrecoverable_error_message() const {
   return unrecoverable_error_message_;
 }
 
 tracked_objects::Location ProfileSyncService::unrecoverable_error_location()
     const {
   return unrecoverable_error_location_;
 }