dbus: Replace PostTaskTo*Thread methods with Get*TaskRunner

dbus/exported_object.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/exported_object.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 66 matching lines @@
                                   MethodCallCallback method_call_callback,
                                   OnExportedCallback on_exported_calback) {
   bus_->AssertOnOriginThread();
 
   base::Closure task = base::Bind(&ExportedObject::ExportMethodInternal,
                                   this,
                                   interface_name,
                                   method_name,
                                   method_call_callback,
                                   on_exported_calback);
-  bus_->PostTaskToDBusThread(FROM_HERE, task);
+  bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, task);
 }
 
 void ExportedObject::SendSignal(Signal* signal) {
   // For signals, the object path should be set to the path to the sender
   // object, which is this exported object here.
   CHECK(signal->SetPath(object_path_));
 
   // Increment the reference count so we can safely reference the
   // underlying signal message until the signal sending is complete. This
   // will be unref'ed in SendSignalInternal().
   DBusMessage* signal_message = signal->raw_message();
   dbus_message_ref(signal_message);
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
-  bus_->PostTaskToDBusThread(FROM_HERE,
-                             base::Bind(&ExportedObject::SendSignalInternal,
-                                        this,
-                                        start_time,
-                                        signal_message));
+  bus_->GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ExportedObject::SendSignalInternal,
+                 this,
+                 start_time,
+                 signal_message));
 }
 
 void ExportedObject::Unregister() {
   bus_->AssertOnDBusThread();
 
   if (!object_is_registered_)
     return;
 
   bus_->UnregisterObjectPath(object_path_);
   object_is_registered_ = false;
 }
 
 void ExportedObject::ExportMethodInternal(
     const std::string& interface_name,
     const std::string& method_name,
     MethodCallCallback method_call_callback,
     OnExportedCallback on_exported_calback) {
   bus_->AssertOnDBusThread();
 
   const bool success = ExportMethodAndBlock(interface_name,
                                             method_name,
                                             method_call_callback);
-  bus_->PostTaskToOriginThread(FROM_HERE,
-                               base::Bind(&ExportedObject::OnExported,
-                                          this,
-                                          on_exported_calback,
-                                          interface_name,
-                                          method_name,
-                                          success));
+  bus_->GetOriginTaskRunner()->PostTask(FROM_HERE,
+                                        base::Bind(&ExportedObject::OnExported,
+                                                   this,
+                                                   on_exported_calback,
+                                                   interface_name,
+                                                   method_name,
+                                                   success));
 }
 
 void ExportedObject::OnExported(OnExportedCallback on_exported_callback,
                                 const std::string& interface_name,
                                 const std::string& method_name,
                                 bool success) {
   bus_->AssertOnOriginThread();
 
   on_exported_callback.Run(interface_name, method_name, success);
 }
@@ skipping 61 matching lines @@
   MethodTable::const_iterator iter = method_table_.find(absolute_method_name);
   if (iter == method_table_.end()) {
     // Don't know about the method.
     LOG(WARNING) << "Unknown method: " << method_call->ToString();
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
   if (bus_->HasDBusThread()) {
     // Post a task to run the method in the origin thread.
-    bus_->PostTaskToOriginThread(FROM_HERE,
-                                 base::Bind(&ExportedObject::RunMethod,
-                                            this,
-                                            iter->second,
-                                            base::Passed(&method_call),
-                                            start_time));
+    bus_->GetOriginTaskRunner()->PostTask(FROM_HERE,
+                                          base::Bind(&ExportedObject::RunMethod,
+                                                     this,
+                                                     iter->second,
+                                                     base::Passed(&method_call),
+                                                     start_time));
   } else {
     // If the D-Bus thread is not used, just call the method directly.
     MethodCall* method = method_call.get();
     iter->second.Run(method,
                      base::Bind(&ExportedObject::SendResponse,
                                 this,
                                 start_time,
                                 base::Passed(&method_call)));
   }
 
@@ skipping 12 matching lines @@
                                       this,
                                       start_time,
                                       base::Passed(&method_call)));
 }
 
 void ExportedObject::SendResponse(base::TimeTicks start_time,
                                   scoped_ptr<MethodCall> method_call,
                                   scoped_ptr<Response> response) {
   DCHECK(method_call);
   if (bus_->HasDBusThread()) {
-    bus_->PostTaskToDBusThread(FROM_HERE,
-                               base::Bind(&ExportedObject::OnMethodCompleted,
-                                          this,
-                                          base::Passed(&method_call),
-                                          base::Passed(&response),
-                                          start_time));
+    bus_->GetDBusTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ExportedObject::OnMethodCompleted,
+                   this,
+                   base::Passed(&method_call),
+                   base::Passed(&response),
+                   start_time));
   } else {
     OnMethodCompleted(method_call.Pass(), response.Pass(), start_time);
   }
 }
 
 void ExportedObject::OnMethodCompleted(scoped_ptr<MethodCall> method_call,
                                        scoped_ptr<Response> response,
                                        base::TimeTicks start_time) {
   bus_->AssertOnDBusThread();
 
@@ skipping 37 matching lines @@
   return self->HandleMessage(connection, raw_message);
 }
 
 void ExportedObject::OnUnregisteredThunk(DBusConnection *connection,
                                          void* user_data) {
   ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data);
   return self->OnUnregistered(connection);
 }
 
 }  // namespace dbus