dbus: Rewrite ObjectProxy::ConnectToSignal with PostTaskAndReplyWithResult

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"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
+#include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/dbus_statistics.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/scoped_dbus_error.h"
 
 namespace dbus {
 
@@ skipping 141 matching lines @@
   // Wait for the response in the D-Bus thread.
   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_->GetDBusTaskRunner()->PostTask(
+  base::PostTaskAndReplyWithResult(
+      bus_->GetDBusTaskRunner(),
       FROM_HERE,
       base::Bind(&ObjectProxy::ConnectToSignalInternal,
                  this,
                  interface_name,
                  signal_name,
-                 signal_callback,
-                 on_connected_callback));
+                 signal_callback),
+      base::Bind(on_connected_callback,
+                 interface_name,
+                 signal_name));
 }
 
 void ObjectProxy::Detach() {
   bus_->AssertOnDBusThread();
 
   if (filter_added_) {
     if (!bus_->RemoveFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
       LOG(ERROR) << "Failed to remove filter function";
     }
   }
@@ skipping 154 matching lines @@
   OnPendingCallIsCompleteData* data =
       reinterpret_cast<OnPendingCallIsCompleteData*>(user_data);
   ObjectProxy* self = data->object_proxy;
   self->OnPendingCallIsComplete(pending_call,
                                 data->response_callback,
                                 data->error_callback,
                                 data->start_time);
   delete data;
 }
 
-void ObjectProxy::ConnectToSignalInternal(
-    const std::string& interface_name,
-    const std::string& signal_name,
-    SignalCallback signal_callback,
-    OnConnectedCallback on_connected_callback) {
+bool ObjectProxy::ConnectToSignalInternal(const std::string& interface_name,
+                                          const std::string& signal_name,
+                                          SignalCallback signal_callback) {
   bus_->AssertOnDBusThread();
 
   const std::string absolute_signal_name =
       GetAbsoluteSignalName(interface_name, signal_name);
 
-  // Will become true, if everything is successful.
-  bool success = false;
+  if (!bus_->Connect() || !bus_->SetUpAsyncOperations())
+    return false;
 
-  if (bus_->Connect() && bus_->SetUpAsyncOperations()) {
-    // We should add the filter only once. Otherwise, HandleMessage() will
-    // be called more than once.
-    if (!filter_added_) {
-      if (bus_->AddFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
-        filter_added_ = true;
-      } else {
-        LOG(ERROR) << "Failed to add filter function";
-      }
+  // We should add the filter only once. Otherwise, HandleMessage() will
+  // be called more than once.
+  if (!filter_added_) {
+    if (bus_->AddFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
+      filter_added_ = true;
+    } else {
+      LOG(ERROR) << "Failed to add filter function";
     }
-    // Add a match rule so the signal goes through HandleMessage().
-    const std::string match_rule =
-        base::StringPrintf("type='signal', interface='%s', path='%s'",
-                           interface_name.c_str(),
-                           object_path_.value().c_str());
-    // Add a match_rule listening NameOwnerChanged for the well-known name
-    // |service_name_|.
-    const std::string name_owner_changed_match_rule =
-        base::StringPrintf(
-            "type='signal',interface='org.freedesktop.DBus',"
-            "member='NameOwnerChanged',path='/org/freedesktop/DBus',"
-            "sender='org.freedesktop.DBus',arg0='%s'",
-            service_name_.c_str());
-    if (AddMatchRuleWithCallback(match_rule,
-                                 absolute_signal_name,
-                                 signal_callback) &&
-        AddMatchRuleWithoutCallback(name_owner_changed_match_rule,
-                                    "org.freedesktop.DBus.NameOwnerChanged")) {
-      success = true;
-    }
+  }
+  // Add a match rule so the signal goes through HandleMessage().
+  const std::string match_rule =
+      base::StringPrintf("type='signal', interface='%s', path='%s'",
+                         interface_name.c_str(),
+                         object_path_.value().c_str());
+  // Add a match_rule listening NameOwnerChanged for the well-known name
+  // |service_name_|.
+  const std::string name_owner_changed_match_rule =
+      base::StringPrintf(
+          "type='signal',interface='org.freedesktop.DBus',"
+          "member='NameOwnerChanged',path='/org/freedesktop/DBus',"
+          "sender='org.freedesktop.DBus',arg0='%s'",
+          service_name_.c_str());
 
-    // 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();
-  }
+  const bool success =
+      AddMatchRuleWithCallback(match_rule,
+                               absolute_signal_name,
+                               signal_callback) &&
+      AddMatchRuleWithoutCallback(name_owner_changed_match_rule,
+                                  "org.freedesktop.DBus.NameOwnerChanged");
 
-  // Run on_connected_callback in the origin thread.
-  bus_->GetOriginTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ObjectProxy::OnConnected,
-                 this,
-                 on_connected_callback,
-                 interface_name,
-                 signal_name,
-                 success));
-}
+  // 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();
 
-void ObjectProxy::OnConnected(OnConnectedCallback on_connected_callback,
-                              const std::string& interface_name,
-                              const std::string& signal_name,
-                              bool success) {
-  bus_->AssertOnOriginThread();
-
-  on_connected_callback.Run(interface_name, signal_name, success);
+  return success;
 }
 
 void ObjectProxy::SetNameOwnerChangedCallback(SignalCallback callback) {
   bus_->AssertOnOriginThread();
 
   name_owner_changed_callback_ = callback;
 }
 
 DBusHandlerResult ObjectProxy::HandleMessage(
     DBusConnection* connection,
@@ skipping 217 matching lines @@
       }
     }
   }
 
   // Always return unhandled to let other object proxies handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus