Remove calls to deprecated MessageLoop methods in chrome.

chrome/browser/sync_file_system/local/local_file_sync_context_unittest.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_file_system/local/local_file_sync_context.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 #include "chrome/browser/sync_file_system/sync_status_code.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 71 matching lines @@
   }
 
   SyncStatusCode PrepareForSync(FileSystemContext* file_system_context,
                                 const FileSystemURL& url,
                                 LocalFileSyncContext::SyncMode sync_mode,
                                 SyncFileMetadata* metadata,
                                 FileChangeList* changes,
                                 storage::ScopedFile* snapshot) {
     StartPrepareForSync(file_system_context, url, sync_mode,
                         metadata, changes, snapshot);
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     return status_;
   }
 
   base::Closure GetPrepareForSyncClosure(
       FileSystemContext* file_system_context,
       const FileSystemURL& url,
       LocalFileSyncContext::SyncMode sync_mode,
       SyncFileMetadata* metadata,
       FileChangeList* changes,
       storage::ScopedFile* snapshot) {
@@ skipping 35 matching lines @@
                              LocalFileSyncContext::SYNC_EXCLUSIVE,
                              &metadata, &changes, nullptr));
     EXPECT_EQ(expected_file_type, metadata.file_type);
 
     status_ = SYNC_STATUS_UNKNOWN;
     sync_context_->ApplyRemoteChange(
         file_system_context, change, local_path, url,
         base::Bind(&LocalFileSyncContextTest::DidApplyRemoteChange,
                    base::Unretained(this),
                    base::RetainedRef(file_system_context), url));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     return status_;
   }
 
   void DidApplyRemoteChange(FileSystemContext* file_system_context,
                             const FileSystemURL& url,
                             SyncStatusCode status) {
     status_ = status;
     sync_context_->FinalizeExclusiveSync(
         file_system_context, url,
         status == SYNC_STATUS_OK /* clear_local_changes */,
@@ skipping 14 matching lines @@
     }
     ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
     file_error_ = base::File::FILE_ERROR_FAILED;
     file_system->operation_runner()->Truncate(
         url, 1, base::Bind(&LocalFileSyncContextTest::DidModifyFile,
                            base::Unretained(this)));
   }
 
   base::File::Error WaitUntilModifyFileIsDone() {
     while (!async_modify_finished_)
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     return file_error_;
   }
 
   void DidModifyFile(base::File::Error error) {
     if (!ui_task_runner_->RunsTasksOnCurrentThread()) {
       ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
       ui_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&LocalFileSyncContextTest::DidModifyFile,
                      base::Unretained(this), error));
@@ skipping 108 matching lines @@
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     StartModifyFileOnIOThread(&file_system, kFile);
 
     if (sync_mode == LocalFileSyncContext::SYNC_SNAPSHOT) {
       // Write should succeed.
       EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
     } else {
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
       EXPECT_FALSE(async_modify_finished_);
     }
 
     SimulateFinishSync(file_system.file_system_context(), kFile,
                        SYNC_STATUS_OK, sync_mode);
 
     EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
 
     // Sync succeeded, but the other change that was made during or
     // after sync is recorded.
@@ skipping 236 matching lines @@
   sync_context_->RegisterURLForWaitingSync(
       kURL1, GetPrepareForSyncClosure(file_system.file_system_context(), kURL1,
                                       LocalFileSyncContext::SYNC_EXCLUSIVE,
                                       &metadata, &changes, nullptr));
 
   // Wait for the completion.
   EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
 
   // The PrepareForSync must have been started; wait until DidPrepareForSync
   // is done.
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   ASSERT_FALSE(has_inflight_prepare_for_sync_);
 
   // Now PrepareForSync should have run and returned OK.
   EXPECT_EQ(SYNC_STATUS_OK, status_);
   EXPECT_EQ(1U, changes.size());
   EXPECT_TRUE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(1, metadata.size);
 
@@ skipping 357 matching lines @@
 
   // Make sure kDir and kFile are created by ApplyRemoteChange.
   EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile));
   EXPECT_EQ(base::File::FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace sync_file_system