Reuse existing object proxies and exported objects, if these exist.

dbus/bus.cc

 // Copyright (c) 2011 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.
 // - Collect metrics (ex. # of method calls, method call time, etc.)
 
 #include "dbus/bus.h"
 
@@ skipping 194 matching lines @@
   DCHECK(filter_functions_added_.empty());
   DCHECK(registered_object_paths_.empty());
   DCHECK_EQ(0, num_pending_watches_);
   DCHECK_EQ(0, num_pending_timeouts_);
 }
 
 ObjectProxy* Bus::GetObjectProxy(const std::string& service_name,
                                  const std::string& object_path) {
   AssertOnOriginThread();
 
+  // Check if we already have the requested object proxy.
+  const std::string key = service_name + object_path;
+  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);
-  object_proxies_.push_back(object_proxy);
+  object_proxy_table_[key] = object_proxy;
 
-  return object_proxy;
+  return object_proxy.get();
 }
 
 ExportedObject* Bus::GetExportedObject(const std::string& service_name,
                                        const std::string& object_path) {
   AssertOnOriginThread();
 
+  // Check if we already have the requested exported object.
+  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_objects_.push_back(exported_object);
+  exported_object_table_[key] = exported_object;
 
-  return 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_)
     return true;
 
@@ skipping 12 matching lines @@
   // We shouldn't exit on the disconnected signal.
   dbus_connection_set_exit_on_disconnect(connection_, false);
 
   return true;
 }
 
 void Bus::ShutdownAndBlock() {
   AssertOnDBusThread();
 
   // Unregister the exported objects.
-  for (size_t i = 0; i < exported_objects_.size(); ++i) {
-    exported_objects_[i]->Unregister();
+  for (ExportedObjectTable::iterator iter = exported_object_table_.begin();
+       iter != exported_object_table_.end(); ++iter) {
+    iter->second->Unregister();
   }
 
   // Release all service names.
   for (std::set<std::string>::iterator iter = owned_service_names_.begin();
        iter != owned_service_names_.end();) {
     // This is a bit tricky but we should increment the iter here as
     // ReleaseOwnership() may remove |service_name| from the set.
     const std::string& service_name = *iter++;
     ReleaseOwnership(service_name);
   }
   if (!owned_service_names_.empty()) {
     LOG(ERROR) << "Failed to release all service names. # of services left: "
                << owned_service_names_.size();
   }
 
   // Detach from the remote objects.
-  for (size_t i = 0; i < object_proxies_.size(); ++i) {
-    object_proxies_[i]->Detach();
+  for (ObjectProxyTable::iterator iter = object_proxy_table_.begin();
+       iter != object_proxy_table_.end(); ++iter) {
+    iter->second->Detach();
   }
 
   // Private connection should be closed.
   if (connection_ && connection_type_ == PRIVATE) {
     dbus_connection_close(connection_);
   }
   // dbus_connection_close() won't unref.
   dbus_connection_unref(connection_);
 
   connection_ = NULL;
@@ skipping 203 matching lines @@
       error);
   if (success)
     registered_object_paths_.insert(object_path);
   return success;
 }
 
 void Bus::UnregisterObjectPath(const std::string& object_path) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
-  DCHECK(registered_object_paths_.find(object_path) !=
-         registered_object_paths_.end())
-      << "Requested to unregister an unknown object path: " << object_path;
+  if (registered_object_paths_.find(object_path) ==
+      registered_object_paths_.end()) {
+    LOG(ERROR) << "Requested to unregister an unknown object path: "
+               << object_path;
+  }
 
   const bool success = dbus_connection_unregister_object_path(
       connection_,
       object_path.c_str());
   CHECK(success) << "Unable to allocate memory";
   registered_object_paths_.erase(object_path);
 }
 
 void Bus::ShutdownInternal(OnShutdownCallback callback) {
   AssertOnDBusThread();
@@ skipping 170 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus