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

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 <map>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/sync_driver/glue/sync_backend_host_core.h"
 #include "components/sync_driver/glue/sync_backend_registrar.h"
 #include "components/sync_driver/invalidation_helper.h"
 #include "components/sync_driver/sync_client.h"
 #include "components/sync_driver/sync_driver_switches.h"
 #include "components/sync_driver/sync_frontend.h"
 #include "components/sync_driver/sync_prefs.h"
@@ skipping 19 matching lines @@
 
 namespace browser_sync {
 
 SyncBackendHostImpl::SyncBackendHostImpl(
     const std::string& name,
     sync_driver::SyncClient* sync_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
     invalidation::InvalidationService* invalidator,
     const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
     const base::FilePath& sync_folder)
-    : frontend_loop_(base::MessageLoop::current()),
+    : frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       sync_client_(sync_client),
       ui_thread_(ui_thread),
       name_(name),
       initialized_(false),
       sync_prefs_(sync_prefs),
       frontend_(NULL),
       cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE),
       invalidator_(invalidator),
       invalidation_handler_registered_(false),
       weak_ptr_factory_(this) {
@@ skipping 101 matching lines @@
   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_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   // SetEncryptionPassphrase should never be called if we are currently
   // encrypted with an explicit passphrase.
   DCHECK(cached_passphrase_type_ == syncer::KEYSTORE_PASSPHRASE ||
          cached_passphrase_type_ == syncer::IMPLICIT_PASSPHRASE);
 
   // Post an encryption task on the syncer thread.
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetEncryptionPassphrase,
                             core_.get(), 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_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   // 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.
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetDecryptionPassphrase,
                             core_.get(), 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_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   // Immediately stop sending messages to the frontend.
   frontend_ = NULL;
 
   DCHECK(registrar_->sync_thread()->IsRunning());
 
   registrar_->RequestWorkerStopOnUIThread();
 
   core_->ShutdownOnUIThread();
 }
@@ skipping 286 matching lines @@
                  core_));
 }
 
 void SyncBackendHostImpl::GetAllNodesForTypes(
     syncer::ModelTypeSet types,
     base::Callback<void(const std::vector<syncer::ModelType>&,
                         ScopedVector<base::ListValue>)> callback) {
   DCHECK(initialized());
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::GetAllNodesForTypes, core_,
-                            types, frontend_loop_->task_runner(), callback));
+                            types, frontend_task_runner_, callback));
 }
 
 void SyncBackendHostImpl::InitCore(
     std::unique_ptr<DoInitializeOptions> options) {
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoInitialize, core_.get(),
                             base::Passed(&options)));
 }
 
 void SyncBackendHostImpl::RequestConfigureSyncer(
@@ skipping 42 matching lines @@
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend> js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
         debug_info_listener,
     std::unique_ptr<syncer_v2::ModelTypeConnector> model_type_connector,
     const std::string& cache_guid) {
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   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_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   if (!frontend_)
     return;
 
   frontend_->OnBackendInitialized(
       syncer::WeakHandle<syncer::JsBackend>(),
       syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(),
       "",
       false);
 }
 
 void SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop(
     const syncer::sessions::SyncSessionSnapshot& snapshot) {
   if (!frontend_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   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 == syncer::PASSPHRASE_BOOTSTRAP_TOKEN)
     sync_prefs_->SetEncryptionBootstrapToken(token);
   else
     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop(
     const syncer::SyncProtocolError& sync_error) {
   if (!frontend_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   frontend_->OnActionableError(sync_error);
 }
 
 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
     syncer::ModelTypeSet types) {
   if (!frontend_)
     return;
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   frontend_->OnMigrationNeededForTypes(types);
 }
 
 void SyncBackendHostImpl::OnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
                             core_.get(), state));
 }
 
@@ skipping 19 matching lines @@
   DVLOG_IF(1, result) << "Passphrase failed to decrypt pending keys.";
   return result;
 }
 
 void SyncBackendHostImpl::NotifyPassphraseRequired(
     syncer::PassphraseRequiredReason reason,
     sync_pb::EncryptedData pending_keys) {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   // 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_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   // Clear our cache of the cryptographer's pending keys.
   cached_pending_keys_.clear_blob();
   frontend_->OnPassphraseAccepted();
 }
 
 void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   frontend_->OnEncryptedTypesChanged(
       encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostImpl::NotifyEncryptionComplete() {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop(
     syncer::PassphraseType type,
     base::Time explicit_passphrase_time) {
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "Passphrase type changed to "
            << syncer::PassphraseTypeToString(type);
   cached_passphrase_type_ = type;
   cached_explicit_passphrase_time_ = explicit_passphrase_time;
 }
 
 void SyncBackendHostImpl::HandleLocalSetPassphraseEncryptionOnFrontendLoop(
     const syncer::SyncEncryptionHandler::NigoriState& nigori_state) {
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   frontend_->OnLocalSetPassphraseEncryption(nigori_state);
 }
 
 void SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop(
     syncer::ConnectionStatus status) {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "Connection status changed: "
            << syncer::ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
     syncer::ProtocolEvent* event) {
   std::unique_ptr<syncer::ProtocolEvent> scoped_event(event);
   if (!frontend_)
@@ skipping 62 matching lines @@
     const syncer::SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   frontend_callback.Run();
 }
 
 }  // namespace browser_sync
 
 #undef SDVLOG
 
 #undef SLOG