dbus: Add ObjectProxy::WaitForServiceToBeAvailable()

dbus/object_proxy.h

 // 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.
 
 #ifndef DBUS_OBJECT_PROXY_H_
 #define DBUS_OBJECT_PROXY_H_
 
 #include <dbus/dbus.h>
 
 #include <map>
@@ skipping 59 matching lines @@
   typedef base::Callback<void(Response*)> ResponseCallback;
 
   // Called when a signal is received. Signal* is the incoming signal.
   typedef base::Callback<void (Signal*)> SignalCallback;
 
   // Called when NameOwnerChanged signal is received.
   typedef base::Callback<void(
       const std::string& old_owner,
       const std::string& new_owner)> NameOwnerChangedCallback;
 
+  // Called when the service becomes available.
+  typedef base::Callback<void(
+      bool service_is_available)> WaitForServiceToBeAvailableCallback;
+
   // Called when the object proxy is connected to the signal.
   // Parameters:
   // - the interface name.
   // - the signal name.
   // - whether it was successful or not.
   typedef base::Callback<void (const std::string&, const std::string&, bool)>
       OnConnectedCallback;
 
   // Calls the method of the remote object and blocks until the response
   // is returned. Returns NULL on error.
@@ skipping 55 matching lines @@
   virtual void ConnectToSignal(const std::string& interface_name,
                                const std::string& signal_name,
                                SignalCallback signal_callback,
                                OnConnectedCallback on_connected_callback);
 
   // Sets a callback for "NameOwnerChanged" signal. The callback is called on
   // the origin thread when D-Bus system sends "NameOwnerChanged" for the name
   // represented by |service_name_|.
   virtual void SetNameOwnerChangedCallback(NameOwnerChangedCallback callback);
 
+  // Runs the callback as soon as the service becomes available.
+  virtual void WaitForServiceToBeAvailable(
+      WaitForServiceToBeAvailableCallback callback);
+
   // Detaches from the remote object. The Bus object will take care of
   // detaching so you don't have to do this manually.
   //
   // BLOCKING CALL.
   virtual void Detach();
 
   // Returns an empty callback that does nothing. Can be used for
   // CallMethod().
   static ResponseCallback EmptyResponseCallback();
 
@@ skipping 36 matching lines @@
   // Runs the response callback with the given response object.
   void RunResponseCallback(ResponseCallback response_callback,
                            ErrorCallback error_callback,
                            base::TimeTicks start_time,
                            DBusMessage* response_message);
 
   // Redirects the function call to OnPendingCallIsComplete().
   static void OnPendingCallIsCompleteThunk(DBusPendingCall* pending_call,
                                            void* user_data);
 
+  // Connects to NameOwnerChanged signal.
+  bool ConnectToNameOwnerChangedSignal();
+
   // Helper function for ConnectToSignal().
   bool ConnectToSignalInternal(const std::string& interface_name,
                                const std::string& signal_name,
                                SignalCallback signal_callback);
 
+  // Helper function for WaitForServiceToBeAvailable().
+  void WaitForServiceToBeAvailableInternal();
+
   // Handles the incoming request messages and dispatches to the signal
   // callbacks.
   DBusHandlerResult HandleMessage(DBusConnection* connection,
                                   DBusMessage* raw_message);
 
   // Runs the method. Helper function for HandleMessage().
   void RunMethod(base::TimeTicks start_time,
                  std::vector<SignalCallback> signal_callbacks,
                  Signal* signal);
 
@@ skipping 29 matching lines @@
   // BLOCKING CALL.
   void UpdateNameOwnerAndBlock();
 
   // Handles NameOwnerChanged signal from D-Bus's special message bus.
   DBusHandlerResult HandleNameOwnerChanged(scoped_ptr<dbus::Signal> signal);
 
   // Runs |name_owner_changed_callback_|.
   void RunNameOwnerChangedCallback(const std::string& old_owner,
                                    const std::string& new_owner);
 
+  // Runs |wait_for_service_to_be_available_callbacks_|.
+  void RunWaitForServiceToBeAvailableCallbacks(bool service_is_available);
+
   scoped_refptr<Bus> bus_;
   std::string service_name_;
   ObjectPath object_path_;
 
   // True if the message filter was added.
   bool filter_added_;
 
   // The method table where keys are absolute signal names (i.e. interface
   // name + signal name), and values are lists of the corresponding callbacks.
   typedef std::map<std::string, std::vector<SignalCallback> > MethodTable;
   MethodTable method_table_;
 
   // The callback called when NameOwnerChanged signal is received.
   NameOwnerChangedCallback name_owner_changed_callback_;
 
+  // Called when the service becomes available.
+  std::vector<WaitForServiceToBeAvailableCallback>
+      wait_for_service_to_be_available_callbacks_;
+
   std::set<std::string> match_rules_;
 
   const bool ignore_service_unknown_errors_;
 
   // Known name owner of the well-known bus name represnted by |service_name_|.
   std::string service_name_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectProxy);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_OBJECT_PROXY_H_