Remove calls to deprecated MessageLoop methods on Windows and Linux.

device/battery/battery_status_manager_linux.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 "device/battery/battery_status_manager_linux.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/property.h"
 #include "dbus/values_util.h"
 #include "device/battery/battery_status_manager_linux-inl.h"
@@ skipping 280 matching lines @@
 class BatteryStatusManagerLinux::BatteryStatusNotificationThread
     : public base::Thread {
  public:
   BatteryStatusNotificationThread(
       const BatteryStatusService::BatteryUpdateCallback& callback)
       : base::Thread(kBatteryNotifierThreadName), callback_(callback) {}
 
   ~BatteryStatusNotificationThread() override {
     // Make sure to shutdown the dbus connection if it is still open in the very
     // end. It needs to happen on the BatteryStatusNotificationThread.
-    message_loop()->PostTask(
+    message_loop()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&BatteryStatusNotificationThread::ShutdownDBusConnection,
                    base::Unretained(this)));
 
     // Drain the message queue of the BatteryStatusNotificationThread and stop.
     Stop();
   }
 
   void StartListening() {
     DCHECK(OnWatcherThread());
@@ skipping 128 matching lines @@
     DCHECK(OnWatcherThread());
 
     if (!system_bus_.get())
       return;
 
     battery_.reset();  // before the system_bus_ is shut down.
     upower_.reset();
 
     // Shutdown DBus connection later because there may be pending tasks on
     // this thread.
-    message_loop()->PostTask(FROM_HERE,
-                             base::Bind(&dbus::Bus::ShutdownAndBlock,
-                                        system_bus_));
+    message_loop()->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&dbus::Bus::ShutdownAndBlock, system_bus_));
     system_bus_ = NULL;
   }
 
   void OnSignalConnected(const std::string& interface_name,
                          const std::string& signal_name,
                          bool success) {}
 
   std::unique_ptr<BatteryObject> CreateBattery(
       const dbus::ObjectPath& device_path) {
     std::unique_ptr<BatteryObject> battery(new BatteryObject(
@@ skipping 82 matching lines @@
 BatteryStatusManagerLinux::BatteryStatusManagerLinux(
     const BatteryStatusService::BatteryUpdateCallback& callback)
     : callback_(callback) {}
 
 BatteryStatusManagerLinux::~BatteryStatusManagerLinux() {}
 
 bool BatteryStatusManagerLinux::StartListeningBatteryChange() {
   if (!StartNotifierThreadIfNecessary())
     return false;
 
-  notifier_thread_->message_loop()->PostTask(
+  notifier_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&BatteryStatusNotificationThread::StartListening,
                             base::Unretained(notifier_thread_.get())));
   return true;
 }
 
 void BatteryStatusManagerLinux::StopListeningBatteryChange() {
   if (!notifier_thread_)
     return;
 
-  notifier_thread_->message_loop()->PostTask(
+  notifier_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&BatteryStatusNotificationThread::StopListening,
                             base::Unretained(notifier_thread_.get())));
 }
 
 bool BatteryStatusManagerLinux::StartNotifierThreadIfNecessary() {
   if (notifier_thread_)
     return true;
 
   base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
   notifier_thread_.reset(new BatteryStatusNotificationThread(callback_));
@@ skipping 25 matching lines @@
 }
 
 // static
 std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
   return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerLinux(callback));
 }
 
 }  // namespace device