dbus: remove service name from ExportedObject

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_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 158 matching lines @@
     // requirements:
     // 1) Already running.
     // 2) Has a MessageLoopForIO.
     scoped_refptr<base::MessageLoopProxy> dbus_thread_message_loop_proxy;
   };
 
   // Creates a Bus object. The actual connection will be established when
   // Connect() is called.
   explicit Bus(const Options& options);
 
+  // Called when an ownership request is complete.
+  // Parameters:
+  // - the requested service name.
+  // - whether ownership has been obtained or not.
+  typedef base::Callback<void (const std::string&, bool)> OnOwnershipCallback;
+
   // Gets the object proxy for the given service name and the object path.
   // The caller must not delete the returned object.
   //
   // Returns an existing object proxy if the bus object already owns the
   // object proxy for the given service name and the object path.
   // Never returns NULL.
   //
   // The bus will own all object proxies created by the bus, to ensure
   // that the object proxies are detached from remote objects at the
   // shutdown time of the bus.
   //
   // The object proxy is used to call methods of remote objects, and
   // receive signals from them.
   //
   // |service_name| looks like "org.freedesktop.NetworkManager", and
   // |object_path| looks like "/org/freedesktop/NetworkManager/Devices/0".
   //
   // Must be called in the origin thread.
   virtual ObjectProxy* GetObjectProxy(const std::string& service_name,
                                       const ObjectPath& object_path);
 
   // Same as above, but also takes a bitfield of ObjectProxy::Options.
   // See object_proxy.h for available options.
   virtual ObjectProxy* GetObjectProxyWithOptions(
       const std::string& service_name,
       const ObjectPath& object_path,
       int options);
 
-  // Gets the exported object for the given service name and the object
-  // path. The caller must not delete the returned object.
+  // Gets the exported object for the given object path.
+  // The caller must not delete the returned object.
   //
   // Returns an existing exported object if the bus object already owns
-  // the exported object for the given service name and the object path.
-  // Never returns NULL.
+  // the exported object for the given object path. Never returns NULL.
   //
   // The bus will own all exported objects created by the bus, to ensure
   // that the exported objects are unregistered at the shutdown time of
   // the bus.
   //
   // The exported object is used to export methods of local objects, and
   // send signal from them.
   //
   // Must be called in the origin thread.
-  virtual ExportedObject* GetExportedObject(const std::string& service_name,
-                                            const ObjectPath& object_path);
+  virtual ExportedObject* GetExportedObject(const ObjectPath& object_path);
 
   // Shuts down the bus and blocks until it's done. More specifically, this
   // function does the following:
   //
   // - Unregisters the object paths
   // - Releases the service names
   // - Closes the connection to dbus-daemon.
   //
   // BLOCKING CALL.
   virtual void ShutdownAndBlock();
@@ skipping 14 matching lines @@
   // The public functions below are not intended to be used in client
   // code. These are used to implement ObjectProxy and ExportedObject.
   //
 
   // Connects the bus to the dbus-daemon.
   // Returns true on success, or the bus is already connected.
   //
   // BLOCKING CALL.
   virtual bool Connect();
 
+  // Requests the ownership of the service name given by |service_name|.
+  // See also RequestOwnershipAndBlock().
+  //
+  // |on_ownership_callback| is called when the service name is obtained
+  // or failed to be obtained, in the origin thread.
+  //
+  // Must be called in the origin thread.
+  virtual void RequestOwnership(const std::string& service_name,
+                                OnOwnershipCallback on_ownership_callback);
+
   // Requests the ownership of the given service name.
   // Returns true on success, or the the service name is already obtained.
   //
   // BLOCKING CALL.
-  virtual bool RequestOwnership(const std::string& service_name);
+  virtual bool RequestOwnershipAndBlock(const std::string& service_name);
 
   // Releases the ownership of the given service name.
   // Returns true on success.
   //
   // BLOCKING CALL.
   virtual bool ReleaseOwnership(const std::string& service_name);
 
   // Sets up async operations.
   // Returns true on success, or it's already set up.
   // This function needs to be called before starting async operations.
@@ skipping 129 matching lines @@
  protected:
   // This is protected, so we can define sub classes.
   virtual ~Bus();
 
  private:
   friend class base::RefCountedThreadSafe<Bus>;
 
   // Helper function used for ShutdownOnDBusThreadAndBlock().
   void ShutdownOnDBusThreadAndBlockInternal();
 
+  // Helper function used for RequestOwnership().
+  void RequestOwnershipInternal(const std::string& service_name,
+                                OnOwnershipCallback on_ownership_callback);
+
+  // Called when the ownership request is completed.
+  void OnOwnership(OnOwnershipCallback on_ownership_callback,
+                   const std::string& service_name,
+                   bool success);
+
   // 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 49 matching lines @@
   // service name + object path, like
   // "org.chromium.TestService/org/chromium/TestObject".
   // The second part is the ObjectProxy::Options for the proxy.
   typedef std::map<std::pair<std::string, int>,
                    scoped_refptr<dbus::ObjectProxy> > ObjectProxyTable;
   ObjectProxyTable object_proxy_table_;
 
   // ExportedObjectTable is used to hold the exported objects 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,
+  typedef std::map<const dbus::ObjectPath,
                    scoped_refptr<dbus::ExportedObject> > ExportedObjectTable;
   ExportedObjectTable exported_object_table_;
 
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_