dbus: remove service name from ExportedObject

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"
@@ skipping 215 matching lines @@
     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) {
+ExportedObject* Bus::GetExportedObject(const ObjectPath& object_path) {
   AssertOnOriginThread();
 
   // Check if we already have the requested exported object.
-  const std::string key = service_name + object_path.value();
-  ExportedObjectTable::iterator iter = exported_object_table_.find(key);
+  ExportedObjectTable::iterator iter = exported_object_table_.find(object_path);
   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;
+      new ExportedObject(this, object_path);
+  exported_object_table_[object_path] = exported_object;
 
   return exported_object.get();
 }
 
 bool Bus::Connect() {
   // dbus_bus_get_private() and dbus_bus_get() are blocking calls.
   AssertOnDBusThread();
 
   // Check if it's already initialized.
   if (connection_)
@@ skipping 72 matching lines @@
       this));
 
   // Wait until the shutdown is complete on the D-Bus thread.
   // The shutdown should not hang, but set timeout just in case.
   const int kTimeoutSecs = 3;
   const base::TimeDelta timeout(base::TimeDelta::FromSeconds(kTimeoutSecs));
   const bool signaled = on_shutdown_.TimedWait(timeout);
   LOG_IF(ERROR, !signaled) << "Failed to shutdown the bus";
 }
 
-bool Bus::RequestOwnership(const std::string& service_name) {
+void Bus::RequestOwnership(const std::string& service_name,
+                           OnOwnershipCallback on_ownership_callback) {
+  AssertOnOriginThread();
+
+  PostTaskToDBusThread(FROM_HERE, base::Bind(
+      &Bus::RequestOwnershipInternal,
+      this, service_name, on_ownership_callback));
+}
+
+void Bus::RequestOwnershipInternal(const std::string& service_name,
+                                   OnOwnershipCallback on_ownership_callback) {
+  AssertOnDBusThread();
+
+  bool success = Connect();
+  if (success)
+    success = RequestOwnershipAndBlock(service_name);
+
+  PostTaskToOriginThread(FROM_HERE,
+                         base::Bind(&Bus::OnOwnership,
+                                    this,
+                                    on_ownership_callback,
+                                    service_name,
+                                    success));
+}
+
+void Bus::OnOwnership(OnOwnershipCallback on_ownership_callback,
+                      const std::string& service_name,
+                      bool success) {
+  AssertOnOriginThread();
+
+  on_ownership_callback.Run(service_name, success);
+}
+
+bool Bus::RequestOwnershipAndBlock(const std::string& service_name) {
   DCHECK(connection_);
   // dbus_bus_request_name() is a blocking call.
   AssertOnDBusThread();
 
   // Check if we already own the service name.
   if (owned_service_names_.find(service_name) != owned_service_names_.end()) {
     return true;
   }
 
   ScopedDBusError error;
@@ skipping 404 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus