chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/browser/sync/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 "chrome/browser/sync/glue/sync_backend_host_impl.h"
 
 #include "base/command_line.h"
+#include "base/location.h"
 #include "base/logging.h"
+#include "base/single_thread_task_runner.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/sync/glue/invalidation_helper.h"
 #include "chrome/browser/sync/glue/sync_backend_host_core.h"
 #include "chrome/browser/sync/glue/sync_backend_registrar.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/invalidation/invalidation_service.h"
 #include "components/invalidation/object_id_invalidation_map.h"
@@ skipping 136 matching lines @@
       scoped_ptr<InternalComponentsFactory>(
           new syncer::InternalComponentsFactoryImpl(factory_switches)).Pass(),
       unrecoverable_error_handler.Pass(),
       report_unrecoverable_error_function));
   InitCore(init_opts.Pass());
 }
 
 void SyncBackendHostImpl::UpdateCredentials(
     const syncer::SyncCredentials& credentials) {
   DCHECK(registrar_->sync_thread()->IsRunning());
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoUpdateCredentials,
-                 core_.get(),
-                 credentials));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoUpdateCredentials,
+                            core_.get(), credentials));
 }
 
 void SyncBackendHostImpl::StartSyncingWithServer() {
   SDVLOG(1) << "SyncBackendHostImpl::StartSyncingWithServer called.";
 
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
 
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoStartSyncing,
-                 core_.get(), routing_info, sync_prefs_->GetLastPollTime()));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoStartSyncing, core_.get(),
+                            routing_info, sync_prefs_->GetLastPollTime()));
 }
 
 void SyncBackendHostImpl::SetEncryptionPassphrase(const std::string& passphrase,
                                                   bool is_explicit) {
   DCHECK(registrar_->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_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // 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()->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoSetEncryptionPassphrase,
-                 core_.get(),
-                 passphrase, is_explicit));
+  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_);
 
   // 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()->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoSetDecryptionPassphrase,
-                 core_.get(),
-                 passphrase));
+  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.
@@ skipping 32 matching lines @@
   if (invalidation_handler_registered_) {
     if (reason == syncer::DISABLE_SYNC) {
       UnregisterInvalidationIds();
     }
     invalidator_->UnregisterInvalidationHandler(this);
     invalidator_ = NULL;
   }
   invalidation_handler_registered_ = false;
 
   // Shut down and destroy sync manager.
-  registrar_->sync_thread()->message_loop()->PostTask(
+  registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoShutdown,
-                 core_.get(), reason));
+      base::Bind(&SyncBackendHostCore::DoShutdown, core_.get(), reason));
   core_ = NULL;
 
   // Worker cleanup.
   SyncBackendRegistrar* detached_registrar = registrar_.release();
-  detached_registrar->sync_thread()->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncBackendRegistrar::Shutdown,
-                 base::Unretained(detached_registrar)));
+  detached_registrar->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendRegistrar::Shutdown,
+                            base::Unretained(detached_registrar)));
 
   if (sync_thread_claimed)
     return detached_registrar->ReleaseSyncThread();
   else
     return scoped_ptr<base::Thread>();
 }
 
 void SyncBackendHostImpl::UnregisterInvalidationIds() {
   if (invalidation_handler_registered_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(this,
@@ skipping 124 matching lines @@
                          retry_callback);
 
   DCHECK(syncer::Intersection(active_types, types_to_purge).Empty());
   DCHECK(syncer::Intersection(active_types, fatal_types).Empty());
   DCHECK(syncer::Intersection(active_types, unapply_types).Empty());
   DCHECK(syncer::Intersection(active_types, inactive_types).Empty());
   return syncer::Difference(active_types, types_to_download);
 }
 
 void SyncBackendHostImpl::EnableEncryptEverything() {
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
-     base::Bind(&SyncBackendHostCore::DoEnableEncryptEverything,
-                core_.get()));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncBackendHostCore::DoEnableEncryptEverything, core_.get()));
 }
 
 void SyncBackendHostImpl::ActivateDataType(
     syncer::ModelType type, syncer::ModelSafeGroup group,
     sync_driver::ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHostImpl::DeactivateDataType(syncer::ModelType type) {
   registrar_->DeactivateDataType(type);
@@ skipping 53 matching lines @@
   }
 }
 
 void SyncBackendHostImpl::FlushDirectory() const {
   DCHECK(initialized());
   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHostCore::SaveChanges, core_));
 }
 
 void SyncBackendHostImpl::RequestBufferedProtocolEventsAndEnableForwarding() {
-  registrar_->sync_thread()->message_loop()->PostTask(
+  registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(
           &SyncBackendHostCore::SendBufferedProtocolEventsAndEnableForwarding,
           core_));
 }
 
 void SyncBackendHostImpl::DisableProtocolEventForwarding() {
-  registrar_->sync_thread()->message_loop()->PostTask(
+  registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(
-          &SyncBackendHostCore::DisableProtocolEventForwarding,
-          core_));
+      base::Bind(&SyncBackendHostCore::DisableProtocolEventForwarding, core_));
 }
 
 void SyncBackendHostImpl::EnableDirectoryTypeDebugInfoForwarding() {
   DCHECK(initialized());
-  registrar_->sync_thread()->message_loop()->PostTask(
+  registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(
-          &SyncBackendHostCore::EnableDirectoryTypeDebugInfoForwarding,
-          core_));
+      base::Bind(&SyncBackendHostCore::EnableDirectoryTypeDebugInfoForwarding,
+                 core_));
 }
 
 void SyncBackendHostImpl::DisableDirectoryTypeDebugInfoForwarding() {
   DCHECK(initialized());
-  registrar_->sync_thread()->message_loop()->PostTask(
+  registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(
-          &SyncBackendHostCore::DisableDirectoryTypeDebugInfoForwarding,
-          core_));
+      base::Bind(&SyncBackendHostCore::DisableDirectoryTypeDebugInfoForwarding,
+                 core_));
 }
 
 void SyncBackendHostImpl::GetAllNodesForTypes(
     syncer::ModelTypeSet types,
     base::Callback<void(const std::vector<syncer::ModelType>&,
                         ScopedVector<base::ListValue>)> callback) {
   DCHECK(initialized());
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
-       base::Bind(
-           &SyncBackendHostCore::GetAllNodesForTypes,
-           core_,
-           types,
-           frontend_loop_->message_loop_proxy(),
-           callback));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::GetAllNodesForTypes, core_,
+                            types, frontend_loop_->task_runner(), callback));
 }
 
 void SyncBackendHostImpl::InitCore(scoped_ptr<DoInitializeOptions> options) {
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoInitialize,
-                 core_.get(), base::Passed(&options)));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoInitialize, core_.get(),
+                            base::Passed(&options)));
 }
 
 void SyncBackendHostImpl::RequestConfigureSyncer(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet to_download,
     syncer::ModelTypeSet to_purge,
     syncer::ModelTypeSet to_journal,
     syncer::ModelTypeSet to_unapply,
     syncer::ModelTypeSet to_ignore,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::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;
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
-       base::Bind(&SyncBackendHostCore::DoConfigureSyncer,
-                  core_.get(),
-                  reason,
-                  config_types,
-                  routing_info,
-                  ready_task,
-                  retry_callback));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncBackendHostCore::DoConfigureSyncer, core_.get(), reason,
+                 config_types, routing_info, ready_task, retry_callback));
 }
 
 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
     const syncer::ModelTypeSet enabled_types,
     const syncer::ModelTypeSet succeeded_configuration_types,
     const syncer::ModelTypeSet failed_configuration_types,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task) {
   if (!frontend_)
     return;
 
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(
         this, ModelTypeSetToObjectIdSet(enabled_types)));
   }
 
   if (!ready_task.is_null())
     ready_task.Run(succeeded_configuration_types, failed_configuration_types);
 }
 
 void SyncBackendHostImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(type, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL);
 
   content::Details<const syncer::ModelTypeSet> state_details(details);
   const syncer::ModelTypeSet& types = *(state_details.ptr());
-  registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_.get(), types));
 }
 
 void SyncBackendHostImpl::AddExperimentalTypes() {
   CHECK(initialized());
   syncer::Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
@@ skipping 98 matching lines @@
 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
     syncer::ModelTypeSet types) {
   if (!frontend_)
     return;
   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   frontend_->OnMigrationNeededForTypes(types);
 }
 
 void SyncBackendHostImpl::OnInvalidatorStateChange(
     syncer::InvalidatorState state) {
-  registrar_->sync_thread()->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
-                 core_.get(),
-                 state));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
+                            core_.get(), state));
 }
 
 void SyncBackendHostImpl::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
-  registrar_->sync_thread()->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncBackendHostCore::DoOnIncomingInvalidation,
-                 core_.get(),
-                 invalidation_map));
+  registrar_->sync_thread()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnIncomingInvalidation,
+                            core_.get(), 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());
@@ skipping 105 matching lines @@
 
 base::MessageLoop* SyncBackendHostImpl::GetSyncLoopForTesting() {
   return registrar_->sync_thread()->message_loop();
 }
 
 }  // namespace browser_sync
 
 #undef SDVLOG
 
 #undef SLOG