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 <memory>
 
 #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 "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.h"
 
@@ skipping 86 matching lines @@
  public:
   BatteryStatusNotificationThread(
       const BatteryStatusService::BatteryUpdateCallback& callback)
       : base::Thread(kBatteryNotifierThreadName),
         callback_(callback),
         battery_proxy_(NULL) {}
 
   ~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 78 matching lines @@
   }
 
   void ShutdownDBusConnection() {
     DCHECK(OnWatcherThread());
 
     if (!system_bus_.get())
       return;
 
     // 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;
     battery_proxy_ = NULL;
   }
 
   void OnSignalConnected(const std::string& interface_name,
                          const std::string& signal_name,
                          bool success) {
     DCHECK(OnWatcherThread());
 
     if (interface_name != kUPowerDeviceName ||
@@ skipping 42 matching lines @@
       : callback_(callback) {}
 
   ~BatteryStatusManagerLinux() override {}
 
  private:
   // BatteryStatusManager:
   bool StartListeningBatteryChange() override {
     if (!StartNotifierThreadIfNecessary())
       return false;
 
-    notifier_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&BatteryStatusNotificationThread::StartListening,
-                   base::Unretained(notifier_thread_.get())));
+    notifier_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&BatteryStatusNotificationThread::StartListening,
+                              base::Unretained(notifier_thread_.get())));
     return true;
   }
 
   void StopListeningBatteryChange() override {
     if (!notifier_thread_)
       return;
 
-    notifier_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&BatteryStatusNotificationThread::StopListening,
-                   base::Unretained(notifier_thread_.get())));
+    notifier_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&BatteryStatusNotificationThread::StopListening,
+                              base::Unretained(notifier_thread_.get())));
   }
 
   // Starts the notifier thread if not already started and returns true on
   // success.
   bool StartNotifierThreadIfNecessary() {
     if (notifier_thread_)
       return true;
 
     base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
     notifier_thread_.reset(new BatteryStatusNotificationThread(callback_));
@@ skipping 60 matching lines @@
 }
 
 // static
 std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
   return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerLinux(callback));
 }
 
 }  // namespace device