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

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/message_loop/message_loop.h"
 #include "base/metrics/histogram.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 "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
@@ skipping 787 matching lines @@
 
   if (sync_thread_)
     sync_thread_->Stop();
 }
 
 void ProfileSyncService::ShutdownImpl(syncer::ShutdownReason reason) {
   if (!backend_) {
     if (reason == syncer::ShutdownReason::DISABLE_SYNC && sync_thread_) {
       // If the backend is already shut down when a DISABLE_SYNC happens,
       // the data directory needs to be cleaned up here.
-      sync_thread_->message_loop()->PostTask(FROM_HERE,
-          base::Bind(&DeleteSyncDataFolder, directory_path_));
+      sync_thread_->task_runner()->PostTask(
+          FROM_HERE, base::Bind(&DeleteSyncDataFolder, directory_path_));
     }
     return;
   }
 
   if (reason == syncer::ShutdownReason::STOP_SYNC
       || reason == syncer::ShutdownReason::DISABLE_SYNC) {
     RemoveClientFromServer();
   }
 
   non_blocking_data_type_manager_.DisconnectSyncBackend();
@@ skipping 40 matching lines @@
 
   // Don't let backup block sync regardless backup succeeded or not.
   if (backend_mode_ == BACKUP)
     backup_finished_ = true;
 
   // Sync could be blocked by rollback/backup. Post task to check whether sync
   // should start after shutting down rollback/backup backend.
   if ((backend_mode_ == ROLLBACK || backend_mode_ == BACKUP) &&
       reason != syncer::SWITCH_MODE_SYNC &&
       reason != syncer::BROWSER_SHUTDOWN) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ProfileSyncService::TryStartSyncAfterBackup,
                               startup_controller_weak_factory_.GetWeakPtr()));
   }
 
   // Clear various flags.
   backend_mode_ = IDLE;
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
   cached_passphrase_.clear();
@@ skipping 79 matching lines @@
   UMA_HISTOGRAM_ENUMERATION(kSyncUnrecoverableErrorHistogram,
                             unrecoverable_error_reason_,
                             ERROR_REASON_LIMIT);
   std::string location;
   from_here.Write(true, true, &location);
   LOG(ERROR)
       << "Unrecoverable error detected at " << location
       << " -- ProfileSyncService unusable: " << message;
 
   // Shut all data types down.
-  base::MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&ProfileSyncService::ShutdownImpl,
-                 weak_factory_.GetWeakPtr(),
-                 delete_sync_database ?
-                     syncer::DISABLE_SYNC : syncer::STOP_SYNC));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &ProfileSyncService::ShutdownImpl, weak_factory_.GetWeakPtr(),
+          delete_sync_database ? syncer::DISABLE_SYNC : syncer::STOP_SYNC));
 }
 
 void ProfileSyncService::ReenableDatatype(syncer::ModelType type) {
   if (!backend_initialized_)
     return;
   directory_data_type_manager_->ReenableType(type);
 }
 
 void ProfileSyncService::UpdateBackendInitUMA(bool success) {
   if (backend_mode_ != SYNC)
@@ skipping 125 matching lines @@
     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::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &SessionsSyncManager::DoGarbageCollection,
-            base::AsWeakPtr(sessions_sync_manager_.get())));
+    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;
 
@@ skipping 264 matching lines @@
 
   if (backend_mode_ != SYNC) {
     if (configure_status_ == DataTypeManager::OK) {
       StartSyncingWithServer();
 
       // Backup is done after models are associated.
       if (backend_mode_ == BACKUP)
         backup_finished_ = true;
 
       // Asynchronously check whether sync needs to start.
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&ProfileSyncService::TryStartSyncAfterBackup,
                                 startup_controller_weak_factory_.GetWeakPtr()));
     } else if (!expect_sync_configuration_aborted_) {
       DVLOG(1) << "Backup/rollback backend failed to configure.";
       ShutdownImpl(syncer::STOP_SYNC);
     }
 
     return;
   }
 
@@ skipping 1198 matching lines @@
 #if defined(ENABLE_PRE_SYNC_BACKUP)
   const base::Time last_synced_time = sync_prefs_.GetLastSyncedTime();
   // Check backup once a day.
   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_->message_loop_proxy()->PostTask(
+      sync_thread_->task_runner()->PostTask(
           FROM_HERE,
           base::Bind(syncer::CheckSyncDbLastModifiedTime,
                      profile_->GetPath().Append(kSyncBackupDataFolderName),
                      base::ThreadTaskRunnerHandle::Get(),
                      base::Bind(&ProfileSyncService::CheckSyncBackupCallback,
                                 weak_factory_.GetWeakPtr())));
     } else {
       content::BrowserThread::PostTask(
           content::BrowserThread::FILE, FROM_HERE,
           base::Bind(syncer::CheckSyncDbLastModifiedTime,
@@ skipping 90 matching lines @@
     } else {
       UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningBeforeCleanShutdown",
                            warning_received);
     }
   }
   sync_prefs_.SetMemoryPressureWarningCount(0);
   // Will set to true during a clean shutdown, so crash or something else will
   // remain this as false.
   sync_prefs_.SetCleanShutdown(false);
 }