dbus: Add ObjectProxy::WaitForServiceToBeAvailable()

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 174 matching lines @@
                  signal_name));
 }
 
 void ObjectProxy::SetNameOwnerChangedCallback(
     NameOwnerChangedCallback callback) {
   bus_->AssertOnOriginThread();
 
   name_owner_changed_callback_ = callback;
 }
 
+void ObjectProxy::WaitForServiceToBeAvailable(
+    WaitForServiceToBeAvailableCallback callback) {
+  bus_->AssertOnOriginThread();
+
+  wait_for_service_to_be_available_callbacks_.push_back(callback);
+  bus_->GetDBusTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ObjectProxy::WaitForServiceToBeAvailableInternal, this));
+}
+
 void ObjectProxy::Detach() {
   bus_->AssertOnDBusThread();
 
   if (filter_added_) {
     if (!bus_->RemoveFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
       LOG(ERROR) << "Failed to remove filter function";
     }
   }
 
   for (std::set<std::string>::iterator iter = match_rules_.begin();
@@ skipping 152 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;
 }
 
-bool ObjectProxy::ConnectToSignalInternal(const std::string& interface_name,
-                                          const std::string& signal_name,
-                                          SignalCallback signal_callback) {
+bool ObjectProxy::ConnectToNameOwnerChangedSignal() {
   bus_->AssertOnDBusThread();
 
-  const std::string absolute_signal_name =
-      GetAbsoluteSignalName(interface_name, signal_name);
-
   if (!bus_->Connect() || !bus_->SetUpAsyncOperations())
     return false;
 
   // 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());
 
   const bool success =
-      AddMatchRuleWithCallback(match_rule,
-                               absolute_signal_name,
-                               signal_callback) &&
       AddMatchRuleWithoutCallback(name_owner_changed_match_rule,
                                   "org.freedesktop.DBus.NameOwnerChanged");
 
   // 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();
 
   return success;
 }
 
+bool ObjectProxy::ConnectToSignalInternal(const std::string& interface_name,
+                                          const std::string& signal_name,
+                                          SignalCallback signal_callback) {
+  bus_->AssertOnDBusThread();
+
+  if (!ConnectToNameOwnerChangedSignal())
+    return false;
+
+  const std::string absolute_signal_name =
+      GetAbsoluteSignalName(interface_name, signal_name);
+
+  // 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());
+  return AddMatchRuleWithCallback(match_rule,
+                                  absolute_signal_name,
+                                  signal_callback);
+}
+
+void ObjectProxy::WaitForServiceToBeAvailableInternal() {
+  bus_->AssertOnDBusThread();
+
+  if (!ConnectToNameOwnerChangedSignal()) {  // Failed to connect to the signal.
+    const bool service_is_ready = false;
+    bus_->GetOriginTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ObjectProxy::RunWaitForServiceToBeAvailableCallbacks,
+                   this, service_is_ready));
+    return;
+  }
+
+  const bool service_is_available = !service_name_owner_.empty();
+  if (service_is_available) {  // Service is already available.
+    bus_->GetOriginTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ObjectProxy::RunWaitForServiceToBeAvailableCallbacks,
+                   this, service_is_available));
+    return;
+  }
+}
+
 DBusHandlerResult ObjectProxy::HandleMessage(
     DBusConnection* connection,
     DBusMessage* raw_message) {
   bus_->AssertOnDBusThread();
 
   if (dbus_message_get_type(raw_message) != DBUS_MESSAGE_TYPE_SIGNAL)
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   // raw_message will be unrefed on exit of the function. Increment the
   // reference so we can use it in Signal.
@@ skipping 191 matching lines @@
     std::string name, old_owner, new_owner;
     if (reader.PopString(&name) &&
         reader.PopString(&old_owner) &&
         reader.PopString(&new_owner) &&
         name == service_name_) {
       service_name_owner_ = new_owner;
       bus_->GetOriginTaskRunner()->PostTask(
           FROM_HERE,
           base::Bind(&ObjectProxy::RunNameOwnerChangedCallback,
                      this, old_owner, new_owner));
+
+      const bool service_is_available = !service_name_owner_.empty();
+      if (service_is_available) {
+        bus_->GetOriginTaskRunner()->PostTask(
+            FROM_HERE,
+            base::Bind(&ObjectProxy::RunWaitForServiceToBeAvailableCallbacks,
+                       this, service_is_available));
+      }
     }
   }
 
   // Always return unhandled to let other object proxies handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 void ObjectProxy::RunNameOwnerChangedCallback(const std::string& old_owner,
                                               const std::string& new_owner) {
   bus_->AssertOnOriginThread();
   if (!name_owner_changed_callback_.is_null())
     name_owner_changed_callback_.Run(old_owner, new_owner);
 }
 
+void ObjectProxy::RunWaitForServiceToBeAvailableCallbacks(
+    bool service_is_available) {
+  bus_->AssertOnOriginThread();
+
+  std::vector<WaitForServiceToBeAvailableCallback> callbacks;
+  callbacks.swap(wait_for_service_to_be_available_callbacks_);
+  for (size_t i = 0; i < callbacks.size(); ++i)
+    callbacks[i].Run(service_is_available);
+}
+
 }  // namespace dbus