[sync] Abstract most ProfileSyncService //chrome deps

chrome/browser/sync/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 "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
+#include "base/prefs/json_pref_store.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/sync_backend_host_impl.h"
 #include "chrome/browser/sync/sync_type_preference_provider.h"
-#include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
 #include "components/invalidation/impl/invalidation_prefs.h"
-#include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/about_signin_internals.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_metrics.h"
 #include "components/sync_driver/backend_migrator.h"
 #include "components/sync_driver/change_processor.h"
 #include "components/sync_driver/data_type_controller.h"
 #include "components/sync_driver/device_info.h"
 #include "components/sync_driver/glue/chrome_report_unrecoverable_error.h"
 #include "components/sync_driver/pref_names.h"
 #include "components/sync_driver/signin_manager_wrapper.h"
 #include "components/sync_driver/sync_api_component_factory.h"
 #include "components/sync_driver/sync_client.h"
 #include "components/sync_driver/sync_driver_switches.h"
 #include "components/sync_driver/sync_error_controller.h"
 #include "components/sync_driver/sync_stopped_reporter.h"
 #include "components/sync_driver/sync_util.h"
 #include "components/sync_driver/system_encryptor.h"
 #include "components/sync_driver/user_selectable_sync_type.h"
 #include "components/sync_sessions/favicon_cache.h"
 #include "components/sync_sessions/sync_sessions_client.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
 #include "components/version_info/version_info_values.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/http_bridge_network_resources.h"
 #include "sync/internal_api/public/network_resources.h"
 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
@@ skipping 99 matching lines @@
     Profile* profile,
     scoped_ptr<SigninManagerWrapper> signin_wrapper,
     ProfileOAuth2TokenService* oauth2_token_service,
     ProfileSyncServiceStartBehavior start_behavior,
     const syncer::NetworkTimeUpdateCallback& network_time_update_callback)
     : OAuth2TokenService::Consumer("sync"),
       last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       sync_client_(sync_client.Pass()),
       profile_(profile),
-      sync_prefs_(profile_->GetPrefs()),
+      sync_prefs_(sync_client_->GetPrefService()),
       sync_service_url_(
           GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
-                            chrome::GetChannel())),
+                            sync_client_->GetChannel())),
       network_time_update_callback_(network_time_update_callback),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
       signin_(signin_wrapper.Pass()),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
       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),
       backend_mode_(IDLE),
       need_backup_(false),
       backup_finished_(false),
       clear_browsing_data_(sync_client_->GetClearBrowsingDataCallback()),
       catch_up_configure_in_progress_(false),
       passphrase_prompt_triggered_by_version_(false),
       weak_factory_(this),
       startup_controller_weak_factory_(this) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(profile);
   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(),
-              profile_->GetRequestContext(),
-              browser_sync::SyncStoppedReporter::ResultCallback()));
+  sync_stopped_reporter_.reset(new browser_sync::SyncStoppedReporter(
+      sync_service_url_, local_device_->GetSyncUserAgent(),
+      sync_client_->GetURLRequestContext(),
+      browser_sync::SyncStoppedReporter::ResultCallback()));
 
   registrar_.Add(this, chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED,
                  content::Source<Profile>(profile));
   sessions_sync_manager_.reset(
       new SessionsSyncManager(sync_client_->GetSyncSessionsClient(), profile,
                               local_device_.get(), router.Pass()));
   device_info_sync_service_.reset(
       new DeviceInfoSyncService(local_device_.get()));
 
   std::string last_version = sync_prefs_.GetLastRunVersion();
@@ skipping 95 matching lines @@
 void ProfileSyncService::TrySyncDatatypePrefRecovery() {
   DCHECK(!IsBackendInitialized());
   if (!HasSyncSetupCompleted())
     return;
 
   // There was a bug where OnUserChoseDatatypes was not properly called on
   // configuration (see crbug.com/154940). We detect this by checking whether
   // kSyncKeepEverythingSynced has a default value. If so, and sync setup has
   // completed, it means sync was not properly configured, so we manually
   // set kSyncKeepEverythingSynced.
-  PrefService* const pref_service = profile_->GetPrefs();
+  PrefService* const pref_service = sync_client_->GetPrefService();
   if (!pref_service)
     return;
   if (GetPreferredDataTypes().Size() > 1)
     return;
 
   const PrefService::Preference* keep_everything_synced =
       pref_service->FindPreference(
           sync_driver::prefs::kSyncKeepEverythingSynced);
   // This will be false if the preference was properly set or if it's controlled
   // by policy.
   if (!keep_everything_synced->IsDefaultValue())
     return;
 
   // kSyncKeepEverythingSynced was not properly set. Set it and the preferred
   // types now, before we configure.
   UMA_HISTOGRAM_COUNTS("Sync.DatatypePrefRecovery", 1);
   sync_prefs_.SetKeepEverythingSynced(true);
   syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
 }
 
 void ProfileSyncService::StartSyncingWithServer() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSyncEnableClearDataOnPassphraseEncryption) &&
       backend_mode_ == SYNC &&
       sync_prefs_.GetPassphraseEncryptionTransitionInProgress()) {
     BeginConfigureCatchUpBeforeClear();
     return;
   }
 
   if (backend_)
@@ skipping 100 matching lines @@
 
   SyncCredentials credentials = GetCredentials();
 
   if (backend_mode_ == SYNC && delete_stale_data)
     ClearStaleErrors();
 
   SyncBackendHost::HttpPostProviderFactoryGetter
       http_post_provider_factory_getter =
           base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                      base::Unretained(network_resources_.get()),
-                     make_scoped_refptr(profile_->GetRequestContext()),
+                     make_scoped_refptr(sync_client_->GetURLRequestContext()),
                      network_time_update_callback_);
 
   backend_->Initialize(
-      this, sync_thread_.Pass(),
-      content::BrowserThread::GetMessageLoopProxyForThread(
-          content::BrowserThread::DB),
-      content::BrowserThread::GetMessageLoopProxyForThread(
-          content::BrowserThread::FILE),
-      GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
-      credentials, delete_stale_data,
+      this, sync_thread_.Pass(), sync_client_->GetDBThread(),
+      sync_client_->GetFileThread(), GetJsEventHandler(), sync_service_url_,
+      local_device_->GetSyncUserAgent(), credentials, delete_stale_data,
       scoped_ptr<syncer::SyncManagerFactory>(
           new syncer::SyncManagerFactory(GetManagerType()))
           .Pass(),
       MakeWeakHandle(weak_factory_.GetWeakPtr()),
       base::Bind(browser_sync::ChromeReportUnrecoverableError,
-                 chrome::GetChannel()),
+                 sync_client_->GetChannel()),
       http_post_provider_factory_getter, saved_nigori_state_.Pass());
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
   DCHECK(encrypted_types.Has(syncer::PASSWORDS));
   return !Intersection(preferred_types, encrypted_types).Empty();
@@ skipping 117 matching lines @@
 
   if (backend_mode_ == ROLLBACK)
     ClearBrowsingDataSinceFirstSync();
   else if (backend_mode_ == SYNC)
     CheckSyncBackupIfNeeded();
 
   base::FilePath sync_folder = backend_mode_ == SYNC ?
       base::FilePath(kSyncDataFolderName) :
       base::FilePath(kSyncBackupDataFolderName);
 
-  invalidation::InvalidationService* invalidator = NULL;
-  if (backend_mode_ == SYNC) {
-    invalidation::ProfileInvalidationProvider* provider =
-        invalidation::ProfileInvalidationProviderFactory::GetForProfile(
-            profile_);
-    if (provider)
-      invalidator = provider->GetInvalidationService();
-  }
+  invalidation::InvalidationService* invalidator =
+      backend_mode_ == SYNC ? sync_client_->GetInvalidationService() : nullptr;
 
-  directory_path_ = profile_->GetPath().Append(sync_folder);
+  directory_path_ = sync_client_->GetBaseDirectory().Append(sync_folder);
 
   backend_.reset(
       sync_client_->GetSyncApiComponentFactory()->CreateSyncBackendHost(
-          profile_->GetDebugName(), sync_client_.get(), invalidator,
+          sync_client_->GetDebugIdentifier(), sync_client_.get(), invalidator,
           sync_prefs_.AsWeakPtr(), sync_folder));
 
   // 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 420 matching lines @@
   sync_js_controller_.AttachJsBackend(js_backend);
   debug_info_listener_ = debug_info_listener;
 
   SigninClient* signin_client = signin_->GetOriginal()->signin_client();
   DCHECK(signin_client);
   std::string signin_scoped_device_id =
       signin_client->GetSigninScopedDeviceId();
 
   // Initialize local device info.
   local_device_->Initialize(cache_guid, signin_scoped_device_id,
-                            content::BrowserThread::GetBlockingPool());
+                            sync_client_->GetBlockingPool());
 
   if (backend_mode_ == BACKUP || backend_mode_ == ROLLBACK)
     ConfigureDataTypeManager();
   else
     PostBackendInitialization();
 }
 
 void ProfileSyncService::OnSyncCycleCompleted() {
   UpdateLastSyncedTime();
   if (IsDataTypeControllerRunning(syncer::SESSIONS)) {
     // Trigger garbage collection of old sessions now that we've downloaded
     // any new session data.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&SessionsSyncManager::DoGarbageCollection,
                               base::AsWeakPtr(sessions_sync_manager_.get())));
   }
   DVLOG(2) << "Notifying observers sync cycle completed";
   NotifySyncCycleCompleted();
 }
 
 void ProfileSyncService::OnExperimentsChanged(
     const syncer::Experiments& experiments) {
   if (current_experiments_.Matches(experiments))
     return;
 
   current_experiments_ = experiments;
 
-  profile()->GetPrefs()->SetBoolean(
+  sync_client_->GetPrefService()->SetBoolean(
       invalidation::prefs::kInvalidationServiceUseGCMChannel,
       experiments.gcm_invalidations_enabled);
-  profile()->GetPrefs()->SetBoolean(
+  sync_client_->GetPrefService()->SetBoolean(
       autofill::prefs::kAutofillWalletSyncExperimentEnabled,
       experiments.wallet_sync_enabled);
 }
 
 void ProfileSyncService::UpdateAuthErrorState(const AuthError& error) {
   is_auth_in_progress_ = false;
   last_auth_error_ = error;
 
   NotifyObservers();
 }
@@ skipping 233 matching lines @@
     CleanUpBackup();
   } else if (error.action == syncer::ROLLBACK_DONE) {
     // Shut down ROLLBACK backend and delete backup DB.
     ShutdownImpl(syncer::DISABLE_SYNC);
     sync_prefs_.ClearFirstSyncTime();
   }
 }
 
 void ProfileSyncService::OnLocalSetPassphraseEncryption(
     const syncer::SyncEncryptionHandler::NigoriState& nigori_state) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSyncEnableClearDataOnPassphraseEncryption))
     return;
 
   // At this point the user has set a custom passphrase and we have received the
   // updated nigori state. Time to cache the nigori state, and catch up the
   // active data types.
   sync_prefs_.SetSavedNigoriStateForPassphraseEncryptionTransition(
       nigori_state);
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(true);
   BeginConfigureCatchUpBeforeClear();
 }
 
 void ProfileSyncService::BeginConfigureCatchUpBeforeClear() {
   DCHECK_EQ(backend_mode_, SYNC);
   DCHECK(data_type_manager_);
   DCHECK(!saved_nigori_state_);
   saved_nigori_state_ =
       sync_prefs_.GetSavedNigoriStateForPassphraseEncryptionTransition().Pass();
   const syncer::ModelTypeSet types = GetActiveDataTypes();
   catch_up_configure_in_progress_ = true;
   data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CATCH_UP);
 }
 
 void ProfileSyncService::ClearAndRestartSyncForPassphraseEncryption() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(thread_checker_.CalledOnValidThread());
   backend_->ClearServerData(base::Bind(
       &ProfileSyncService::OnClearServerDataDone, weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnClearServerDataDone() {
   DCHECK(sync_prefs_.GetPassphraseEncryptionTransitionInProgress());
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(false);
 
   // Call to ClearServerData generates new keystore key on the server. This
   // makes keystore bootstrap token invalid. Let's clear it from preferences.
@@ skipping 459 matching lines @@
   bool restart = false;
   if (!data_type_manager_) {
     restart = true;
     data_type_manager_.reset(
         sync_client_->GetSyncApiComponentFactory()->CreateDataTypeManager(
             debug_info_listener_, &data_type_controllers_, this, backend_.get(),
             this));
 
     // We create the migrator at the same time.
     migrator_.reset(new browser_sync::BackendMigrator(
-        profile_->GetDebugName(), GetUserShare(), this,
+        sync_client_->GetDebugIdentifier(), GetUserShare(), this,
         data_type_manager_.get(),
         base::Bind(&ProfileSyncService::StartSyncingWithServer,
                    base::Unretained(this))));
   }
 
   syncer::ModelTypeSet types;
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   if (backend_mode_ == BACKUP || backend_mode_ == ROLLBACK) {
     types = syncer::BackupTypes();
     reason = syncer::CONFIGURE_REASON_BACKUP_ROLLBACK;
@@ skipping 512 matching lines @@
   return sync_prefs_.IsSyncRequested();
 }
 
 SigninManagerBase* ProfileSyncService::signin() const {
   if (!signin_)
     return NULL;
   return signin_->GetOriginal();
 }
 
 void ProfileSyncService::RequestStart() {
-  DCHECK(profile_);
+  DCHECK(sync_client_);
   sync_prefs_.SetSyncRequested(true);
   DCHECK(!signin_.get() || signin_->GetOriginal()->IsAuthenticated());
   startup_controller_->TryStart();
 }
 
 void ProfileSyncService::ReconfigureDatatypeManager() {
   // If we haven't initialized yet, don't configure the DTM as it could cause
   // association to start before a Directory has even been created.
   if (backend_initialized_) {
     DCHECK(backend_.get());
@@ skipping 128 matching lines @@
   if (!last_backup_time_ &&
       (last_synced_time.is_null() ||
           base::Time::Now() - last_synced_time >=
               base::TimeDelta::FromDays(1))) {
     // If sync thread is set, need to serialize check on sync thread after
     // closing backup DB.
     if (sync_thread_) {
       sync_thread_->task_runner()->PostTask(
           FROM_HERE,
           base::Bind(syncer::CheckSyncDbLastModifiedTime,
-                     profile_->GetPath().Append(kSyncBackupDataFolderName),
+                     sync_client_->GetBaseDirectory().Append(
+                         kSyncBackupDataFolderName),
                      base::ThreadTaskRunnerHandle::Get(),
                      base::Bind(&ProfileSyncService::CheckSyncBackupCallback,
                                 weak_factory_.GetWeakPtr())));
     } else {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::FILE, FROM_HERE,
+      sync_client_->GetFileThread()->PostTask(
+          FROM_HERE,
           base::Bind(syncer::CheckSyncDbLastModifiedTime,
-                     profile_->GetPath().Append(kSyncBackupDataFolderName),
+                     sync_client_->GetBaseDirectory().Append(
+                         kSyncBackupDataFolderName),
                      base::ThreadTaskRunnerHandle::Get(),
                      base::Bind(&ProfileSyncService::CheckSyncBackupCallback,
                                 weak_factory_.GetWeakPtr())));
     }
   }
 #endif
 }
 
 void ProfileSyncService::CheckSyncBackupCallback(base::Time backup_time) {
   last_backup_time_.reset(new base::Time(backup_time));
 
   DCHECK(device_info_sync_service_);
   device_info_sync_service_->UpdateLocalDeviceBackupTime(*last_backup_time_);
 }
 
 void ProfileSyncService::TryStartSyncAfterBackup() {
   startup_controller_->Reset(GetRegisteredDataTypes());
   startup_controller_->TryStart();
 }
 
 void ProfileSyncService::CleanUpBackup() {
   sync_prefs_.ClearFirstSyncTime();
-  profile_->GetIOTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(base::DeleteFile),
-                 profile_->GetPath().Append(kSyncBackupDataFolderName),
-                 true));
+
+  // Use the client's base directory to get the blocking task runner to use in
+  // order to ensure ordering between the tasks posted by different invocations
+  // of this method.
+  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
+      JsonPrefStore::GetTaskRunnerForFile(sync_client_->GetBaseDirectory(),
+                                          sync_client_->GetBlockingPool());
+  blocking_task_runner->PostTask(
+      FROM_HERE, base::Bind(base::IgnoreResult(base::DeleteFile),
+                            sync_client_->GetBaseDirectory().Append(
+                                kSyncBackupDataFolderName),
+                            true));
 }
 
 bool ProfileSyncService::NeedBackup() const {
   return need_backup_;
 }
 
 base::Time ProfileSyncService::GetDeviceBackupTimeForTesting() const {
   return device_info_sync_service_->GetLocalDeviceBackupTime();
 }
 
@@ skipping 70 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_;
 }