Linux/CrOS: Retry connecting to mtpd.

dbus/bus.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_BUS_H_
 #define DBUS_BUS_H_
 
 #include <dbus/dbus.h>
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/dbus_export.h"
 #include "dbus/object_path.h"
 
 namespace base {
 class SequencedTaskRunner;
 class SingleThreadTaskRunner;
-class Thread;
 }
 
 namespace tracked_objects {
 class Location;
 }
 
 namespace dbus {
 
 class ExportedObject;
 class ObjectManager;
@@ skipping 520 matching lines @@
   //
   // BLOCKING CALL.
   virtual std::string GetServiceOwnerAndBlock(const std::string& service_name,
                                               GetServiceOwnerOption options);
 
   // A non-blocking version of GetServiceOwnerAndBlock().
   // Must be called in the origin thread.
   virtual void GetServiceOwner(const std::string& service_name,
                                const GetServiceOwnerCallback& callback);
 
+  // Whenever the owner for |service_name| changes, run |callback| with the
+  // name of the new owner. If the owner goes away, then |callback| receives
+  // an empty string.
+  //
+  // Any unique (service_name, callback) can be used. Duplicate are ignored.
+  // |service_name| must not be empty and |callback| must not be null.
+  //
+  // Must be called in the origin thread.
+  virtual void ListenForServiceOwnerChange(
+      const std::string& service_name,
+      const GetServiceOwnerCallback& callback);
+
+  // Stop listening for |service_name| owner changes for |callback|.
+  // Any unique (service_name, callback) can be used. Non-registered callbacks
+  // for a given service name are ignored.
+  // |service_name| must not be empty and |callback| must not be null.
+  //
+  // Must be called in the origin thread.
+  virtual void UnlistenForServiceOwnerChange(
+      const std::string& service_name,
+      const GetServiceOwnerCallback& callback);
+
   // Returns true if the bus is connected to D-Bus.
   bool is_connected() { return connection_ != NULL; }
 
  protected:
   // This is protected, so we can define sub classes.
   virtual ~Bus();
 
  private:
   friend class base::RefCountedThreadSafe<Bus>;
 
   // Helper function used for RemoveObjectProxy().
   void RemoveObjectProxyInternal(scoped_refptr<dbus::ObjectProxy> object_proxy,
                                  const base::Closure& callback);
 
   // Helper function used for UnregisterExportedObject().
   void UnregisterExportedObjectInternal(
       scoped_refptr<dbus::ExportedObject> exported_object);
 
   // Helper function used for ShutdownOnDBusThreadAndBlock().
   void ShutdownOnDBusThreadAndBlockInternal();
 
   // Helper function used for RequestOwnership().
   void RequestOwnershipInternal(const std::string& service_name,
                                 OnOwnershipCallback on_ownership_callback);
 
   // Helper function used for GetServiceOwner().
   void GetServiceOwnerInternal(const std::string& service_name,
                                const GetServiceOwnerCallback& callback);
 
+  // Helper function used for ListenForServiceOwnerChange().
+  void ListenForServiceOwnerChangeInternal(
+      const std::string& service_name,
+      const GetServiceOwnerCallback& callback);
+
+  // Helper function used for UnListenForServiceOwnerChange().
+  void UnlistenForServiceOwnerChangeInternal(
+      const std::string& service_name,
+      const GetServiceOwnerCallback& callback);
+
   // Processes the all incoming data to the connection, if any.
   //
   // BLOCKING CALL.
   void ProcessAllIncomingDataIfAny();
 
   // Called when a watch object is added. Used to start monitoring the
   // file descriptor used for D-Bus communication.
   dbus_bool_t OnAddWatch(DBusWatch* raw_watch);
 
   // Called when a watch object is removed.
@@ skipping 13 matching lines @@
   void OnToggleTimeout(DBusTimeout* raw_timeout);
 
   // Called when the dispatch status (i.e. if any incoming data is
   // available) is changed.
   void OnDispatchStatusChanged(DBusConnection* connection,
                                DBusDispatchStatus status);
 
   // Called when the connection is diconnected.
   void OnConnectionDisconnected(DBusConnection* connection);
 
+  // Called when a service owner change occurs.
+  void OnServiceOwnerChanged(DBusMessage* message);
+
   // Callback helper functions. Redirects to the corresponding member function.
   static dbus_bool_t OnAddWatchThunk(DBusWatch* raw_watch, void* data);
   static void OnRemoveWatchThunk(DBusWatch* raw_watch, void* data);
   static void OnToggleWatchThunk(DBusWatch* raw_watch, void* data);
   static dbus_bool_t OnAddTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnRemoveTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnToggleTimeoutThunk(DBusTimeout* raw_timeout, void* data);
   static void OnDispatchStatusChangedThunk(DBusConnection* connection,
                                            DBusDispatchStatus status,
                                            void* data);
 
-  // Calls OnConnectionDisconnected if the Diconnected signal is received.
+  // Calls OnConnectionDisconnected if the Disconnected signal is received.
   static DBusHandlerResult OnConnectionDisconnectedFilter(
       DBusConnection* connection,
       DBusMessage* message,
       void* user_data);
 
+  // Calls OnServiceOwnerChanged for a NameOwnerChanged signal.
+  static DBusHandlerResult OnServiceOwnerChangedFilter(
+      DBusConnection* connection,
+      DBusMessage* message,
+      void* user_data);
+
   const BusType bus_type_;
   const ConnectionType connection_type_;
   scoped_refptr<base::SequencedTaskRunner> dbus_task_runner_;
   base::WaitableEvent on_shutdown_;
   DBusConnection* connection_;
 
   scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
   base::PlatformThreadId origin_thread_id_;
 
   std::set<std::string> owned_service_names_;
@@ skipping 22 matching lines @@
                    scoped_refptr<dbus::ExportedObject> > ExportedObjectTable;
   ExportedObjectTable exported_object_table_;
 
   // ObjectManagerTable is used to hold the object managers created by the
   // bus object. Key is a concatenated string of service name + object path,
   // like "org.chromium.TestService/org/chromium/TestObject".
   typedef std::map<std::string,
                    scoped_refptr<dbus::ObjectManager> > ObjectManagerTable;
   ObjectManagerTable object_manager_table_;
 
+  // A map of NameOwnerChanged signals to listen for and the callbacks to run
+  // on the origin thread when the owner changes.
+  // Only accessed on the DBus thread.
+  // Key: Service name
+  // Value: Vector of callbacks. Unique and expected to be small. Not using
+  //        std::set here because base::Callbacks don't have a '<' operator.
+  typedef std::map<std::string, std::vector<GetServiceOwnerCallback> >
+      ServiceOwnerChangedListenerMap;
+  ServiceOwnerChangedListenerMap service_owner_changed_listener_map_;
+
   bool async_operations_set_up_;
   bool shutdown_completed_;
 
   // Counters to make sure that OnAddWatch()/OnRemoveWatch() and
   // OnAddTimeout()/OnRemoveTimeou() are balanced.
   int num_pending_watches_;
   int num_pending_timeouts_;
 
   std::string address_;
   base::Closure on_disconnected_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_