D-Bus: ObjectProxy remove function for Bus object.

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 217 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();
 }
 
+bool Bus::RemoveObjectProxy(const std::string& service_name,
+                            const ObjectPath& object_path,
+                            OnRemoveObjectProxyCallback callback) {
+  return RemoveObjectProxyWithOptions(service_name, object_path,
+                                      ObjectProxy::DEFAULT_OPTIONS,
+                                      callback);
+}
+
+bool Bus::RemoveObjectProxyWithOptions(const std::string& service_name,
+                                       const dbus::ObjectPath& object_path,
+                                       int options,
+                                       OnRemoveObjectProxyCallback callback) {
+  AssertOnOriginThread();
+
+  // Check if we have the requested object proxy.
+  const ObjectProxyTable::key_type key(service_name + object_path.value(),
+                                       options);
+  ObjectProxyTable::iterator iter = object_proxy_table_.find(key);
+  if (iter != object_proxy_table_.end()) {
+    // Object is present. Remove it now and Detach in the DBus thread.
+    PostTaskToDBusThread(FROM_HERE, base::Bind(
+        &Bus::RemoveObjectProxyInternal,
+        this, iter->second, service_name, object_path, options, callback));
+
+    object_proxy_table_.erase(iter);
+    return true;
+  }
+  return false;
+}
+
+void Bus::RemoveObjectProxyInternal(
+    scoped_refptr<dbus::ObjectProxy> object_proxy,
+    const std::string& service_name,
+    const dbus::ObjectPath& object_path,
+    int options,
+    OnRemoveObjectProxyCallback callback) {
+  AssertOnDBusThread();
+
+  object_proxy.get()->Detach();
+
+  PostTaskToOriginThread(FROM_HERE,
+                         base::Bind(&Bus::OnRemoveObjectProxy,
+                                    this,
+                                    callback,
+                                    service_name,
+                                    object_path,
+                                    options));

[satorux1, 2013/01/25 01:46:06]

I think you don't need OnRemoveObjectProxy.

You should be able to do something like:

base::Bind(callback, service_name, object_path, options);

[deymo, 2013/01/25 20:50:55]

Done.

+}
+
+void Bus::OnRemoveObjectProxy(OnRemoveObjectProxyCallback callback,
+                              const std::string& service_name,
+                              const dbus::ObjectPath& object_path,
+                              int options) {
+  AssertOnOriginThread();
+
+  callback.Run(service_name, object_path, options);
+}
+
 ExportedObject* Bus::GetExportedObject(const ObjectPath& object_path) {
   AssertOnOriginThread();
 
   // Check if we already have the requested exported object.
   ExportedObjectTable::iterator iter = exported_object_table_.find(object_path);
   if (iter != exported_object_table_.end()) {
     return iter->second;
   }
 
   scoped_refptr<ExportedObject> exported_object =
@@ skipping 159 matching lines @@
 
   bool success = Connect();
   if (success)
     success = RequestOwnershipAndBlock(service_name);
 
   PostTaskToOriginThread(FROM_HERE,
                          base::Bind(&Bus::OnOwnership,
                                     this,
                                     on_ownership_callback,
                                     service_name,
                                     success));

[satorux1, 2013/01/25 01:46:06]

While you are at it, could you remove OnOwnership?

[deymo, 2013/01/25 20:50:55]

Done.

 }
 
 void Bus::OnOwnership(OnOwnershipCallback on_ownership_callback,
                       const std::string& service_name,
                       bool success) {
   AssertOnOriginThread();
 
   on_ownership_callback.Run(service_name, success);
 }
 
@@ skipping 415 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus