[Sync] Pass a TaskRunner into SBHI/SBHC, not a thread or message loop.

components/sync/driver/glue/sync_backend_host_impl.cc

 // Copyright 2013 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/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 namespace syncer {
 
 SyncBackendHostImpl::SyncBackendHostImpl(
     const std::string& name,
     SyncClient* sync_client,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
     invalidation::InvalidationService* invalidator,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
     const base::FilePath& sync_folder)
-    : frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      sync_client_(sync_client),
-      ui_thread_(ui_thread),
+    : sync_client_(sync_client),
       name_(name),
       initialized_(false),
       sync_prefs_(sync_prefs),
       frontend_(nullptr),
       cached_passphrase_type_(PassphraseType::IMPLICIT_PASSPHRASE),
       invalidator_(invalidator),
       invalidation_handler_registered_(false),
       weak_ptr_factory_(this) {
   core_ = new SyncBackendHostCore(name_, sync_folder,
-                                  sync_prefs_->IsFirstSetupComplete(),
                                   weak_ptr_factory_.GetWeakPtr());
 }
 
 SyncBackendHostImpl::~SyncBackendHostImpl() {
   DCHECK(!core_.get() && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!registrar_.get());
 }
 
 void SyncBackendHostImpl::Initialize(
     SyncFrontend* frontend,
-    base::Thread* sync_thread,
+    scoped_refptr<base::SingleThreadTaskRunner> sync_task_runner,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& sync_service_url,
     const std::string& sync_user_agent,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder,
     bool enable_local_sync_backend,
     const base::FilePath& local_sync_backend_folder,
     std::unique_ptr<SyncManagerFactory> sync_manager_factory,
     const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
     const HttpPostProviderFactoryGetter& http_post_provider_factory_getter,
     std::unique_ptr<SyncEncryptionHandler::NigoriState> saved_nigori_state) {
-  CHECK(sync_thread);
-  sync_thread_ = sync_thread;
+  CHECK(sync_task_runner);
+  sync_task_runner_ = sync_task_runner;
 
   registrar_ = base::MakeUnique<SyncBackendRegistrar>(
       name_, base::Bind(&SyncClient::CreateModelWorkerForGroup,
                         base::Unretained(sync_client_)));
 
   DCHECK(frontend);
   frontend_ = frontend;
 
   std::vector<scoped_refptr<ModelSafeWorker>> workers;
   registrar_->GetWorkers(&workers);
@@ skipping 13 matching lines @@
   }
   if (cl->HasSwitch(switches::kSyncShortNudgeDelayForTest)) {
     factory_switches.nudge_delay =
         EngineComponentsFactory::NudgeDelay::SHORT_NUDGE_DELAY;
   }
 
   std::map<ModelType, int64_t> invalidation_versions;
   sync_prefs_->GetInvalidationVersions(&invalidation_versions);
 
   std::unique_ptr<DoInitializeOptions> init_opts(new DoInitializeOptions(
-      sync_thread_->message_loop(), registrar_.get(), workers,
+      sync_task_runner_, registrar_.get(), workers,
       sync_client_->GetExtensionsActivity(), event_handler, sync_service_url,
       sync_user_agent, http_post_provider_factory_getter.Run(
                            core_->GetRequestContextCancelationSignal()),
       credentials, invalidator_ ? invalidator_->GetInvalidatorClientId() : "",
       std::move(sync_manager_factory), delete_sync_data_folder,
       enable_local_sync_backend, local_sync_backend_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
       sync_prefs_->GetKeystoreEncryptionBootstrapToken(),
       std::unique_ptr<EngineComponentsFactory>(
           new EngineComponentsFactoryImpl(factory_switches)),
       unrecoverable_error_handler, report_unrecoverable_error_function,
       std::move(saved_nigori_state), invalidation_versions));
   InitCore(std::move(init_opts));
 }
 
 void SyncBackendHostImpl::TriggerRefresh(const ModelTypeSet& types) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  sync_thread_->task_runner()->PostTask(
+  DCHECK(thread_checker_.CalledOnValidThread());
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_, types));
 }
 
 void SyncBackendHostImpl::UpdateCredentials(
     const SyncCredentials& credentials) {
-  DCHECK(sync_thread_->IsRunning());
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoUpdateCredentials, core_,
                             credentials));
 }
 
 void SyncBackendHostImpl::StartSyncingWithServer() {
   SDVLOG(1) << "SyncBackendHostImpl::StartSyncingWithServer called.";
 
   ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
 
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoStartSyncing, core_,
                             routing_info, sync_prefs_->GetLastPollTime()));
 }
 
 void SyncBackendHostImpl::SetEncryptionPassphrase(const std::string& passphrase,
                                                   bool is_explicit) {
-  DCHECK(sync_thread_->IsRunning());
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetEncryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return;
   }
 
   // We should never be called with an empty passphrase.
   DCHECK(!passphrase.empty());
 
   // This should only be called by the frontend.
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // SetEncryptionPassphrase should never be called if we are currently
   // encrypted with an explicit passphrase.
   DCHECK(cached_passphrase_type_ == PassphraseType::KEYSTORE_PASSPHRASE ||
          cached_passphrase_type_ == PassphraseType::IMPLICIT_PASSPHRASE);
 
   // Post an encryption task on the syncer thread.
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetEncryptionPassphrase,
                             core_, passphrase, is_explicit));
 }
 
 bool SyncBackendHostImpl::SetDecryptionPassphrase(
     const std::string& passphrase) {
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetDecryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return false;
   }
 
   // We should never be called with an empty passphrase.
   DCHECK(!passphrase.empty());
 
   // This should only be called by the frontend.
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // This should only be called when we have cached pending keys.
   DCHECK(cached_pending_keys_.has_blob());
 
   // Check the passphrase that was provided against our local cache of the
   // cryptographer's pending keys. If this was unsuccessful, the UI layer can
   // immediately call OnPassphraseRequired without showing the user a spinner.
   if (!CheckPassphraseAgainstCachedPendingKeys(passphrase))
     return false;
 
   // Post a decryption task on the syncer thread.
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetDecryptionPassphrase,
                             core_, passphrase));
 
   // Since we were able to decrypt the cached pending keys with the passphrase
   // provided, we immediately alert the UI layer that the passphrase was
   // accepted. This will avoid the situation where a user enters a passphrase,
   // clicks OK, immediately reopens the advanced settings dialog, and gets an
   // unnecessary prompt for a passphrase.
   // Note: It is not guaranteed that the passphrase will be accepted by the
   // syncer thread, since we could receive a new nigori node while the task is
   // pending. This scenario is a valid race, and SetDecryptionPassphrase can
   // trigger a new OnPassphraseRequired if it needs to.
   NotifyPassphraseAccepted();
   return true;
 }
 
 void SyncBackendHostImpl::StopSyncingForShutdown() {
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
+  // Stop getting messages from the sync thread.
+  weak_ptr_factory_.InvalidateWeakPtrs();
   // Immediately stop sending messages to the frontend.
   frontend_ = nullptr;
 
-  DCHECK(sync_thread_->IsRunning());
-
   registrar_->RequestWorkerStopOnUIThread();
 
   core_->ShutdownOnUIThread();
 }
 
 void SyncBackendHostImpl::Shutdown(ShutdownReason reason) {
   // StopSyncingForShutdown() (which nulls out |frontend_|) should be
   // called first.
   DCHECK(!frontend_);
-  DCHECK(sync_thread_->IsRunning());
 
   if (invalidation_handler_registered_) {
     if (reason == DISABLE_SYNC) {
       UnregisterInvalidationIds();
     }
     invalidator_->UnregisterInvalidationHandler(this);
     invalidator_ = nullptr;
   }
   invalidation_handler_registered_ = false;
 
   model_type_connector_.reset();
 
   // Shut down and destroy SyncManager. SyncManager holds a pointer to
   // |registrar_| so its destruction must be sequenced before the destruction of
   // |registrar_|.
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoShutdown, core_, reason));
   core_ = nullptr;
 
   // Destroy |registrar_|.
-  sync_thread_->task_runner()->DeleteSoon(FROM_HERE, registrar_.release());
+  sync_task_runner_->DeleteSoon(FROM_HERE, registrar_.release());
 }
 
 void SyncBackendHostImpl::UnregisterInvalidationIds() {
   if (invalidation_handler_registered_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(this, ObjectIdSet()));
   }
 }
 
 ModelTypeSet SyncBackendHostImpl::ConfigureDataTypes(
     ConfigureReason reason,
@@ skipping 103 matching lines @@
                          ready_task, retry_callback);
 
   DCHECK(Intersection(active_types, types_to_purge).Empty());
   DCHECK(Intersection(active_types, fatal_types).Empty());
   DCHECK(Intersection(active_types, unapply_types).Empty());
   DCHECK(Intersection(active_types, inactive_types).Empty());
   return Difference(active_types, types_to_download);
 }
 
 void SyncBackendHostImpl::EnableEncryptEverything() {
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoEnableEncryptEverything, core_));
 }
 
 void SyncBackendHostImpl::ActivateDirectoryDataType(
     ModelType type,
     ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
@@ skipping 56 matching lines @@
   if (initialized()) {
     CHECK(registrar_.get());
     registrar_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 void SyncBackendHostImpl::FlushDirectory() const {
   DCHECK(initialized());
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::SaveChanges, core_));
 }
 
 void SyncBackendHostImpl::RequestBufferedProtocolEventsAndEnableForwarding() {
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &SyncBackendHostCore::SendBufferedProtocolEventsAndEnableForwarding,
           core_));
 }
 
 void SyncBackendHostImpl::DisableProtocolEventForwarding() {
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DisableProtocolEventForwarding, core_));
 }
 
 void SyncBackendHostImpl::EnableDirectoryTypeDebugInfoForwarding() {
   DCHECK(initialized());
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::EnableDirectoryTypeDebugInfoForwarding,
                  core_));
 }
 
 void SyncBackendHostImpl::DisableDirectoryTypeDebugInfoForwarding() {
   DCHECK(initialized());
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DisableDirectoryTypeDebugInfoForwarding,
                  core_));
 }
 
 void SyncBackendHostImpl::InitCore(
     std::unique_ptr<DoInitializeOptions> options) {
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoInitialize, core_,
                             base::Passed(&options)));
 }
 
 void SyncBackendHostImpl::RequestConfigureSyncer(
     ConfigureReason reason,
     ModelTypeSet to_download,
     ModelTypeSet to_purge,
     ModelTypeSet to_journal,
     ModelTypeSet to_unapply,
     ModelTypeSet to_ignore,
     const ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
   DoConfigureSyncerTypes config_types;
   config_types.to_download = to_download;
   config_types.to_purge = to_purge;
   config_types.to_journal = to_journal;
   config_types.to_unapply = to_unapply;
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoConfigureSyncer, core_, reason,
                  config_types, routing_info, ready_task, retry_callback));
 }
 
 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
     const ModelTypeSet enabled_types,
     const ModelTypeSet succeeded_configuration_types,
     const ModelTypeSet failed_configuration_types,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task) {
@@ skipping 14 matching lines @@
   Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
     const WeakHandle<JsBackend> js_backend,
     const WeakHandle<DataTypeDebugInfoListener> debug_info_listener,
     std::unique_ptr<ModelTypeConnector> model_type_connector,
     const std::string& cache_guid) {
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   model_type_connector_ = std::move(model_type_connector);
 
   if (!frontend_)
     return;
 
   initialized_ = true;
 
   if (invalidator_) {
     invalidator_->RegisterInvalidationHandler(this);
     invalidation_handler_registered_ = true;
 
     // Fake a state change to initialize the SyncManager's cached invalidator
     // state.
     OnInvalidatorStateChange(invalidator_->GetInvalidatorState());
   }
 
   // Now that we've downloaded the control types, we can see if there are any
   // experimental types to enable. This should be done before we inform
   // the frontend to ensure they're visible in the customize screen.
   AddExperimentalTypes();
   frontend_->OnBackendInitialized(js_backend, debug_info_listener, cache_guid,
                                   true);
 }
 
 void SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop() {
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (!frontend_)
     return;
 
   frontend_->OnBackendInitialized(WeakHandle<JsBackend>(),
                                   WeakHandle<DataTypeDebugInfoListener>(), "",
                                   false);
 }
 
 void SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop(
     const SyncCycleSnapshot& snapshot) {
   if (!frontend_)
     return;
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   last_snapshot_ = snapshot;
 
   SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 
   if (!snapshot.poll_finish_time().is_null())
     sync_prefs_->SetLastPollTime(snapshot.poll_finish_time());
 
   // Process any changes to the datatypes we're syncing.
   // TODO(sync): add support for removing types.
@@ skipping 17 matching lines @@
   if (token_type == PASSPHRASE_BOOTSTRAP_TOKEN)
     sync_prefs_->SetEncryptionBootstrapToken(token);
   else
     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop(
     const SyncProtocolError& sync_error) {
   if (!frontend_)
     return;
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnActionableError(sync_error);
 }
 
 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
     ModelTypeSet types) {
   if (!frontend_)
     return;
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnMigrationNeededForTypes(types);
 }
 
 void SyncBackendHostImpl::OnInvalidatorStateChange(InvalidatorState state) {
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
                             core_, state));
 }
 
 void SyncBackendHostImpl::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
-  sync_thread_->task_runner()->PostTask(
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnIncomingInvalidation,
                             core_, invalidation_map));
 }
 
 std::string SyncBackendHostImpl::GetOwnerName() const {
   return "SyncBackendHostImpl";
 }
 
 bool SyncBackendHostImpl::CheckPassphraseAgainstCachedPendingKeys(
     const std::string& passphrase) const {
   DCHECK(cached_pending_keys_.has_blob());
   DCHECK(!passphrase.empty());
   Nigori nigori;
   nigori.InitByDerivation("localhost", "dummy", passphrase);
   std::string plaintext;
   bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
   DVLOG_IF(1, result) << "Passphrase failed to decrypt pending keys.";
   return result;
 }
 
 void SyncBackendHostImpl::NotifyPassphraseRequired(
     PassphraseRequiredReason reason,
     sync_pb::EncryptedData pending_keys) {
   if (!frontend_)
     return;
 
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update our cache of the cryptographer's pending keys.
   cached_pending_keys_ = pending_keys;
 
   frontend_->OnPassphraseRequired(reason, pending_keys);
 }
 
 void SyncBackendHostImpl::NotifyPassphraseAccepted() {
   if (!frontend_)
     return;
 
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // Clear our cache of the cryptographer's pending keys.
   cached_pending_keys_.clear_blob();
   frontend_->OnPassphraseAccepted();
 }
 
 void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
     ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!frontend_)
     return;
 
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostImpl::NotifyEncryptionComplete() {
   if (!frontend_)
     return;
 
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop(
     PassphraseType type,
     base::Time explicit_passphrase_time) {
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Passphrase type changed to " << PassphraseTypeToString(type);
   cached_passphrase_type_ = type;
   cached_explicit_passphrase_time_ = explicit_passphrase_time;
 }
 
 void SyncBackendHostImpl::HandleLocalSetPassphraseEncryptionOnFrontendLoop(
     const SyncEncryptionHandler::NigoriState& nigori_state) {
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnLocalSetPassphraseEncryption(nigori_state);
 }
 
 void SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop(
     ConnectionStatus status) {
   if (!frontend_)
     return;
 
-  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Connection status changed: " << ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
     std::unique_ptr<ProtocolEvent> event) {
   if (!frontend_)
     return;
   frontend_->OnProtocolEvent(*event);
@@ skipping 22 matching lines @@
     return;
   frontend_->OnDatatypeStatusCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::UpdateInvalidationVersions(
     const std::map<ModelType, int64_t>& invalidation_versions) {
   sync_prefs_->UpdateInvalidationVersions(invalidation_versions);
 }
 
 void SyncBackendHostImpl::RefreshTypesForTest(ModelTypeSet types) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  sync_thread_->task_runner()->PostTask(
+  DCHECK(thread_checker_.CalledOnValidThread());
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_, types));
 }
 
 void SyncBackendHostImpl::ClearServerData(
     const SyncManager::ClearServerDataCallback& callback) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  sync_thread_->task_runner()->PostTask(
+  DCHECK(thread_checker_.CalledOnValidThread());
+  sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoClearServerData, core_, callback));
 }
 
 void SyncBackendHostImpl::OnCookieJarChanged(bool account_mismatch,
                                              bool empty_jar) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  sync_thread_->task_runner()->PostTask(
+  DCHECK(thread_checker_.CalledOnValidThread());
+  sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnCookieJarChanged, core_,
                             account_mismatch, empty_jar));
 }
 
 void SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop(
     const SyncManager::ClearServerDataCallback& frontend_callback) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   frontend_callback.Run();
 }
 
 }  // namespace syncer
 
 #undef SDVLOG
 
 #undef SLOG