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

chrome/browser/sync_file_system/drive_backend/sync_task_manager_unittest.cc

 // Copyright 2014 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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define MAKE_PATH(path)                                       \
   base::FilePath(storage::VirtualPath::GetNormalizedFilePath( \
       base::FilePath(FILE_PATH_LITERAL(path))))
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 void DumbTask(SyncStatusCode status,
               const SyncStatusCallback& callback) {
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, status));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                base::Bind(callback, status));
 }
 
 void IncrementAndAssign(int expected_before_counter,
                         int* counter,
                         SyncStatusCode* status_out,
                         SyncStatusCode status) {
   EXPECT_EQ(expected_before_counter, *counter);
   ++(*counter);
   *status_out = status;
 }
@@ skipping 62 matching lines @@
     return last_operation_status_;
   }
 
  private:
   void DoTask(SyncStatusCode status_to_return,
               bool is_idle_task,
               const SyncStatusCallback& callback) {
     ++task_scheduled_count_;
     if (is_idle_task)
       ++idle_task_scheduled_count_;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, status_to_return));
   }
 
   scoped_ptr<SyncTaskManager> task_manager_;
 
   int maybe_schedule_next_task_count_;
   int task_scheduled_count_;
   int idle_task_scheduled_count_;
 
   SyncStatusCode last_operation_status_;
@@ skipping 10 matching lines @@
         weak_ptr_factory_(this) {
     DCHECK(task_started_);
     DCHECK(task_completed_);
   }
 
   ~MultihopSyncTask() override {}
 
   void RunExclusive(const SyncStatusCallback& callback) override {
     DCHECK(!*task_started_);
     *task_started_ = true;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MultihopSyncTask::CompleteTask,
                               weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  private:
   void CompleteTask(const SyncStatusCallback& callback) {
     DCHECK(*task_started_);
     DCHECK(!*task_completed_);
     *task_completed_ = true;
     callback.Run(SYNC_STATUS_OK);
@@ skipping 40 matching lines @@
         base::Bind(&BackgroundTask::RunAsBackgroundTask,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
   void RunAsBackgroundTask(scoped_ptr<SyncTaskToken> token) {
     ++(stats_->running_background_task);
     if (stats_->max_parallel_task < stats_->running_background_task)
       stats_->max_parallel_task = stats_->running_background_task;
 
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&BackgroundTask::CompleteTask,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Passed(&token)));
+                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
   }
 
   void CompleteTask(scoped_ptr<SyncTaskToken> token) {
     ++(stats_->finished_task);
     --(stats_->running_background_task);
     SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
   }
 
   std::string app_id_;
   base::FilePath path_;
@@ skipping 47 matching lines @@
     SyncTaskManager::UpdateTaskBlocker(
         token.Pass(), task_blocker.Pass(),
         base::Bind(&BlockerUpdateTestHelper::UpdateBlockerSoon,
                    weak_ptr_factory_.GetWeakPtr(),
                    updating_to));
   }
 
   void UpdateBlockerSoon(const std::string& updated_to,
                          scoped_ptr<SyncTaskToken> token) {
     log_->push_back(name_ + ": updated to " + updated_to);
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&BlockerUpdateTestHelper::UpdateBlocker,
                    weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
   }
 
   std::string name_;
   std::string app_id_;
   std::deque<std::string> paths_;
   Log* log_;
 
@@ skipping 378 matching lines @@
 
   EXPECT_EQ("task1: finished", log[i++]);
 
   EXPECT_EQ("task2: updating to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: updated to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: finished", log[i++]);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system