2003-11-26 Mikael Hallendal <micke@imendio.com>

	* bus/*.[ch]:
	* dbus/*.[ch]:
	* glib/*.[ch]: Made ref functions return the pointer

34 files changed, 102 insertions, 43 deletions

diff --git a/dbus/dbus-auth.c b/dbus/dbus-auth.c
index cdfd3bb2..7c7befb1 100644
--- a/dbus/dbus-auth.c
+++ b/dbus/dbus-auth.c
@@ -1894,13 +1894,16 @@ _dbus_auth_client_new (void)
  * Increments the refcount of an auth object.
  *
  * @param auth the auth conversation
+ * @returns the auth conversation
  */
-void
+DBusAuth *
 _dbus_auth_ref (DBusAuth *auth)
 {
   _dbus_assert (auth != NULL);
   
   auth->refcount += 1;
+  
+  return auth;
 }
 
 /**
diff --git a/dbus/dbus-auth.h b/dbus/dbus-auth.h
index 98e4369d..48221ea0 100644
--- a/dbus/dbus-auth.h
+++ b/dbus/dbus-auth.h
@@ -44,7 +44,7 @@ typedef enum
 
 DBusAuth*     _dbus_auth_server_new          (void);
 DBusAuth*     _dbus_auth_client_new          (void);
-void          _dbus_auth_ref                 (DBusAuth               *auth);
+DBusAuth*     _dbus_auth_ref                 (DBusAuth               *auth);
 void          _dbus_auth_unref               (DBusAuth               *auth);
 dbus_bool_t   _dbus_auth_set_mechanisms      (DBusAuth               *auth,
                                               const char            **mechanisms);
diff --git a/dbus/dbus-connection-internal.h b/dbus/dbus-connection-internal.h
index e53908b5..6afd3301 100644
--- a/dbus/dbus-connection-internal.h
+++ b/dbus/dbus-connection-internal.h
@@ -46,7 +46,7 @@ typedef enum
 
 void              _dbus_connection_lock                        (DBusConnection     *connection);
 void              _dbus_connection_unlock                      (DBusConnection     *connection);
-void              _dbus_connection_ref_unlocked                (DBusConnection     *connection);
+DBusConnection *  _dbus_connection_ref_unlocked                (DBusConnection     *connection);
 void              _dbus_connection_unref_unlocked              (DBusConnection     *connection);
 dbus_bool_t       _dbus_connection_queue_received_message      (DBusConnection     *connection,
                                                                 DBusMessage        *message);
diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c
index 7871f922..01ebeb1c 100644
--- a/dbus/dbus-connection.c
+++ b/dbus/dbus-connection.c
@@ -219,11 +219,13 @@ static void               _dbus_connection_update_dispatch_status_and_unlock (DB
                                                                               DBusDispatchStatus  new_status);
 static void               _dbus_connection_last_unref                        (DBusConnection     *connection);
 
-static void
+static DBusMessageFilter *
 _dbus_message_filter_ref (DBusMessageFilter *filter)
 {
   _dbus_assert (filter->refcount.value > 0);
   _dbus_atomic_inc (&filter->refcount);
+
+  return filter;
 }
 
 static void
@@ -963,8 +965,9 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
  * Requires that the caller already holds the connection lock.
  *
  * @param connection the connection.
+ * @returns the connection.
  */
-void
+DBusConnection *
 _dbus_connection_ref_unlocked (DBusConnection *connection)
 {
 #ifdef DBUS_HAVE_ATOMIC_INT
@@ -973,6 +976,8 @@ _dbus_connection_ref_unlocked (DBusConnection *connection)
   _dbus_assert (connection->refcount.value > 0);
   connection->refcount.value += 1;
 #endif
+
+  return connection;
 }
 
 /**
@@ -1117,11 +1122,12 @@ dbus_connection_open (const char     *address,
  * Increments the reference count of a DBusConnection.
  *
  * @param connection the connection.
+ * @returns the connection.
  */
-void
+DBusConnection *
 dbus_connection_ref (DBusConnection *connection)
 {
-  _dbus_return_if_fail (connection != NULL);
+  _dbus_return_val_if_fail (connection != NULL, NULL);
 
   /* The connection lock is better than the global
    * lock in the atomic increment fallback
@@ -1136,6 +1142,8 @@ dbus_connection_ref (DBusConnection *connection)
   connection->refcount.value += 1;
   CONNECTION_UNLOCK (connection);
 #endif
+
+  return connection;
 }
 
 static void
diff --git a/dbus/dbus-connection.h b/dbus/dbus-connection.h
index aa92b30a..c2251c86 100644
--- a/dbus/dbus-connection.h
+++ b/dbus/dbus-connection.h
@@ -95,7 +95,7 @@ typedef DBusHandlerResult (* DBusHandleMessageFunction) (DBusConnection     *con
 
 DBusConnection*    dbus_connection_open                         (const char                 *address,
                                                                  DBusError                  *error);
-void               dbus_connection_ref                          (DBusConnection             *connection);
+DBusConnection*    dbus_connection_ref                          (DBusConnection             *connection);
 void               dbus_connection_unref                        (DBusConnection             *connection);
 void               dbus_connection_disconnect                   (DBusConnection             *connection);
 dbus_bool_t        dbus_connection_get_is_connected             (DBusConnection             *connection);
diff --git a/dbus/dbus-hash.c b/dbus/dbus-hash.c
index d35087b4..b0581510 100644
--- a/dbus/dbus-hash.c
+++ b/dbus/dbus-hash.c
@@ -348,11 +348,14 @@ _dbus_hash_table_new (DBusHashType     type,
  * Increments the reference count for a hash table.
  *
  * @param table the hash table to add a reference to.
+ * @returns the hash table.
  */
-void
+DBusHashTable *
 _dbus_hash_table_ref (DBusHashTable *table)
 {
   table->refcount += 1;
+  
+  return table;
 }
 
 /**
diff --git a/dbus/dbus-hash.h b/dbus/dbus-hash.h
index 5e7515f9..58fd5bf8 100644
--- a/dbus/dbus-hash.h
+++ b/dbus/dbus-hash.h
@@ -61,7 +61,7 @@ typedef enum
 DBusHashTable* _dbus_hash_table_new                (DBusHashType      type,
                                                     DBusFreeFunction  key_free_function,
                                                     DBusFreeFunction  value_free_function);
-void           _dbus_hash_table_ref                (DBusHashTable    *table);
+DBusHashTable* _dbus_hash_table_ref                (DBusHashTable    *table);
 void           _dbus_hash_table_unref              (DBusHashTable    *table);
 void           _dbus_hash_iter_init                (DBusHashTable    *table,
                                                     DBusHashIter     *iter);
diff --git a/dbus/dbus-keyring.c b/dbus/dbus-keyring.c
index e091d801..99de65cf 100644
--- a/dbus/dbus-keyring.c
+++ b/dbus/dbus-keyring.c
@@ -657,11 +657,14 @@ _dbus_keyring_reload (DBusKeyring *keyring,
  * Increments reference count of the keyring
  *
  * @param keyring the keyring
+ * @returns the keyring
  */
-void
+DBusKeyring *
 _dbus_keyring_ref (DBusKeyring *keyring)
 {
   keyring->refcount += 1;
+
+  return keyring;
 }
 
 /**
diff --git a/dbus/dbus-keyring.h b/dbus/dbus-keyring.h
index 2a450ec8..d4e2a57e 100644
--- a/dbus/dbus-keyring.h
+++ b/dbus/dbus-keyring.h
@@ -34,7 +34,7 @@ typedef struct DBusKeyring DBusKeyring;
 DBusKeyring* _dbus_keyring_new_homedir      (const DBusString  *username,
                                              const DBusString  *context,
                                              DBusError         *error);
-void         _dbus_keyring_ref              (DBusKeyring       *keyring);
+DBusKeyring* _dbus_keyring_ref              (DBusKeyring       *keyring);
 void         _dbus_keyring_unref            (DBusKeyring       *keyring);
 dbus_bool_t  _dbus_keyring_validate_context (const DBusString  *context);
 int          _dbus_keyring_get_best_key     (DBusKeyring       *keyring,
diff --git a/dbus/dbus-mainloop.c b/dbus/dbus-mainloop.c
index 6da5318c..dd0c015c 100644
--- a/dbus/dbus-mainloop.c
+++ b/dbus/dbus-mainloop.c
@@ -123,12 +123,14 @@ timeout_callback_new (DBusTimeout         *timeout,
   return cb;
 }
 
-static void
+static Callback * 
 callback_ref (Callback *cb)
 {
   _dbus_assert (cb->refcount > 0);
   
   cb->refcount += 1;
+
+  return cb;
 }
 
 static void
@@ -204,13 +206,15 @@ _dbus_loop_new (void)
   return loop;
 }
 
-void
+DBusLoop *
 _dbus_loop_ref (DBusLoop *loop)
 {
   _dbus_assert (loop != NULL);
   _dbus_assert (loop->refcount > 0);
 
   loop->refcount += 1;
+
+  return loop;
 }
 
 void
diff --git a/dbus/dbus-mainloop.h b/dbus/dbus-mainloop.h
index 8a3cde13..fadc5ad9 100644
--- a/dbus/dbus-mainloop.h
+++ b/dbus/dbus-mainloop.h
@@ -37,7 +37,7 @@ typedef void        (* DBusTimeoutFunction) (DBusTimeout   *timeout,
                                              void          *data);
 
 DBusLoop*   _dbus_loop_new            (void);
-void        _dbus_loop_ref            (DBusLoop            *loop);
+DBusLoop*   _dbus_loop_ref            (DBusLoop            *loop);
 void        _dbus_loop_unref          (DBusLoop            *loop);
 dbus_bool_t _dbus_loop_add_watch      (DBusLoop            *loop,
                                        DBusWatch           *watch,
diff --git a/dbus/dbus-message-handler.c b/dbus/dbus-message-handler.c
index f38e5100..89f180a4 100644
--- a/dbus/dbus-message-handler.c
+++ b/dbus/dbus-message-handler.c
@@ -189,13 +189,16 @@ dbus_message_handler_new (DBusHandleMessageFunction function,
  * Increments the reference count on a message handler.
  *
  * @param handler the handler
+ * @returns the handler
  */
-void
+DBusMessageHandler *
 dbus_message_handler_ref (DBusMessageHandler *handler)
 {
   _dbus_return_if_fail (handler != NULL);
 
   _dbus_atomic_inc (&handler->refcount);
+
+  return handler;
 }
 
 /**
diff --git a/dbus/dbus-message-handler.h b/dbus/dbus-message-handler.h
index dac015ac..ab6f0508 100644
--- a/dbus/dbus-message-handler.h
+++ b/dbus/dbus-message-handler.h
@@ -43,7 +43,7 @@ DBusMessageHandler* dbus_message_handler_new (DBusHandleMessageFunction  functio
                                               DBusFreeFunction           free_user_data);
 
 
-void         dbus_message_handler_ref   (DBusMessageHandler *handler);
+DBusMessageHandler* dbus_message_handler_ref   (DBusMessageHandler *handler);
 void         dbus_message_handler_unref (DBusMessageHandler *handler);
 
 
diff --git a/dbus/dbus-message-internal.h b/dbus/dbus-message-internal.h
index 53711f3d..26f1676b 100644
--- a/dbus/dbus-message-internal.h
+++ b/dbus/dbus-message-internal.h
@@ -48,7 +48,7 @@ void        _dbus_message_remove_size_counter   (DBusMessage  *message,
                                                  DBusList    **link_return);
 
 DBusMessageLoader* _dbus_message_loader_new                   (void);
-void               _dbus_message_loader_ref                   (DBusMessageLoader  *loader);
+DBusMessageLoader* _dbus_message_loader_ref                   (DBusMessageLoader  *loader);
 void               _dbus_message_loader_unref                 (DBusMessageLoader  *loader);
 
 void               _dbus_message_loader_get_buffer            (DBusMessageLoader  *loader,
diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
index 50f3107c..2e4ef0be 100644
--- a/dbus/dbus-message.c
+++ b/dbus/dbus-message.c
@@ -1504,17 +1504,20 @@ dbus_message_copy (const DBusMessage *message)
  * Increments the reference count of a DBusMessage.
  *
  * @param message The message
+ * @returns the message
  * @see dbus_message_unref
  */
-void
+DBusMessage *
 dbus_message_ref (DBusMessage *message)
 {
   dbus_int32_t old_refcount;
 
-  _dbus_return_if_fail (message != NULL);
+  _dbus_return_val_if_fail (message != NULL, NULL);
   
   old_refcount = _dbus_atomic_inc (&message->refcount);
   _dbus_assert (old_refcount >= 1);
+
+  return message;
 }
 
 static void
@@ -4781,11 +4784,14 @@ _dbus_message_loader_new (void)
  * Increments the reference count of the loader.
  *
  * @param loader the loader.
+ * @returns the loader
  */
-void
+DBusMessageLoader *
 _dbus_message_loader_ref (DBusMessageLoader *loader)
 {
   loader->refcount += 1;
+
+  return loader;
 }
 
 /**
diff --git a/dbus/dbus-message.h b/dbus/dbus-message.h
index 90865789..038fdc87 100644
--- a/dbus/dbus-message.h
+++ b/dbus/dbus-message.h
@@ -73,9 +73,9 @@ DBusMessage* dbus_message_new_error         (DBusMessage *reply_to,
                                              const char  *error_name,
                                              const char  *error_message);
 
-DBusMessage *dbus_message_copy              (const DBusMessage *message);
+DBusMessage* dbus_message_copy              (const DBusMessage *message);
 
-void          dbus_message_ref              (DBusMessage   *message);
+DBusMessage*  dbus_message_ref              (DBusMessage   *message);
 void          dbus_message_unref            (DBusMessage   *message);
 int           dbus_message_get_type         (DBusMessage   *message);
 dbus_bool_t   dbus_message_set_path         (DBusMessage   *message,
diff --git a/dbus/dbus-object-tree.c b/dbus/dbus-object-tree.c
index 07d3ae59..09049195 100644
--- a/dbus/dbus-object-tree.c
+++ b/dbus/dbus-object-tree.c
@@ -46,7 +46,7 @@ typedef struct DBusObjectSubtree DBusObjectSubtree;
 static DBusObjectSubtree* _dbus_object_subtree_new   (const char                  *name,
                                                       const DBusObjectPathVTable  *vtable,
                                                       void                        *user_data);
-static void               _dbus_object_subtree_ref   (DBusObjectSubtree           *subtree);
+static DBusObjectSubtree* _dbus_object_subtree_ref   (DBusObjectSubtree           *subtree);
 static void               _dbus_object_subtree_unref (DBusObjectSubtree           *subtree);
 
 /**
@@ -121,13 +121,16 @@ _dbus_object_tree_new (DBusConnection *connection)
 /**
  * Increment the reference count
  * @param tree the object tree
+ * @returns the object tree
  */
-void
+DBusObjectTree *
 _dbus_object_tree_ref (DBusObjectTree *tree)
 {
   _dbus_assert (tree->refcount > 0);
 
   tree->refcount += 1;
+
+  return tree;
 }
 
 /**
@@ -859,11 +862,13 @@ _dbus_object_subtree_new (const char                  *name,
   return NULL;
 }
 
-static void
+static DBusObjectSubtree *
 _dbus_object_subtree_ref (DBusObjectSubtree *subtree)
 {
   _dbus_assert (subtree->refcount.value > 0);
   _dbus_atomic_inc (&subtree->refcount);
+
+  return subtree;
 }
 
 static void
diff --git a/dbus/dbus-object-tree.h b/dbus/dbus-object-tree.h
index bf34d972..09e4ee29 100644
--- a/dbus/dbus-object-tree.h
+++ b/dbus/dbus-object-tree.h
@@ -30,7 +30,7 @@ DBUS_BEGIN_DECLS;
 typedef struct DBusObjectTree DBusObjectTree;
 
 DBusObjectTree* _dbus_object_tree_new   (DBusConnection *connection);
-void            _dbus_object_tree_ref   (DBusObjectTree *tree);
+DBusObjectTree* _dbus_object_tree_ref   (DBusObjectTree *tree);
 void            _dbus_object_tree_unref (DBusObjectTree *tree);
 
 dbus_bool_t       _dbus_object_tree_register              (DBusObjectTree              *tree,
diff --git a/dbus/dbus-pending-call.c b/dbus/dbus-pending-call.c
index 590f1296..a19ed8b9 100644
--- a/dbus/dbus-pending-call.c
+++ b/dbus/dbus-pending-call.c
@@ -138,13 +138,16 @@ _dbus_pending_call_notify (DBusPendingCall *pending)
  * Increments the reference count on a pending call.
  *
  * @param pending the pending call object
+ * @returns the pending call object
  */
-void
+DBusPendingCall *
 dbus_pending_call_ref (DBusPendingCall *pending)
 {
   _dbus_return_if_fail (pending != NULL);
 
   _dbus_atomic_inc (&pending->refcount);
+
+  return pending;
 }
 
 /**
diff --git a/dbus/dbus-pending-call.h b/dbus/dbus-pending-call.h
index 4f1e92c0..3ea1486e 100644
--- a/dbus/dbus-pending-call.h
+++ b/dbus/dbus-pending-call.h
@@ -33,7 +33,7 @@
 
 DBUS_BEGIN_DECLS;
 
-void         dbus_pending_call_ref           (DBusPendingCall               *pending);
+DBusPendingCall* dbus_pending_call_ref       (DBusPendingCall               *pending);
 void         dbus_pending_call_unref         (DBusPendingCall               *pending);
 dbus_bool_t  dbus_pending_call_set_notify    (DBusPendingCall               *pending,
                                               DBusPendingCallNotifyFunction  function,
diff --git a/dbus/dbus-resources.c b/dbus/dbus-resources.c
index edc2e788..a5a8e099 100644
--- a/dbus/dbus-resources.c
+++ b/dbus/dbus-resources.c
@@ -96,13 +96,16 @@ _dbus_counter_new (void)
  * Increments refcount of the counter
  *
  * @param counter the counter
+ * @returns the counter
  */
-void
+DBusCounter *
 _dbus_counter_ref (DBusCounter *counter)
 {
   _dbus_assert (counter->refcount > 0);
   
   counter->refcount += 1;
+
+  return counter;
 }
 
 /**
diff --git a/dbus/dbus-resources.h b/dbus/dbus-resources.h
index 26a5b98c..2975405a 100644
--- a/dbus/dbus-resources.h
+++ b/dbus/dbus-resources.h
@@ -35,7 +35,7 @@ typedef void (* DBusCounterNotifyFunction) (DBusCounter *counter,
                                             void        *user_data);
 
 DBusCounter* _dbus_counter_new       (void);
-void         _dbus_counter_ref       (DBusCounter *counter);
+DBusCounter* _dbus_counter_ref       (DBusCounter *counter);
 void         _dbus_counter_unref     (DBusCounter *counter);
 void         _dbus_counter_adjust    (DBusCounter *counter,
                                       long         delta);
diff --git a/dbus/dbus-server.c b/dbus/dbus-server.c
index 29e20a55..2e33cac6 100644
--- a/dbus/dbus-server.c
+++ b/dbus/dbus-server.c
@@ -450,13 +450,16 @@ dbus_server_listen (const char     *address,
  * Increments the reference count of a DBusServer.
  *
  * @param server the server.
+ * @returns the server
  */
-void
+DBusServer *
 dbus_server_ref (DBusServer *server)
 {
   _dbus_return_if_fail (server != NULL);
   
   server->refcount += 1;
+
+  return server;
 }
 
 /**
diff --git a/dbus/dbus-server.h b/dbus/dbus-server.h
index c2a0ca0f..237e9500 100644
--- a/dbus/dbus-server.h
+++ b/dbus/dbus-server.h
@@ -41,7 +41,7 @@ typedef void (* DBusNewConnectionFunction) (DBusServer     *server,
 
 DBusServer* dbus_server_listen           (const char     *address,
                                           DBusError      *error);
-void        dbus_server_ref              (DBusServer     *server);
+DBusServer* dbus_server_ref              (DBusServer     *server);
 void        dbus_server_unref            (DBusServer     *server);
 void        dbus_server_disconnect       (DBusServer     *server);
 dbus_bool_t dbus_server_get_is_connected (DBusServer     *server);
diff --git a/dbus/dbus-spawn.c b/dbus/dbus-spawn.c
index 604b9e7c..0e62f951 100644
--- a/dbus/dbus-spawn.c
+++ b/dbus/dbus-spawn.c
@@ -235,14 +235,17 @@ _dbus_babysitter_new (void)
  * Increment the reference count on the babysitter object.
  *
  * @param sitter the babysitter
+ * @returns the babysitter
  */
-void
+DBusBabysitter *
 _dbus_babysitter_ref (DBusBabysitter *sitter)
 {
   _dbus_assert (sitter != NULL);
   _dbus_assert (sitter->refcount > 0);
   
   sitter->refcount += 1;
+
+  return sitter;
 }
 
 /**
diff --git a/dbus/dbus-spawn.h b/dbus/dbus-spawn.h
index a467beec..9771144d 100644
--- a/dbus/dbus-spawn.h
+++ b/dbus/dbus-spawn.h
@@ -40,7 +40,7 @@ dbus_bool_t _dbus_spawn_async_with_babysitter     (DBusBabysitter           **si
                                                    DBusSpawnChildSetupFunc    child_setup,
                                                    void                      *user_data,
                                                    DBusError                 *error);
-void        _dbus_babysitter_ref                  (DBusBabysitter            *sitter);
+DBusBabysitter* _dbus_babysitter_ref              (DBusBabysitter            *sitter);
 void        _dbus_babysitter_unref                (DBusBabysitter            *sitter);
 void        _dbus_babysitter_kill_child           (DBusBabysitter            *sitter);
 dbus_bool_t _dbus_babysitter_get_child_exited     (DBusBabysitter            *sitter);
diff --git a/dbus/dbus-timeout.c b/dbus/dbus-timeout.c
index b15089db..bd740963 100644
--- a/dbus/dbus-timeout.c
+++ b/dbus/dbus-timeout.c
@@ -86,11 +86,14 @@ _dbus_timeout_new (int                 interval,
  * Increments the reference count of a DBusTimeout object.
  *
  * @param timeout the timeout object.
+ * @returns the timeout object.
  */
-void
+DBusTimeout *
 _dbus_timeout_ref (DBusTimeout *timeout)
 {
   timeout->refcount += 1;
+
+  return timeout;
 }
 
 /**
diff --git a/dbus/dbus-timeout.h b/dbus/dbus-timeout.h
index c68f29fa..3950257c 100644
--- a/dbus/dbus-timeout.h
+++ b/dbus/dbus-timeout.h
@@ -38,7 +38,7 @@ DBusTimeout* _dbus_timeout_new          (int                 interval,
                                          DBusTimeoutHandler  handler,
                                          void               *data,
                                          DBusFreeFunction    free_data_function);
-void         _dbus_timeout_ref          (DBusTimeout        *timeout);
+DBusTimeout* _dbus_timeout_ref          (DBusTimeout        *timeout);
 void         _dbus_timeout_unref        (DBusTimeout        *timeout);
 void         _dbus_timeout_set_interval (DBusTimeout        *timeout,
                                          int                 interval);
diff --git a/dbus/dbus-transport.c b/dbus/dbus-transport.c
index b58073f6..40fc98d0 100644
--- a/dbus/dbus-transport.c
+++ b/dbus/dbus-transport.c
@@ -365,13 +365,16 @@ _dbus_transport_open (const char     *address,
  * Increments the reference count for the transport.
  *
  * @param transport the transport.
+ * @returns the transport.
  */
-void
+DBusTransport *
 _dbus_transport_ref (DBusTransport *transport)
 {
   _dbus_assert (transport->refcount > 0);
   
   transport->refcount += 1;
+
+  return transport;
 }
 
 /**
diff --git a/dbus/dbus-transport.h b/dbus/dbus-transport.h
index eadee383..6b1f4b76 100644
--- a/dbus/dbus-transport.h
+++ b/dbus/dbus-transport.h
@@ -32,7 +32,7 @@ typedef struct DBusTransport DBusTransport;
 
 DBusTransport*     _dbus_transport_open                   (const char                 *address,
                                                            DBusError                  *error);
-void               _dbus_transport_ref                    (DBusTransport              *transport);
+DBusTransport*     _dbus_transport_ref                    (DBusTransport              *transport);
 void               _dbus_transport_unref                  (DBusTransport              *transport);
 void               _dbus_transport_disconnect             (DBusTransport              *transport);
 dbus_bool_t        _dbus_transport_get_is_connected       (DBusTransport              *transport);
diff --git a/dbus/dbus-userdb.c b/dbus/dbus-userdb.c
index 95f13981..13502306 100644
--- a/dbus/dbus-userdb.c
+++ b/dbus/dbus-userdb.c
@@ -635,13 +635,16 @@ _dbus_user_database_new (void)
 /**
  * Increments refcount of user database.
  * @param db the database
+ * @returns the database
  */
-void
+DBusUserDatabase *
 _dbus_user_database_ref (DBusUserDatabase  *db)
 {
   _dbus_assert (db->refcount > 0);
 
   db->refcount += 1;
+
+  return db;
 }
 
 /**
diff --git a/dbus/dbus-userdb.h b/dbus/dbus-userdb.h
index e277979e..90807478 100644
--- a/dbus/dbus-userdb.h
+++ b/dbus/dbus-userdb.h
@@ -31,7 +31,7 @@ DBUS_BEGIN_DECLS;
 typedef struct DBusUserDatabase DBusUserDatabase;
 
 DBusUserDatabase* _dbus_user_database_new           (void);
-void              _dbus_user_database_ref           (DBusUserDatabase     *db);
+DBusUserDatabase* _dbus_user_database_ref           (DBusUserDatabase     *db);
 void              _dbus_user_database_unref         (DBusUserDatabase     *db);
 dbus_bool_t       _dbus_user_database_get_groups    (DBusUserDatabase     *db,
                                                      dbus_uid_t            uid,
diff --git a/dbus/dbus-watch.c b/dbus/dbus-watch.c
index f212090a..7171dd6d 100644
--- a/dbus/dbus-watch.c
+++ b/dbus/dbus-watch.c
@@ -97,11 +97,14 @@ _dbus_watch_new (int               fd,
  * Increments the reference count of a DBusWatch object.
  *
  * @param watch the watch object.
+ * @returns the watch object.
  */
-void
+DBusWatch *
 _dbus_watch_ref (DBusWatch *watch)
 {
   watch->refcount += 1;
+
+  return watch;
 }
 
 /**
diff --git a/dbus/dbus-watch.h b/dbus/dbus-watch.h
index 355a9b7e..bea4d59f 100644
--- a/dbus/dbus-watch.h
+++ b/dbus/dbus-watch.h
@@ -42,7 +42,7 @@ DBusWatch* _dbus_watch_new                (int               fd,
                                            DBusWatchHandler  handler,
                                            void             *data,
                                            DBusFreeFunction  free_data_function);
-void       _dbus_watch_ref                (DBusWatch        *watch);
+DBusWatch* _dbus_watch_ref                (DBusWatch        *watch);
 void       _dbus_watch_unref              (DBusWatch        *watch);
 void       _dbus_watch_invalidate         (DBusWatch        *watch);
 void       _dbus_watch_sanitize_condition (DBusWatch        *watch,