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

dbus/bus.h

 
 // 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.
 
 #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/memory/scoped_ptr.h"
 #include "base/tracked_objects.h"
 
 class MessageLoop;
 
 namespace base {
@@ skipping 26 matching lines @@
 //
 // BLOCKING CALLS
 //
 // Functions that issue blocking calls are marked "BLOCKING CALL" and
 // these functions should be called in the D-Bus thread (if
 // supplied). AssertOnDBusThread() is placed in these functions.
 //
 // Note that it's hard to tell if a libdbus function is actually blocking
 // or not (ex. dbus_bus_request_name() internally calls
 // dbus_connection_send_with_reply_and_block(), which is a blocking
-// call). To err on the side, we consider all libdbus functions that deal
-// with the connection to dbus-damoen to be blocking.
+// call). To err on the safe side, we consider all libdbus functions that
+// deal with the connection to dbus-damoen to be blocking.
 //
 // EXAMPLE USAGE:
 //
 // Synchronous method call:
 //
 //   dbus::Bus::Options options;
 //   // Set up the bus options here.
 //   ...
 //   dbus::Bus bus(options);
 //
@@ skipping 87 matching lines @@
   };
 
   // Called when shutdown is done. Used for Shutdown().
   typedef base::Callback<void ()> OnShutdownCallback;
 
   // Creates a Bus object. The actual connection will be established when
   // Connect() is called.
   explicit Bus(const Options& options);
 
   // Gets the object proxy for the given service name and the object path.
-  // The caller must not delete the returned object. The bus will own the
-  // object. Never returns NULL.
+  // The caller must not delete the returned object.
+  //
+  // Returns an existing object proxy if the bus object already owns the
+  // object proxy for the given the service name and the object path.

[stevenjb, 2011/08/22 17:46:22]

s/the given the/the given/

[satorux1, 2011/08/22 19:01:58]

Done.

+  // Never returns NULL.
+  //
+  // The bus will own all object proxies created by the bus, to ensure
+  // that the object proxies are detached from remote objects at the
+  // 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);
 
   // Gets the exported object for the given service name and the object
-  // path. The caller must not delete the returned object. The bus will
-  // own the object. Never returns NULL.
+  // 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 the service name and the object path.

[stevenjb, 2011/08/22 17:46:22]

s/the given the/the given/

[satorux1, 2011/08/22 19:01:58]

Done.

+  // 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);
 
   // Shuts down the bus and blocks until it's done. More specifically, this
   // function does the following:
@@ skipping 216 matching lines @@
   base::PlatformThreadId origin_thread_id_;
   base::PlatformThreadId dbus_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<DBusHandleMessageFunction> filter_functions_added_;
 
-  std::vector<scoped_refptr<dbus::ObjectProxy> > object_proxies_;
-  std::vector<scoped_refptr<dbus::ExportedObject> > exported_objects_;
+  // ObjectProxyTable is used to hold the object proxies created by the
+  // bus object. Key is a pair of service name and object path.

[stevenjb, 2011/08/22 17:46:22]

nit: Does it make sense to concatnate service name + object path for the key
here to avoid the complexity of a pair as a key?

[satorux1, 2011/08/22 19:01:58]

Good point. I thought about it but didn't go with it for some reason. Now I
think concatenating them makes sense, as it wouldn't cause ambiguity. It would
look like:

org.chromium.TestService/org/chromium/TestObject

Changed the code accordingly.

+  typedef std::map<std::pair<std::string, std::string>,
+                   scoped_refptr<dbus::ObjectProxy> > ObjectProxyTable;
+  ObjectProxyTable object_proxy_table_;
+
+  // ExportedObjectTable is used to hold the exported objects created by
+  // the bus object. Key is a pair of service name and object path.
+  typedef std::map<std::pair<std::string, std::string>,
+                   scoped_refptr<dbus::ExportedObject> > ExportedObjectTable;
+  ExportedObjectTable exported_object_table_;
 
   bool async_operations_are_set_up_;
 
   // Counters to make sure that OnAddWatch()/OnRemoveWatch() and
   // OnAddTimeout()/OnRemoveTimeou() are balanced.
   int num_pending_watches_;
   int num_pending_timeouts_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_