dbus: Replace PostTaskTo*Thread methods with Get*TaskRunner

dbus/bus.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/message_loop/message_loop_proxy.h"
@@ skipping 106 matching lines @@
     AddRef();  // Balanced on Complete().
   }
 
   // Returns true if the timeout is ready to be monitored.
   bool IsReadyToBeMonitored() {
     return dbus_timeout_get_enabled(raw_timeout_);
   }
 
   // Starts monitoring the timeout.
   void StartMonitoring(Bus* bus) {
-    bus->PostDelayedTaskToDBusThread(FROM_HERE,
-                                     base::Bind(&Timeout::HandleTimeout,
-                                                this),
-                                     GetInterval());
+    bus->GetDBusTaskRunner()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&Timeout::HandleTimeout, this),
+        GetInterval());
     monitoring_is_active_ = true;
   }
 
   // Stops monitoring the timeout.
   void StopMonitoring() {
     // We cannot take back the delayed task we posted in
     // StartMonitoring(), so we just mark the monitoring is inactive now.
     monitoring_is_active_ = false;
   }
 
@@ skipping 118 matching lines @@
                                        int options,
                                        const base::Closure& callback) {
   AssertOnOriginThread();
 
   // Check if we have the requested object proxy.
   const ObjectProxyTable::key_type key(service_name + object_path.value(),
                                        options);
   ObjectProxyTable::iterator iter = object_proxy_table_.find(key);
   if (iter != object_proxy_table_.end()) {
     // Object is present. Remove it now and Detach in the DBus thread.
-    PostTaskToDBusThread(FROM_HERE, base::Bind(
-        &Bus::RemoveObjectProxyInternal,
-        this, iter->second, callback));
+    GetDBusTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Bus::RemoveObjectProxyInternal,
+                   this, iter->second, callback));
 
     object_proxy_table_.erase(iter);
     return true;
   }
   return false;
 }
 
 void Bus::RemoveObjectProxyInternal(scoped_refptr<ObjectProxy> object_proxy,
                                     const base::Closure& callback) {
   AssertOnDBusThread();
 
   object_proxy.get()->Detach();
 
-  PostTaskToOriginThread(FROM_HERE, callback);
+  GetOriginTaskRunner()->PostTask(FROM_HERE, callback);
 }
 
 ExportedObject* Bus::GetExportedObject(const ObjectPath& object_path) {
   AssertOnOriginThread();
 
   // Check if we already have the requested exported object.
   ExportedObjectTable::iterator iter = exported_object_table_.find(object_path);
   if (iter != exported_object_table_.end()) {
     return iter->second.get();
   }
@@ skipping 15 matching lines @@
     return;
 
   scoped_refptr<ExportedObject> exported_object = iter->second;
   exported_object_table_.erase(iter);
 
   // Post the task to perform the final unregistration to the D-Bus thread.
   // Since the registration also happens on the D-Bus thread in
   // TryRegisterObjectPath(), and the task runner we post to is a
   // SequencedTaskRunner, there is a guarantee that this will happen before any
   // future registration call.
-  PostTaskToDBusThread(FROM_HERE,
-                       base::Bind(&Bus::UnregisterExportedObjectInternal,
-                                  this, exported_object));
+  GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Bus::UnregisterExportedObjectInternal,
+                 this, exported_object));
 }
 
 void Bus::UnregisterExportedObjectInternal(
     scoped_refptr<ExportedObject> exported_object) {
   AssertOnDBusThread();
 
   exported_object->Unregister();
 }
 
 ObjectManager* Bus::GetObjectManager(const std::string& service_name,
@@ skipping 144 matching lines @@
   }
 
   connection_ = NULL;
   shutdown_completed_ = true;
 }
 
 void Bus::ShutdownOnDBusThreadAndBlock() {
   AssertOnOriginThread();
   DCHECK(dbus_task_runner_.get());
 
-  PostTaskToDBusThread(FROM_HERE, base::Bind(
-      &Bus::ShutdownOnDBusThreadAndBlockInternal,
-      this));
+  GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Bus::ShutdownOnDBusThreadAndBlockInternal, this));
 
   // http://crbug.com/125222
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
 
   // Wait until the shutdown is complete on the D-Bus thread.
   // The shutdown should not hang, but set timeout just in case.
   const int kTimeoutSecs = 3;
   const base::TimeDelta timeout(base::TimeDelta::FromSeconds(kTimeoutSecs));
   const bool signaled = on_shutdown_.TimedWait(timeout);
   LOG_IF(ERROR, !signaled) << "Failed to shutdown the bus";
 }
 
 void Bus::RequestOwnership(const std::string& service_name,
                            ServiceOwnershipOptions options,
                            OnOwnershipCallback on_ownership_callback) {
   AssertOnOriginThread();
 
-  PostTaskToDBusThread(FROM_HERE, base::Bind(
-      &Bus::RequestOwnershipInternal,
-      this, service_name, options, on_ownership_callback));
+  GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Bus::RequestOwnershipInternal,
+                 this, service_name, options, on_ownership_callback));
 }
 
 void Bus::RequestOwnershipInternal(const std::string& service_name,
                                    ServiceOwnershipOptions options,
                                    OnOwnershipCallback on_ownership_callback) {
   AssertOnDBusThread();
 
   bool success = Connect();
   if (success)
     success = RequestOwnershipAndBlock(service_name, options);
 
-  PostTaskToOriginThread(FROM_HERE,
-                         base::Bind(on_ownership_callback,
-                                    service_name,
-                                    success));
+  GetOriginTaskRunner()->PostTask(FROM_HERE,
+                                  base::Bind(on_ownership_callback,
+                                             service_name,
+                                             success));
 }
 
 bool Bus::RequestOwnershipAndBlock(const std::string& service_name,
                                    ServiceOwnershipOptions options) {
   DCHECK(connection_);
   // dbus_bus_request_name() is a blocking call.
   AssertOnDBusThread();
 
   // Check if we already own the service name.
   if (owned_service_names_.find(service_name) != owned_service_names_.end()) {
@@ skipping 247 matching lines @@
   // if the connection is lost. Otherwise we will miss "Disconnected" signal.
   // (crbug.com/174431)
   if (dbus_connection_get_dispatch_status(connection_) ==
       DBUS_DISPATCH_DATA_REMAINS) {
     while (dbus_connection_dispatch(connection_) ==
            DBUS_DISPATCH_DATA_REMAINS) {
     }
   }
 }
 
-void Bus::PostTaskToDBusThreadAndReply(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task,
-    const base::Closure& reply) {
-  AssertOnOriginThread();
-
-  if (dbus_task_runner_.get()) {
-    if (!dbus_task_runner_->PostTaskAndReply(from_here, task, reply)) {
-      LOG(WARNING) << "Failed to post a task to the D-Bus thread message loop";
-    }
-  } else {
-    DCHECK(origin_task_runner_.get());
-    if (!origin_task_runner_->PostTaskAndReply(from_here, task, reply)) {
-      LOG(WARNING) << "Failed to post a task to the origin message loop";
-    }
-  }
+base::TaskRunner* Bus::GetDBusTaskRunner() {
+  if (dbus_task_runner_.get())
+    return dbus_task_runner_.get();
+  else
+    return GetOriginTaskRunner();
 }
 
-void Bus::PostTaskToOriginThread(const tracked_objects::Location& from_here,
-                                 const base::Closure& task) {
+base::TaskRunner* Bus::GetOriginTaskRunner() {
   DCHECK(origin_task_runner_.get());
-  if (!origin_task_runner_->PostTask(from_here, task)) {
-    LOG(WARNING) << "Failed to post a task to the origin message loop";
-  }
-}
-
-void Bus::PostTaskToDBusThread(const tracked_objects::Location& from_here,
-                               const base::Closure& task) {
-  if (dbus_task_runner_.get()) {
-    if (!dbus_task_runner_->PostTask(from_here, task)) {
-      LOG(WARNING) << "Failed to post a task to the D-Bus thread message loop";
-    }
-  } else {
-    DCHECK(origin_task_runner_.get());
-    if (!origin_task_runner_->PostTask(from_here, task)) {
-      LOG(WARNING) << "Failed to post a task to the origin message loop";
-    }
-  }
-}
-
-void Bus::PostDelayedTaskToDBusThread(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task,
-    base::TimeDelta delay) {
-  if (dbus_task_runner_.get()) {
-    if (!dbus_task_runner_->PostDelayedTask(
-            from_here, task, delay)) {
-      LOG(WARNING) << "Failed to post a task to the D-Bus thread message loop";
-    }
-  } else {
-    DCHECK(origin_task_runner_.get());
-    if (!origin_task_runner_->PostDelayedTask(from_here, task, delay)) {
-      LOG(WARNING) << "Failed to post a task to the origin message loop";
-    }
-  }
+  return origin_task_runner_.get();
 }
 
 bool Bus::HasDBusThread() {
   return dbus_task_runner_.get() != NULL;
 }
 
 void Bus::AssertOnOriginThread() {
   DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
 }
 
@@ skipping 43 matching lines @@
   std::string service_owner;
   if (!reader.PopString(&service_owner))
     service_owner.clear();
   return service_owner;
 }
 
 void Bus::GetServiceOwner(const std::string& service_name,
                           const GetServiceOwnerCallback& callback) {
   AssertOnOriginThread();
 
-  PostTaskToDBusThread(
+  GetDBusTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&Bus::GetServiceOwnerInternal, this, service_name, callback));
 }
 
 void Bus::GetServiceOwnerInternal(const std::string& service_name,
                                   const GetServiceOwnerCallback& callback) {
   AssertOnDBusThread();
 
   std::string service_owner;
   if (Connect())
     service_owner = GetServiceOwnerAndBlock(service_name, SUPPRESS_ERRORS);
-  PostTaskToOriginThread(FROM_HERE, base::Bind(callback, service_owner));
+  GetOriginTaskRunner()->PostTask(FROM_HERE,
+                                  base::Bind(callback, service_owner));
 }
 
 void Bus::ListenForServiceOwnerChange(
     const std::string& service_name,
     const GetServiceOwnerCallback& callback) {
   AssertOnOriginThread();
   DCHECK(!service_name.empty());
   DCHECK(!callback.is_null());
 
-  PostTaskToDBusThread(FROM_HERE,
-                       base::Bind(&Bus::ListenForServiceOwnerChangeInternal,
-                                  this, service_name, callback));
+  GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Bus::ListenForServiceOwnerChangeInternal,
+                 this, service_name, callback));
 }
 
 void Bus::ListenForServiceOwnerChangeInternal(
     const std::string& service_name,
     const GetServiceOwnerCallback& callback) {
   AssertOnDBusThread();
   DCHECK(!service_name.empty());
   DCHECK(!callback.is_null());
 
   if (!Connect() || !SetUpAsyncOperations())
@@ skipping 33 matching lines @@
   callbacks.push_back(callback);
 }
 
 void Bus::UnlistenForServiceOwnerChange(
     const std::string& service_name,
     const GetServiceOwnerCallback& callback) {
   AssertOnOriginThread();
   DCHECK(!service_name.empty());
   DCHECK(!callback.is_null());
 
-  PostTaskToDBusThread(FROM_HERE,
-                       base::Bind(&Bus::UnlistenForServiceOwnerChangeInternal,
-                                  this, service_name, callback));
+  GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Bus::UnlistenForServiceOwnerChangeInternal,
+                 this, service_name, callback));
 }
 
 void Bus::UnlistenForServiceOwnerChangeInternal(
     const std::string& service_name,
     const GetServiceOwnerCallback& callback) {
   AssertOnDBusThread();
   DCHECK(!service_name.empty());
   DCHECK(!callback.is_null());
 
   ServiceOwnerChangedListenerMap::iterator it =
@@ skipping 94 matching lines @@
 
 void Bus::OnDispatchStatusChanged(DBusConnection* connection,
                                   DBusDispatchStatus status) {
   DCHECK_EQ(connection, connection_);
   AssertOnDBusThread();
 
   // We cannot call ProcessAllIncomingDataIfAny() here, as calling
   // dbus_connection_dispatch() inside DBusDispatchStatusFunction is
   // prohibited by the D-Bus library. Hence, we post a task here instead.
   // See comments for dbus_connection_set_dispatch_status_function().
-  PostTaskToDBusThread(FROM_HERE,
-                       base::Bind(&Bus::ProcessAllIncomingDataIfAny,
-                                  this));
+  GetDBusTaskRunner()->PostTask(FROM_HERE,
+                                base::Bind(&Bus::ProcessAllIncomingDataIfAny,
+                                           this));
 }
 
 void Bus::OnConnectionDisconnected(DBusConnection* connection) {
   AssertOnDBusThread();
 
   if (!on_disconnected_closure_.is_null())
-    PostTaskToOriginThread(FROM_HERE, on_disconnected_closure_);
+    GetOriginTaskRunner()->PostTask(FROM_HERE, on_disconnected_closure_);
 
   if (!connection)
     return;
   DCHECK(!dbus_connection_get_is_connected(connection));
 
   ShutdownAndBlock();
 }
 
 void Bus::OnServiceOwnerChanged(DBusMessage* message) {
   DCHECK(message);
@@ skipping 21 matching lines @@
     return;
   }
 
   ServiceOwnerChangedListenerMap::const_iterator it =
       service_owner_changed_listener_map_.find(service_name);
   if (it == service_owner_changed_listener_map_.end())
     return;
 
   const std::vector<GetServiceOwnerCallback>& callbacks = it->second;
   for (size_t i = 0; i < callbacks.size(); ++i) {
-    PostTaskToOriginThread(FROM_HERE,
-                           base::Bind(callbacks[i], new_owner));
+    GetOriginTaskRunner()->PostTask(FROM_HERE,
+                                    base::Bind(callbacks[i], new_owner));
   }
 }
 
 // static
 dbus_bool_t Bus::OnAddWatchThunk(DBusWatch* raw_watch, void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnAddWatch(raw_watch);
 }
 
 // static
@@ skipping 59 matching lines @@
                              kNameOwnerChangedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->OnServiceOwnerChanged(message);
   }
   // Always return unhandled to let others, e.g. ObjectProxies, handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus