Revert 121920 - dbus: add ObjectPath type

dbus/bus.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.
 //
 // TODO(satorux):
 // - Handle "disconnected" signal.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "dbus/exported_object.h"
-#include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/scoped_dbus_error.h"
 
 namespace dbus {
 
 namespace {
 
 // The class is used for watching the file descriptor used for D-Bus
 // communication.
 class Watch : public base::MessagePumpLibevent::Watcher {
@@ skipping 171 matching lines @@
   DCHECK(filter_functions_added_.empty());
   DCHECK(registered_object_paths_.empty());
   DCHECK_EQ(0, num_pending_watches_);
   // TODO(satorux): This check fails occasionally in browser_tests for tests
   // that run very quickly. Perhaps something does not have time to clean up.
   // Despite the check failing, the tests seem to run fine. crosbug.com/23416
   // DCHECK_EQ(0, num_pending_timeouts_);
 }
 
 ObjectProxy* Bus::GetObjectProxy(const std::string& service_name,
-                                 const ObjectPath& object_path) {
+                                 const std::string& object_path) {
   return GetObjectProxyWithOptions(service_name, object_path,
                                    ObjectProxy::DEFAULT_OPTIONS);
 }
 
 ObjectProxy* Bus::GetObjectProxyWithOptions(const std::string& service_name,
-                                            const dbus::ObjectPath& object_path,
+                                            const std::string& object_path,
                                             int options) {
   AssertOnOriginThread();
 
   // Check if we already have the requested object proxy.
-  const ObjectProxyTable::key_type key(service_name + object_path.value(),
-                                       options);
+  const ObjectProxyTable::key_type key(service_name + object_path, options);
   ObjectProxyTable::iterator iter = object_proxy_table_.find(key);
   if (iter != object_proxy_table_.end()) {
     return iter->second;
   }
 
   scoped_refptr<ObjectProxy> object_proxy =
       new ObjectProxy(this, service_name, object_path, options);
   object_proxy_table_[key] = object_proxy;
 
   return object_proxy.get();
 }
 
 ExportedObject* Bus::GetExportedObject(const std::string& service_name,
-                                       const ObjectPath& object_path) {
+                                       const std::string& object_path) {
   AssertOnOriginThread();
 
   // Check if we already have the requested exported object.
-  const std::string key = service_name + object_path.value();
+  const std::string key = service_name + object_path;
   ExportedObjectTable::iterator iter = exported_object_table_.find(key);
   if (iter != exported_object_table_.end()) {
     return iter->second;
   }
 
   scoped_refptr<ExportedObject> exported_object =
       new ExportedObject(this, service_name, object_path);
   exported_object_table_[key] = exported_object;
 
   return exported_object.get();
@@ skipping 264 matching lines @@
 
   if (match_rules_added_.find(match_rule) == match_rules_added_.end()) {
     LOG(ERROR) << "Requested to remove an unknown match rule: " << match_rule;
     return;
   }
 
   dbus_bus_remove_match(connection_, match_rule.c_str(), error);
   match_rules_added_.erase(match_rule);
 }
 
-bool Bus::TryRegisterObjectPath(const ObjectPath& object_path,
+bool Bus::TryRegisterObjectPath(const std::string& object_path,
                                 const DBusObjectPathVTable* vtable,
                                 void* user_data,
                                 DBusError* error) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   if (registered_object_paths_.find(object_path) !=
       registered_object_paths_.end()) {
-    LOG(ERROR) << "Object path already registered: " << object_path.value();
+    LOG(ERROR) << "Object path already registered: " << object_path;
     return false;
   }
 
   const bool success = dbus_connection_try_register_object_path(
       connection_,
-      object_path.value().c_str(),
+      object_path.c_str(),
       vtable,
       user_data,
       error);
   if (success)
     registered_object_paths_.insert(object_path);
   return success;
 }
 
-void Bus::UnregisterObjectPath(const ObjectPath& object_path) {
+void Bus::UnregisterObjectPath(const std::string& object_path) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   if (registered_object_paths_.find(object_path) ==
       registered_object_paths_.end()) {
     LOG(ERROR) << "Requested to unregister an unknown object path: "
-               << object_path.value();
+               << object_path;
     return;
   }
 
   const bool success = dbus_connection_unregister_object_path(
       connection_,
-      object_path.value().c_str());
+      object_path.c_str());
   CHECK(success) << "Unable to allocate memory";
   registered_object_paths_.erase(object_path);
 }
 
 void Bus::ShutdownOnDBusThreadAndBlockInternal() {
   AssertOnDBusThread();
 
   ShutdownAndBlock();
   on_shutdown_.Signal();
 }
@@ skipping 183 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus