Remove use of deprecated MessageLoop methods in chrome/.

chrome/browser/extensions/api/image_writer_private/test_utils.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/extensions/api/image_writer_private/test_utils.h"
 
 #include <string.h>
 #include <utility>
 
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_image_burner_client.h"
 #endif
 
 namespace extensions {
 namespace image_writer {
 
 #if defined(OS_CHROMEOS)
 namespace {
 
 class ImageWriterFakeImageBurnerClient
     : public chromeos::FakeImageBurnerClient {
  public:
   ImageWriterFakeImageBurnerClient() {}
   ~ImageWriterFakeImageBurnerClient() override {}
 
   void SetEventHandlers(
       const BurnFinishedHandler& burn_finished_handler,
       const BurnProgressUpdateHandler& burn_progress_update_handler) override {
     burn_finished_handler_ = burn_finished_handler;
     burn_progress_update_handler_ = burn_progress_update_handler;
   }
 
   void BurnImage(const std::string& from_path,
                  const std::string& to_path,
                  const ErrorCallback& error_callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(burn_progress_update_handler_, to_path, 0, 100));
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(burn_progress_update_handler_, to_path, 50, 100));
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(burn_progress_update_handler_, to_path, 0, 100));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(burn_progress_update_handler_, to_path, 50, 100));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
         base::Bind(burn_progress_update_handler_, to_path, 100, 100));
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(burn_finished_handler_, to_path, true, ""));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(burn_finished_handler_, to_path, true, ""));
   }
 
  private:
   BurnFinishedHandler burn_finished_handler_;
   BurnProgressUpdateHandler burn_progress_update_handler_;
 };
 
 } // namespace
 #endif
 
 MockOperationManager::MockOperationManager() : OperationManager(NULL) {}
 MockOperationManager::MockOperationManager(content::BrowserContext* context)
     : OperationManager(context) {}
 MockOperationManager::~MockOperationManager() {}
 
 #if defined(OS_CHROMEOS)
 FakeDiskMountManager::FakeDiskMountManager() {}
 FakeDiskMountManager::~FakeDiskMountManager() {}
 
 void FakeDiskMountManager::UnmountDeviceRecursively(
     const std::string& device_path,
     const UnmountDeviceRecursivelyCallbackType& callback) {
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                base::Bind(callback, true));
 }
 #endif
 
 FakeImageWriterClient::FakeImageWriterClient() {}
 FakeImageWriterClient::~FakeImageWriterClient() {}
 
 void FakeImageWriterClient::Write(const ProgressCallback& progress_callback,
                                   const SuccessCallback& success_callback,
                                   const ErrorCallback& error_callback,
                                   const base::FilePath& source,
@@ skipping 188 matching lines @@
   test_utils_.SetUp();
 }
 
 void ImageWriterUnitTestBase::TearDown() {
   testing::Test::TearDown();
   test_utils_.TearDown();
 }
 
 }  // namespace image_writer
 }  // namespace extensions