Revert of [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_);
-  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;
-  }
-}
-
-ProfileSyncService::~ProfileSyncService() {
-  sync_prefs_.RemoveSyncPrefObserver(this);
-  // Shutdown() should have been called before destruction.
-  CHECK(!backend_initialized_);
-}
-
-bool ProfileSyncService::CanSyncStart() const {
-  return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
-}
-
-bool ProfileSyncService::IsOAuthRefreshTokenAvailable() {
-  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(),
+      start_behavior,
+      oauth2_token_service,
+      &sync_prefs_,
+      signin_.get(),
       base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                 startup_controller_weak_factory_.GetWeakPtr(), SYNC)));
+                 startup_controller_weak_factory_.GetWeakPtr(),
+                 SYNC)));
   backup_rollback_controller_.reset(new sync_driver::BackupRollbackController(
-      &sync_prefs_, signin_.get(),
+      &sync_prefs_,
+      signin_.get(),
       base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                 startup_controller_weak_factory_.GetWeakPtr(), BACKUP),
+                 startup_controller_weak_factory_.GetWeakPtr(),
+                 BACKUP),
       base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
-                 startup_controller_weak_factory_.GetWeakPtr(), ROLLBACK)));
+                 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);
+  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;
+  }
+}
+
+ProfileSyncService::~ProfileSyncService() {
+  sync_prefs_.RemoveSyncPrefObserver(this);
+  // Shutdown() should have been called before destruction.
+  CHECK(!backend_initialized_);
+}
+
+bool ProfileSyncService::CanSyncStart() const {
+  return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
+}
+
+bool ProfileSyncService::IsOAuthRefreshTokenAvailable() {
+  if (!oauth2_token_service_)
+    return false;
+
+  return oauth2_token_service_->RefreshTokenIsAvailable(
+      signin_->GetAccountIdToUse());
+}
+
+void ProfileSyncService::Initialize() {
+  sync_client_->Initialize(this);
 
   // 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()) {
@@ skipping 364 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_, invalidator, sync_prefs_.AsWeakPtr(),
-          directory_path_));
+          debug_identifier_, sync_client_.get(), 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_;
 }