Remove calls to MessageLoop::current() in components.

components/sync_driver/glue/sync_backend_host_core.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_core.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 115 matching lines @@
 }
 
 SyncBackendHostCore::~SyncBackendHostCore() {
   DCHECK(!sync_manager_.get());
 }
 
 void SyncBackendHostCore::OnSyncCycleCompleted(
     const syncer::sessions::SyncSessionSnapshot& snapshot) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop,
       snapshot);
 }
 
 void SyncBackendHostCore::DoRefreshTypes(syncer::ModelTypeSet types) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->RefreshTypes(types);
 }
 
 void SyncBackendHostCore::OnInitializationComplete(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     bool success,
     const syncer::ModelTypeSet restored_types) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   if (!success) {
     DoDestroySyncManager(syncer::STOP_SYNC);
     host_.Call(FROM_HERE,
                &SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop);
     return;
   }
 
   // Register for encryption related changes now. We have to do this before
   // the initializing downloading control types or initializing the encryption
@@ skipping 46 matching lines @@
       routing_info,
       base::Bind(&SyncBackendHostCore::DoInitialProcessControlTypes,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Closure());
 }
 
 void SyncBackendHostCore::OnConnectionStatusChange(
     syncer::ConnectionStatus status) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop, status);
 }
 
 void SyncBackendHostCore::OnPassphraseRequired(
     syncer::PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::NotifyPassphraseRequired, reason, pending_keys);
 }
 
 void SyncBackendHostCore::OnPassphraseAccepted() {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::NotifyPassphraseAccepted);
 }
 
 void SyncBackendHostCore::OnBootstrapTokenUpdated(
     const std::string& bootstrap_token,
     syncer::BootstrapTokenType type) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::PersistEncryptionBootstrapToken,
              bootstrap_token,
              type);
 }
 
 void SyncBackendHostCore::OnEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::NotifyEncryptedTypesChanged,
       encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostCore::OnEncryptionComplete() {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::NotifyEncryptionComplete);
 }
 
 void SyncBackendHostCore::OnCryptographerStateChanged(
     syncer::Cryptographer* cryptographer) {
   // Do nothing.
 }
@@ skipping 38 matching lines @@
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleDirectoryStatusCountersUpdatedOnFrontendLoop,
       type, counters);
 }
 
 void SyncBackendHostCore::OnActionableError(
     const syncer::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop,
       sync_error);
 }
 
 void SyncBackendHostCore::OnMigrationRequested(syncer::ModelTypeSet types) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop,
       types);
 }
 
 void SyncBackendHostCore::OnProtocolEvent(
     const syncer::ProtocolEvent& event) {
   // TODO(rlarocque): Find a way to pass event_clone as a scoped_ptr.
   if (forward_protocol_events_) {
     std::unique_ptr<syncer::ProtocolEvent> event_clone(event.Clone());
     host_.Call(
         FROM_HERE,
         &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
         event_clone.release());
   }
 }
 
 void SyncBackendHostCore::DoOnInvalidatorStateChange(
     syncer::InvalidatorState state) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->SetInvalidatorEnabled(state == syncer::INVALIDATIONS_ENABLED);
 }
 
 void SyncBackendHostCore::DoOnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   syncer::ObjectIdSet ids = invalidation_map.GetObjectIds();
   for (const invalidation::ObjectId& object_id : ids) {
     syncer::ModelType type;
     if (!NotificationTypeToRealModelType(object_id.name(), &type)) {
       DLOG(WARNING) << "Notification has invalid id: "
                     << syncer::ObjectIdToString(object_id);
     } else {
       syncer::SingleObjectInvalidationSet invalidation_set =
           invalidation_map.ForObject(object_id);
@@ skipping 75 matching lines @@
   args.unrecoverable_error_handler = options->unrecoverable_error_handler;
   args.report_unrecoverable_error_function =
       options->report_unrecoverable_error_function;
   args.cancelation_signal = &stop_syncing_signal_;
   args.saved_nigori_state = std::move(options->saved_nigori_state);
   sync_manager_->Init(&args);
 }
 
 void SyncBackendHostCore::DoUpdateCredentials(
     const syncer::SyncCredentials& credentials) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   // UpdateCredentials can be called during backend initialization, possibly
   // when backend initialization has failed but hasn't notified the UI thread
   // yet. In that case, the sync manager may have been destroyed on the sync
   // thread before this task was executed, so we do nothing.
   if (sync_manager_) {
     sync_manager_->UpdateCredentials(credentials);
   }
 }
 
 void SyncBackendHostCore::DoStartSyncing(
     const syncer::ModelSafeRoutingInfo& routing_info,
     base::Time last_poll_time) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->StartSyncingNormally(routing_info, last_poll_time);
 }
 
 void SyncBackendHostCore::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->GetEncryptionHandler()->SetEncryptionPassphrase(
       passphrase, is_explicit);
 }
 
 void SyncBackendHostCore::DoInitialProcessControlTypes() {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   DVLOG(1) << "Initilalizing Control Types";
 
   // Initialize encryption.
   sync_manager_->GetEncryptionHandler()->Init();
 
   // Note: experiments are currently handled via SBH::AddExperimentalTypes,
   // which is called at the end of every sync cycle.
   // TODO(zea): eventually add an experiment handler and initialize it here.
 
@@ skipping 18 matching lines @@
              js_backend_, debug_info_listener_,
              base::Passed(sync_manager_->GetModelTypeConnectorProxy()),
              sync_manager_->cache_guid());
 
   js_backend_.Reset();
   debug_info_listener_.Reset();
 }
 
 void SyncBackendHostCore::DoSetDecryptionPassphrase(
     const std::string& passphrase) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->GetEncryptionHandler()->SetDecryptionPassphrase(
       passphrase);
 }
 
 void SyncBackendHostCore::DoEnableEncryptEverything() {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->GetEncryptionHandler()->EnableEncryptEverything();
 }
 
 void SyncBackendHostCore::ShutdownOnUIThread() {
   // This will cut short any blocking network tasks, cut short any in-progress
   // sync cycles, and prevent the creation of new blocking network tasks and new
   // sync cycles.  If there was an in-progress network request, it would have
   // had a reference to the RequestContextGetter.  This reference will be
   // dropped by the time this function returns.
   //
   // It is safe to call this even if Sync's backend classes have not been
   // initialized yet.  Those classes will receive the message when the sync
   // thread finally getes around to constructing them.
   stop_syncing_signal_.Signal();
 
   // This will drop the HttpBridgeFactory's reference to the
   // RequestContextGetter.  Once this has been called, the HttpBridgeFactory can
   // no longer be used to create new HttpBridge instances.  We can get away with
   // this because the stop_syncing_signal_ has already been signalled, which
   // guarantees that the ServerConnectionManager will no longer attempt to
   // create new connections.
   release_request_context_signal_.Signal();
 }
 
 void SyncBackendHostCore::DoShutdown(syncer::ShutdownReason reason) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   DoDestroySyncManager(reason);
 
   registrar_ = NULL;
 
   if (reason == syncer::DISABLE_SYNC)
     DeleteSyncDataFolder();
 
   host_.Reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void SyncBackendHostCore::DoDestroySyncManager(syncer::ShutdownReason reason) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   if (sync_manager_) {
     DisableDirectoryTypeDebugInfoForwarding();
     save_changes_timer_.reset();
     sync_manager_->RemoveObserver(this);
     sync_manager_->ShutdownOnSyncThread(reason);
     sync_manager_.reset();
   }
 }
 
 void SyncBackendHostCore::DoConfigureSyncer(
     syncer::ConfigureReason reason,
     const DoConfigureSyncerTypes& config_types,
     const syncer::ModelSafeRoutingInfo routing_info,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   DCHECK(!ready_task.is_null());
   DCHECK(!retry_callback.is_null());
   base::Closure chained_ready_task(
       base::Bind(&SyncBackendHostCore::DoFinishConfigureDataTypes,
                  weak_ptr_factory_.GetWeakPtr(),
                  config_types.to_download,
                  ready_task));
   base::Closure chained_retry_task(
       base::Bind(&SyncBackendHostCore::DoRetryConfiguration,
                  weak_ptr_factory_.GetWeakPtr(),
                  retry_callback));
   sync_manager_->ConfigureSyncer(reason,
                                  config_types.to_download,
                                  config_types.to_purge,
                                  config_types.to_journal,
                                  config_types.to_unapply,
                                  routing_info,
                                  chained_ready_task,
                                  chained_retry_task);
 }
 
 void SyncBackendHostCore::DoFinishConfigureDataTypes(
     syncer::ModelTypeSet types_to_config,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   // Update the enabled types for the bridge and sync manager.
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routing_info);
   enabled_types.RemoveAll(syncer::ProxyTypes());
 
   const syncer::ModelTypeSet failed_configuration_types =
       Difference(types_to_config, sync_manager_->InitialSyncEndedTypes());
   const syncer::ModelTypeSet succeeded_configuration_types =
       Difference(types_to_config, failed_configuration_types);
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop,
              enabled_types,
              succeeded_configuration_types,
              failed_configuration_types,
              ready_task);
 }
 
 void SyncBackendHostCore::DoRetryConfiguration(
     const base::Closure& retry_callback) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::RetryConfigurationOnFrontendLoop,
              retry_callback);
 }
 
 void SyncBackendHostCore::SendBufferedProtocolEventsAndEnableForwarding() {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   forward_protocol_events_ = true;
 
   if (sync_manager_) {
     // Grab our own copy of the buffered events.
     // The buffer is not modified by this operation.
     std::vector<syncer::ProtocolEvent*> buffered_events;
     sync_manager_->GetBufferedProtocolEvents().release(&buffered_events);
 
     // Send them all over the fence to the host.
     for (std::vector<syncer::ProtocolEvent*>::iterator it =
@@ skipping 27 matching lines @@
   if (!forward_type_info_)
     return;
 
   forward_type_info_ = false;
 
   if (sync_manager_->HasDirectoryTypeDebugInfoObserver(this))
     sync_manager_->UnregisterDirectoryTypeDebugInfoObserver(this);
 }
 
 void SyncBackendHostCore::DeleteSyncDataFolder() {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   if (base::DirectoryExists(sync_data_folder_path_)) {
     if (!base::DeleteFile(sync_data_folder_path_, true))
       SLOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 void SyncBackendHostCore::GetAllNodesForTypes(
     syncer::ModelTypeSet types,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     base::Callback<void(const std::vector<syncer::ModelType>& type,
@@ skipping 17 matching lines @@
 
   task_runner->PostTask(
       FROM_HERE,
       base::Bind(callback, types_vector, base::Passed(&node_lists)));
 }
 
 void SyncBackendHostCore::StartSavingChanges() {
   // We may already be shut down.
   if (!sync_loop_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   DCHECK(!save_changes_timer_.get());
   save_changes_timer_.reset(new base::RepeatingTimer());
   save_changes_timer_->Start(FROM_HERE,
       base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &SyncBackendHostCore::SaveChanges);
 }
 
 void SyncBackendHostCore::SaveChanges() {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHostCore::DoClearServerData(
     const syncer::SyncManager::ClearServerDataCallback& frontend_callback) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   const syncer::SyncManager::ClearServerDataCallback callback =
       base::Bind(&SyncBackendHostCore::ClearServerDataDone,
                  weak_ptr_factory_.GetWeakPtr(), frontend_callback);
   sync_manager_->ClearServerData(callback);
 }
 
 void SyncBackendHostCore::DoOnCookieJarChanged(bool account_mismatch,
                                                bool empty_jar) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->OnCookieJarChanged(account_mismatch, empty_jar);
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
-  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 
 }  // namespace browser_sync