Remove calls to deprecated MessageLoop methods in chrome.

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 "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 
 #include <stdint.h>
 #include <deque>
 #include <string>
 #include <utility>
@@ skipping 296 matching lines @@
 
 TEST(SyncTaskManagerTest, ScheduleTask) {
   base::MessageLoop message_loop;
   TaskManagerClient client(0 /* maximum_background_task */);
   int callback_count = 0;
   SyncStatusCode callback_status = SYNC_STATUS_OK;
 
   client.ScheduleTask(kStatus1, base::Bind(&IncrementAndAssign, 0,
                                            &callback_count,
                                            &callback_status));
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(kStatus1, callback_status);
   EXPECT_EQ(kStatus1, client.last_operation_status());
 
   EXPECT_EQ(1, callback_count);
   EXPECT_EQ(1, client.maybe_schedule_next_task_count());
   EXPECT_EQ(1, client.task_scheduled_count());
   EXPECT_EQ(0, client.idle_task_scheduled_count());
 }
 
 TEST(SyncTaskManagerTest, ScheduleTwoTasks) {
   base::MessageLoop message_loop;
   TaskManagerClient client(0 /* maximum_background_task */);
   int callback_count = 0;
   SyncStatusCode callback_status = SYNC_STATUS_OK;
 
   client.ScheduleTask(kStatus1, base::Bind(&IncrementAndAssign, 0,
                                            &callback_count,
                                            &callback_status));
   client.ScheduleTask(kStatus2, base::Bind(&IncrementAndAssign, 1,
                                            &callback_count,
                                            &callback_status));
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(kStatus2, callback_status);
   EXPECT_EQ(kStatus2, client.last_operation_status());
 
   EXPECT_EQ(2, callback_count);
   EXPECT_EQ(1, client.maybe_schedule_next_task_count());
   EXPECT_EQ(2, client.task_scheduled_count());
   EXPECT_EQ(0, client.idle_task_scheduled_count());
 }
 
 TEST(SyncTaskManagerTest, ScheduleIdleTask) {
   base::MessageLoop message_loop;
   TaskManagerClient client(0 /* maximum_background_task */);
 
   client.ScheduleTaskIfIdle(kStatus1);
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(kStatus1, client.last_operation_status());
 
   EXPECT_EQ(1, client.maybe_schedule_next_task_count());
   EXPECT_EQ(1, client.task_scheduled_count());
   EXPECT_EQ(1, client.idle_task_scheduled_count());
 }
 
 TEST(SyncTaskManagerTest, ScheduleIdleTaskWhileNotIdle) {
   base::MessageLoop message_loop;
   TaskManagerClient client(0 /* maximum_background_task */);
   int callback_count = 0;
   SyncStatusCode callback_status = SYNC_STATUS_OK;
 
   client.ScheduleTask(kStatus1, base::Bind(&IncrementAndAssign, 0,
                                            &callback_count,
                                            &callback_status));
   client.ScheduleTaskIfIdle(kStatus2);
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Idle task must not have run.
   EXPECT_EQ(kStatus1, callback_status);
   EXPECT_EQ(kStatus1, client.last_operation_status());
 
   EXPECT_EQ(1, callback_count);
   EXPECT_EQ(1, client.maybe_schedule_next_task_count());
   EXPECT_EQ(1, client.task_scheduled_count());
   EXPECT_EQ(0, client.idle_task_scheduled_count());
 }
 
 TEST(SyncTaskManagerTest, ScheduleAndCancelSyncTask) {
   base::MessageLoop message_loop;
 
   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::ThreadTaskRunnerHandle::Get(),
                                  nullptr /* worker_pool */);
     task_manager.Initialize(SYNC_STATUS_OK);
-    message_loop.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     task_manager.ScheduleSyncTask(
         FROM_HERE, std::unique_ptr<SyncTask>(
                        new MultihopSyncTask(&task_started, &task_completed)),
         SyncTaskManager::PRIORITY_MED,
         base::Bind(&IncrementAndAssign, 0, &callback_count, &status));
   }
-  message_loop.RunUntilIdle();
+  base::RunLoop().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::ThreadTaskRunnerHandle::Get(),
                                nullptr /* worker_pool */);
   task_manager.Initialize(SYNC_STATUS_OK);
-  message_loop.RunUntilIdle();
+  base::RunLoop().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;
 
   // This will run first even if its priority is low, since there're no
   // pending tasks.
@@ skipping 24 matching lines @@
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&IncrementAndAssign, 3, &callback_count, &callback_status4));
 
   // This runs third (expected counter == 2).
   task_manager.ScheduleTask(
       FROM_HERE,
       base::Bind(&DumbTask, kStatus5),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&IncrementAndAssign, 2, &callback_count, &callback_status5));
 
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(kStatus1, callback_status1);
   EXPECT_EQ(kStatus2, callback_status2);
   EXPECT_EQ(kStatus3, callback_status3);
   EXPECT_EQ(kStatus4, callback_status4);
   EXPECT_EQ(kStatus5, callback_status5);
   EXPECT_EQ(5, callback_count);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Sequential) {
@@ skipping 14 matching lines @@
   task_manager.ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(
                      new BackgroundTask("app_id", MAKE_PATH("/hoge"), &stats)),
       SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(new BackgroundTask(
                      "app_id", MAKE_PATH("/hoge/fuga/piyo"), &stats)),
       SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   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>(),
@@ skipping 12 matching lines @@
   task_manager.ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(
                      new BackgroundTask("app_id", MAKE_PATH("/fuga"), &stats)),
       SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(
                      new BackgroundTask("app_id", MAKE_PATH("/piyo"), &stats)),
       SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   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>(),
@@ skipping 12 matching lines @@
   task_manager.ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(
                      new BackgroundTask("app_id", MAKE_PATH("/fuga"), &stats)),
       SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(
                      new BackgroundTask("app_id", MAKE_PATH("/piyo"), &stats)),
       SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   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, UpdateTaskBlocker) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
@@ skipping 21 matching lines @@
     std::vector<std::string> paths;
     paths.push_back("/foo");
     paths.push_back("/foo/bar");
     paths.push_back("/hoge/fuga/piyo");
     task_manager.ScheduleSyncTask(
         FROM_HERE, std::unique_ptr<SyncTask>(new BlockerUpdateTestHelper(
                        "task2", "app_id", paths, &log)),
         SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status2));
   }
 
-  message_loop.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(SYNC_STATUS_OK, status1);
   EXPECT_EQ(SYNC_STATUS_OK, status2);
 
   ASSERT_EQ(14u, log.size());
   int i = 0;
 
   // task1 takes "/foo/bar" first.
   EXPECT_EQ("task1: updating to /foo/bar", log[i++]);
 
@@ skipping 17 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