dbus: add ObjectPath type

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>
 #include <string>
 #include <utility>
 #include <dbus/dbus.h>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/tracked_objects.h"
+#include "dbus/object_path.h"
 
 class MessageLoop;
 
 namespace base {
 class Thread;
 class MessageLoopProxy;
 }
 
 namespace dbus {
 
@@ skipping 75 matching lines @@
 //     // Do something with method_call.
 //     Response* response = Response::FromMethodCall(method_call);
 //     // Build response here.
 //     // Can send an immediate response here to implement a synchronous service
 //     // or store the response_sender and send a response later to implement an
 //     // asynchronous service.
 //     response_sender.Run(response);
 //   }
 //
 //   void OnExported(const std::string& interface_name,
-//                   const std::string& object_path,
+//                   const ObjectPath& object_path,
 //                   bool success) {
 //     // success is true if the method was exported successfully.
 //   }
 //
 //   ...
 //   dbus::ExportedObject* exported_object =
 //       bus.GetExportedObject(service_name, object_path);
 //   exported_object.ExportMethod(interface_name, method_name,
 //                                base::Bind(&Echo),
 //                                base::Bind(&OnExported));
@@ skipping 61 matching lines @@
   // 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 std::string& object_path);
+                                      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 std::string& object_path,
+      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.
   //
   // 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 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 std::string& object_path);
+                                            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 113 matching lines @@
   //
   // |message_function| in |vtable| will be called every time when a new
   // |message sent to the object path arrives.
   //
   // The same object path must not be added more than once.
   //
   // See also documentation of |dbus_connection_try_register_object_path| at
   // http://dbus.freedesktop.org/doc/api/html/group__DBusConnection.html
   //
   // BLOCKING CALL.
-  virtual bool TryRegisterObjectPath(const std::string& object_path,
+  virtual bool TryRegisterObjectPath(const ObjectPath& object_path,
                                      const DBusObjectPathVTable* vtable,
                                      void* user_data,
                                      DBusError* error);
 
   // Unregister the object path.
   //
   // BLOCKING CALL.
-  virtual void UnregisterObjectPath(const std::string& object_path);
+  virtual void UnregisterObjectPath(const ObjectPath& object_path);
 
   // Posts the task to the message loop of the thread that created the bus.
   virtual void PostTaskToOriginThread(
       const tracked_objects::Location& from_here,
       const base::Closure& task);
 
   // Posts the task to the message loop of the D-Bus thread. If D-Bus
   // thread is not supplied, the message loop of the origin thread will be
   // used.
   virtual void PostTaskToDBusThread(
@@ skipping 79 matching lines @@
   base::WaitableEvent on_shutdown_;
   DBusConnection* connection_;
 
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformThreadId origin_thread_id_;
 
   std::set<std::string> owned_service_names_;
   // The following sets are used to check if rules/object_paths/filters
   // are properly cleaned up before destruction of the bus object.
   std::set<std::string> match_rules_added_;
-  std::set<std::string> registered_object_paths_;
+  std::set<ObjectPath> registered_object_paths_;
   std::set<std::pair<DBusHandleMessageFunction, void*> >
       filter_functions_added_;
 
   // ObjectProxyTable is used to hold the object proxies created by the
   // bus object. Key is a pair; the first part is a concatenated string of
   // 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;
@@ skipping 13 matching lines @@
   // OnAddTimeout()/OnRemoveTimeou() are balanced.
   int num_pending_watches_;
   int num_pending_timeouts_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_