Remove calls to deprecated MessageLoop methods on Windows and Linux.

dbus/test_service.cc

 // Copyright (c) 2012 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 "dbus/test_service.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/bus.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 #include "dbus/object_manager.h"
 #include "dbus/object_path.h"
 #include "dbus/property.h"
 
 namespace {
@@ skipping 43 matching lines @@
   return StartWithOptions(thread_options);
 }
 
 bool TestService::WaitUntilServiceIsStarted() {
   const base::TimeDelta timeout(TestTimeouts::action_max_timeout());
   // Wait until the ownership of the service name is obtained.
   return on_name_obtained_.TimedWait(timeout);
 }
 
 void TestService::ShutdownAndBlock() {
-  message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::ShutdownAndBlockInternal,
-                 base::Unretained(this)));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::ShutdownAndBlockInternal,
+                            base::Unretained(this)));
 }
 
 bool TestService::HasDBusThread() {
   return bus_->HasDBusThread();
 }
 
 void TestService::ShutdownAndBlockInternal() {
   if (HasDBusThread())
     bus_->ShutdownOnDBusThreadAndBlock();
   else
     bus_->ShutdownAndBlock();
 }
 
 void TestService::SendTestSignal(const std::string& message) {
-  message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::SendTestSignalInternal,
-                 base::Unretained(this),
-                 message));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::SendTestSignalInternal,
+                            base::Unretained(this), message));
 }
 
 void TestService::SendTestSignalFromRoot(const std::string& message) {
-  message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::SendTestSignalFromRootInternal,
-                 base::Unretained(this),
-                 message));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::SendTestSignalFromRootInternal,
+                            base::Unretained(this), message));
 }
 
 void TestService::SendTestSignalInternal(const std::string& message) {
   Signal signal("org.chromium.TestInterface", "Test");
   MessageWriter writer(&signal);
   writer.AppendString(message);
   exported_object_->SendSignal(&signal);
 }
 
 void TestService::SendTestSignalFromRootInternal(const std::string& message) {
   Signal signal("org.chromium.TestInterface", "Test");
   MessageWriter writer(&signal);
   writer.AppendString(message);
 
   bus_->RequestOwnership(service_name_,
                          request_ownership_options_,
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     base::Bind(&EmptyCallback)));
 
   // Use "/" just like dbus-send does.
   ExportedObject* root_object = bus_->GetExportedObject(ObjectPath("/"));
   root_object->SendSignal(&signal);
 }
 
 void TestService::RequestOwnership(base::Callback<void(bool)> callback) {
-  message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::RequestOwnershipInternal,
-                 base::Unretained(this),
-                 callback));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::RequestOwnershipInternal,
+                            base::Unretained(this), callback));
 }
 
 void TestService::RequestOwnershipInternal(
     base::Callback<void(bool)> callback) {
   bus_->RequestOwnership(service_name_,
                          request_ownership_options_,
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     callback));
 }
@@ skipping 173 matching lines @@
 
 void TestService::SlowEcho(MethodCall* method_call,
                            ExportedObject::ResponseSender response_sender) {
   base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   Echo(method_call, response_sender);
 }
 
 void TestService::AsyncEcho(MethodCall* method_call,
                             ExportedObject::ResponseSender response_sender) {
   // Schedule a call to Echo() to send an asynchronous response after we return.
-  message_loop()->PostDelayedTask(FROM_HERE,
-                                  base::Bind(&TestService::Echo,
-                                             base::Unretained(this),
-                                             method_call,
-                                             response_sender),
-                                  TestTimeouts::tiny_timeout());
+  message_loop()->task_runner()->PostDelayedTask(
+      FROM_HERE, base::Bind(&TestService::Echo, base::Unretained(this),
+                            method_call, response_sender),
+      TestTimeouts::tiny_timeout());
 }
 
 void TestService::BrokenMethod(MethodCall* method_call,
                                ExportedObject::ResponseSender response_sender) {
   response_sender.Run(std::unique_ptr<Response>());
 }
 
 
 void TestService::GetAllProperties(
     MethodCall* method_call,
@@ skipping 292 matching lines @@
   dict_entry_writer.OpenVariant("ay", &variant_writer);
   const uint8_t bytes[] = {0x54, 0x65, 0x73, 0x74};
   variant_writer.AppendArrayOfBytes(bytes, sizeof(bytes));
   dict_entry_writer.CloseContainer(&variant_writer);
   array_writer.CloseContainer(&dict_entry_writer);
 
   writer->CloseContainer(&array_writer);
 }
 
 void TestService::AddObject(const ObjectPath& object_path) {
-  message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::AddObjectInternal,
-                 base::Unretained(this),
-                 object_path));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::AddObjectInternal,
+                            base::Unretained(this), object_path));
 }
 
 void TestService::AddObjectInternal(const ObjectPath& object_path) {
   Signal signal(kObjectManagerInterface, kObjectManagerInterfacesAdded);
   MessageWriter writer(&signal);
   writer.AppendObjectPath(object_path);
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
 
   writer.OpenArray("{sa{sv}}", &array_writer);
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString("org.chromium.TestInterface");
   AddPropertiesToWriter(&dict_entry_writer);
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
   exported_object_manager_->SendSignal(&signal);
 }
 
 void TestService::RemoveObject(const ObjectPath& object_path) {
-  message_loop()->PostTask(FROM_HERE,
-                           base::Bind(&TestService::RemoveObjectInternal,
-                                      base::Unretained(this),
-                                      object_path));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::RemoveObjectInternal,
+                            base::Unretained(this), object_path));
 }
 
 void TestService::RemoveObjectInternal(const ObjectPath& object_path) {
   Signal signal(kObjectManagerInterface, kObjectManagerInterfacesRemoved);
   MessageWriter writer(&signal);
 
   writer.AppendObjectPath(object_path);
 
   std::vector<std::string> interfaces;
   interfaces.push_back("org.chromium.TestInterface");
   writer.AppendArrayOfStrings(interfaces);
 
   exported_object_manager_->SendSignal(&signal);
 }
 
 void TestService::SendPropertyChangedSignal(const std::string& name) {
-  message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TestService::SendPropertyChangedSignalInternal,
-                 base::Unretained(this),
-                 name));
+  message_loop()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TestService::SendPropertyChangedSignalInternal,
+                            base::Unretained(this), name));
 }
 
 void TestService::SendPropertyChangedSignalInternal(const std::string& name) {
   Signal signal(kPropertiesInterface, kPropertiesChanged);
   MessageWriter writer(&signal);
   writer.AppendString("org.chromium.TestInterface");
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
 
   writer.OpenArray("{sv}", &array_writer);
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString("Name");
   dict_entry_writer.AppendVariantOfString(name);
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
   MessageWriter invalidated_array_writer(NULL);
 
   writer.OpenArray("s", &invalidated_array_writer);
   writer.CloseContainer(&invalidated_array_writer);
 
   exported_object_->SendSignal(&signal);
 }
 
 void TestService::SendPropertyInvalidatedSignal() {
-  message_loop()->PostTask(
+  message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TestService::SendPropertyInvalidatedSignalInternal,
                             base::Unretained(this)));
 }
 
 void TestService::SendPropertyInvalidatedSignalInternal() {
   Signal signal(kPropertiesInterface, kPropertiesChanged);
   MessageWriter writer(&signal);
   writer.AppendString("org.chromium.TestInterface");
 
   MessageWriter array_writer(NULL);
   MessageWriter dict_entry_writer(NULL);
 
   writer.OpenArray("{sv}", &array_writer);
   writer.CloseContainer(&array_writer);
 
   MessageWriter invalidated_array_writer(NULL);
 
   writer.OpenArray("s", &invalidated_array_writer);
   invalidated_array_writer.AppendString("Name");
   writer.CloseContainer(&invalidated_array_writer);
 
   exported_object_->SendSignal(&signal);
 }
 
 }  // namespace dbus