dbus: Replace PostTaskTo*Thread methods with Get*TaskRunner

dbus/object_proxy.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/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 122 matching lines @@
   if (!method_call->SetDestination(service_name_) ||
       !method_call->SetPath(object_path_)) {
     // In case of a failure, run the error callback with NULL.
     DBusMessage* response_message = NULL;
     base::Closure task = base::Bind(&ObjectProxy::RunResponseCallback,
                                     this,
                                     callback,
                                     error_callback,
                                     start_time,
                                     response_message);
-    bus_->PostTaskToOriginThread(FROM_HERE, task);
+    bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, task);
     return;
   }
 
   // Increment the reference count so we can safely reference the
   // underlying request message until the method call is complete. This
   // will be unref'ed in StartAsyncMethodCall().
   DBusMessage* request_message = method_call->raw_message();
   dbus_message_ref(request_message);
 
   base::Closure task = base::Bind(&ObjectProxy::StartAsyncMethodCall,
                                   this,
                                   timeout_ms,
                                   request_message,
                                   callback,
                                   error_callback,
                                   start_time);
   statistics::AddSentMethodCall(service_name_,
                                 method_call->GetInterface(),
                                 method_call->GetMember());
 
   // Wait for the response in the D-Bus thread.
-  bus_->PostTaskToDBusThread(FROM_HERE, task);
+  bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, task);
 }
 
 void ObjectProxy::ConnectToSignal(const std::string& interface_name,
                                   const std::string& signal_name,
                                   SignalCallback signal_callback,
                                   OnConnectedCallback on_connected_callback) {
   bus_->AssertOnOriginThread();
 
-  bus_->PostTaskToDBusThread(FROM_HERE,
-                             base::Bind(&ObjectProxy::ConnectToSignalInternal,
-                                        this,
-                                        interface_name,
-                                        signal_name,
-                                        signal_callback,
-                                        on_connected_callback));
+  bus_->GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ObjectProxy::ConnectToSignalInternal,
+                 this,
+                 interface_name,
+                 signal_name,
+                 signal_callback,
+                 on_connected_callback));
 }
 
 void ObjectProxy::Detach() {
   bus_->AssertOnDBusThread();
 
   if (filter_added_) {
     if (!bus_->RemoveFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
       LOG(ERROR) << "Failed to remove filter function";
     }
   }
@@ skipping 38 matching lines @@
 
   if (!bus_->Connect() || !bus_->SetUpAsyncOperations()) {
     // In case of a failure, run the error callback with NULL.
     DBusMessage* response_message = NULL;
     base::Closure task = base::Bind(&ObjectProxy::RunResponseCallback,
                                     this,
                                     response_callback,
                                     error_callback,
                                     start_time,
                                     response_message);
-    bus_->PostTaskToOriginThread(FROM_HERE, task);
+    bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, task);
 
     dbus_message_unref(request_message);
     return;
   }
 
   DBusPendingCall* pending_call = NULL;
 
   bus_->SendWithReply(request_message, &pending_call, timeout_ms);
 
   // Prepare the data we'll be passing to OnPendingCallIsCompleteThunk().
@@ skipping 21 matching lines @@
                                           base::TimeTicks start_time) {
   bus_->AssertOnDBusThread();
 
   DBusMessage* response_message = dbus_pending_call_steal_reply(pending_call);
   base::Closure task = base::Bind(&ObjectProxy::RunResponseCallback,
                                   this,
                                   response_callback,
                                   error_callback,
                                   start_time,
                                   response_message);
-  bus_->PostTaskToOriginThread(FROM_HERE, task);
+  bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, task);
 }
 
 void ObjectProxy::RunResponseCallback(ResponseCallback response_callback,
                                       ErrorCallback error_callback,
                                       base::TimeTicks start_time,
                                       DBusMessage* response_message) {
   bus_->AssertOnOriginThread();
 
   bool method_call_successful = false;
   if (!response_message) {
     // The response is not received.
     error_callback.Run(NULL);
   } else if (dbus_message_get_type(response_message) ==
              DBUS_MESSAGE_TYPE_ERROR) {
     // This will take |response_message| and release (unref) it.
     scoped_ptr<ErrorResponse> error_response(
         ErrorResponse::FromRawMessage(response_message));
     error_callback.Run(error_response.get());
     // Delete the message  on the D-Bus thread. See below for why.
-    bus_->PostTaskToDBusThread(
+    bus_->GetDBusTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&base::DeletePointer<ErrorResponse>,
                    error_response.release()));
   } else {
     // This will take |response_message| and release (unref) it.
     scoped_ptr<Response> response(Response::FromRawMessage(response_message));
     // The response is successfully received.
     response_callback.Run(response.get());
     // The message should be deleted on the D-Bus thread for a complicated
     // reason:
     //
     // libdbus keeps track of the number of bytes in the incoming message
     // queue to ensure that the data size in the queue is manageable. The
     // bookkeeping is partly done via dbus_message_unref(), and immediately
     // asks the client code (Chrome) to stop monitoring the underlying
     // socket, if the number of bytes exceeds a certian number, which is set
     // to 63MB, per dbus-transport.cc:
     //
     //   /* Try to default to something that won't totally hose the system,
     //    * but doesn't impose too much of a limitation.
     //    */
     //   transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63;
     //
     // The monitoring of the socket is done on the D-Bus thread (see Watch
     // class in bus.cc), hence we should stop the monitoring from D-Bus
     // thread, not from the current thread here, which is likely UI thread.
-    bus_->PostTaskToDBusThread(
+    bus_->GetDBusTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&base::DeletePointer<Response>, response.release()));
 
     method_call_successful = true;
     // Record time spent for the method call. Don't include failures.
     UMA_HISTOGRAM_TIMES("DBus.AsyncMethodCallTime",
                         base::TimeTicks::Now() - start_time);
   }
   // Record if the method call is successful, or not. 1 if successful.
   UMA_HISTOGRAM_ENUMERATION("DBus.AsyncMethodCallSuccess",
@@ skipping 58 matching lines @@
     }
 
     // Try getting the current name owner. It's not guaranteed that we can get
     // the name owner at this moment, as the service may not yet be started. If
     // that's the case, we'll get the name owner via NameOwnerChanged signal,
     // as soon as the service is started.
     UpdateNameOwnerAndBlock();
   }
 
   // Run on_connected_callback in the origin thread.
-  bus_->PostTaskToOriginThread(
+  bus_->GetOriginTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ObjectProxy::OnConnected,
                  this,
                  on_connected_callback,
                  interface_name,
                  signal_name,
                  success));
 }
 
 void ObjectProxy::OnConnected(OnConnectedCallback on_connected_callback,
@@ skipping 59 matching lines @@
     UMA_HISTOGRAM_COUNTS("DBus.RejectedSignalCount", 1);
     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.
     // Transfer the ownership of |signal| to RunMethod().
     // |released_signal| will be deleted in RunMethod().
     Signal* released_signal = signal.release();
-    bus_->PostTaskToOriginThread(FROM_HERE,
-                                 base::Bind(&ObjectProxy::RunMethod,
-                                            this,
-                                            start_time,
-                                            iter->second,
-                                            released_signal));
+    bus_->GetOriginTaskRunner()->PostTask(FROM_HERE,
+                                          base::Bind(&ObjectProxy::RunMethod,
+                                                     this,
+                                                     start_time,
+                                                     iter->second,
+                                                     released_signal));
   } else {
     const base::TimeTicks start_time = base::TimeTicks::Now();
     // If the D-Bus thread is not used, just call the callback on the
     // current thread. Transfer the ownership of |signal| to RunMethod().
     Signal* released_signal = signal.release();
     RunMethod(start_time, iter->second, released_signal);
   }
 
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 void ObjectProxy::RunMethod(base::TimeTicks start_time,
                             std::vector<SignalCallback> signal_callbacks,
                             Signal* signal) {
   bus_->AssertOnOriginThread();
 
   for (std::vector<SignalCallback>::iterator iter = signal_callbacks.begin();
        iter != signal_callbacks.end(); ++iter)
     iter->Run(signal);
 
   // Delete the message on the D-Bus thread. See comments in
   // RunResponseCallback().
-  bus_->PostTaskToDBusThread(
+  bus_->GetDBusTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&base::DeletePointer<Signal>, signal));
 
   // Record time spent for handling the signal.
   UMA_HISTOGRAM_TIMES("DBus.SignalHandleTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 DBusHandlerResult ObjectProxy::HandleMessageThunk(
     DBusConnection* connection,
@@ skipping 108 matching lines @@
     if (reader.PopString(&name) &&
         reader.PopString(&old_owner) &&
         reader.PopString(&new_owner) &&
         name == service_name_) {
       service_name_owner_ = new_owner;
       if (!name_owner_changed_callback_.is_null()) {
         const base::TimeTicks start_time = base::TimeTicks::Now();
         Signal* released_signal = signal.release();
         std::vector<SignalCallback> callbacks;
         callbacks.push_back(name_owner_changed_callback_);
-        bus_->PostTaskToOriginThread(FROM_HERE,
-                                     base::Bind(&ObjectProxy::RunMethod,
-                                                this,
-                                                start_time,
-                                                callbacks,
-                                                released_signal));
+        bus_->GetOriginTaskRunner()->PostTask(
+            FROM_HERE,
+            base::Bind(&ObjectProxy::RunMethod,
+                       this,
+                       start_time,
+                       callbacks,
+                       released_signal));
       }
     }
   }
 
   // Always return unhandled to let other object proxies handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus