Replace MessageLoopProxy::current() with ThreadTaskRunnerHandle::Get()

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/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.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 "testing/gtest/include/gtest/gtest.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 #define MAKE_PATH(path)                                       \
   base::FilePath(fileapi::VirtualPath::GetNormalizedFilePath( \
       base::FilePath(FILE_PATH_LITERAL(path))))
@@ skipping 31 matching lines @@
     : public SyncTaskManager::Client,
       public base::SupportsWeakPtr<TaskManagerClient> {
  public:
   explicit TaskManagerClient(int64 maximum_background_task)
       : maybe_schedule_next_task_count_(0),
         task_scheduled_count_(0),
         idle_task_scheduled_count_(0),
         last_operation_status_(SYNC_STATUS_OK) {
     task_manager_.reset(new SyncTaskManager(
         AsWeakPtr(), maximum_background_task,
-        base::MessageLoopProxy::current()));
+        base::ThreadTaskRunnerHandle::Get()));
     task_manager_->Initialize(SYNC_STATUS_OK);
     base::MessageLoop::current()->RunUntilIdle();
     maybe_schedule_next_task_count_ = 0;
   }
   virtual ~TaskManagerClient() {}
 
   // DriveFileSyncManager::Client overrides.
   virtual void MaybeScheduleNextTask() OVERRIDE {
     ++maybe_schedule_next_task_count_;
   }
@@ skipping 314 matching lines @@
 
   int callback_count = 0;
   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
   bool task_started = false;
   bool task_completed = false;
 
   {
     SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                  0 /* maximum_background_task */,
-                                 base::MessageLoopProxy::current());
+                                 base::ThreadTaskRunnerHandle::Get());
     task_manager.Initialize(SYNC_STATUS_OK);
     message_loop.RunUntilIdle();
     task_manager.ScheduleSyncTask(
         FROM_HERE,
         scoped_ptr<SyncTask>(new MultihopSyncTask(
             &task_started, &task_completed)),
         SyncTaskManager::PRIORITY_MED,
         base::Bind(&IncrementAndAssign, 0, &callback_count, &status));
   }
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(0, callback_count);
   EXPECT_EQ(SYNC_STATUS_UNKNOWN, status);
   EXPECT_TRUE(task_started);
   EXPECT_FALSE(task_completed);
 }
 
 TEST(SyncTaskManagerTest, ScheduleTaskAtPriority) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                0 /* maximum_background_task */,
-                               base::MessageLoopProxy::current());
+                               base::ThreadTaskRunnerHandle::Get());
   task_manager.Initialize(SYNC_STATUS_OK);
   message_loop.RunUntilIdle();
 
   int callback_count = 0;
   SyncStatusCode callback_status1 = SYNC_STATUS_OK;
   SyncStatusCode callback_status2 = SYNC_STATUS_OK;
   SyncStatusCode callback_status3 = SYNC_STATUS_OK;
   SyncStatusCode callback_status4 = SYNC_STATUS_OK;
   SyncStatusCode callback_status5 = SYNC_STATUS_OK;
 
@@ skipping 40 matching lines @@
   EXPECT_EQ(kStatus3, callback_status3);
   EXPECT_EQ(kStatus4, callback_status4);
   EXPECT_EQ(kStatus5, callback_status5);
   EXPECT_EQ(5, callback_count);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Sequential) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
-                               base::MessageLoopProxy::current());
+                               base::ThreadTaskRunnerHandle::Get());
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   BackgroundTask::Stats stats;
   task_manager.ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(new BackgroundTask(
           "app_id", MAKE_PATH("/hoge/fuga"),
           &stats)),
       SyncTaskManager::PRIORITY_MED,
@@ skipping 20 matching lines @@
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_EQ(0, stats.running_background_task);
   EXPECT_EQ(3, stats.finished_task);
   EXPECT_EQ(1, stats.max_parallel_task);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Parallel) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
-                               base::MessageLoopProxy::current());
+                               base::ThreadTaskRunnerHandle::Get());
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   BackgroundTask::Stats stats;
   task_manager.ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(new BackgroundTask(
           "app_id", MAKE_PATH("/hoge"),
           &stats)),
       SyncTaskManager::PRIORITY_MED,
@@ skipping 20 matching lines @@
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_EQ(0, stats.running_background_task);
   EXPECT_EQ(3, stats.finished_task);
   EXPECT_EQ(3, stats.max_parallel_task);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Throttled) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                2 /* maximum_background_task */,
-                               base::MessageLoopProxy::current());
+                               base::ThreadTaskRunnerHandle::Get());
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   BackgroundTask::Stats stats;
   task_manager.ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(new BackgroundTask(
           "app_id", MAKE_PATH("/hoge"),
           &stats)),
       SyncTaskManager::PRIORITY_MED,
@@ skipping 20 matching lines @@
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_EQ(0, stats.running_background_task);
   EXPECT_EQ(3, stats.finished_task);
   EXPECT_EQ(2, stats.max_parallel_task);
 }
 
 TEST(SyncTaskManagerTest, UpdateBlockingFactor) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
-                               base::MessageLoopProxy::current());
+                               base::ThreadTaskRunnerHandle::Get());
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status1 = SYNC_STATUS_FAILED;
   SyncStatusCode status2 = SYNC_STATUS_FAILED;
   BlockerUpdateTestHelper::Log log;
 
   {
     std::vector<std::string> paths;
     paths.push_back("/foo/bar");
     paths.push_back("/foo");
@@ skipping 50 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