Change subsession API argument name (from cb_data to user_data)

Change-Id: I58969118f4a0412ef781d1c277ca222e70b02723
Signed-off-by: Hyotaek Shim <hyotaek.shim@samsung.com>

diff --git a/clientExample/app/main.cpp b/clientExample/app/main.cpp
index 97b9428..cfcbc16 100644 (file)
--- a/clientExample/app/main.cpp
+++ b/clientExample/app/main.cpp
@@ -50,15 +50,15 @@ void green_print(const char *str)
        printf("\033[0;32m%s\033[0;37m\n", str);
 }
 
-void test_subsession_switch_user_completion_callback(subsession_event_info info, void *cb_data)
+void test_subsession_switch_user_completion_callback(subsession_event_info info, void *user_data)
 {
        g_atomic_int_inc(&callbackCount);
-       test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
-       user_data->session_uid = info.session_uid;
-       user_data->switch_id = info.switch_user.switch_id;
-       memcpy(user_data->user_id, info.switch_user.next_user, SUBSESSION_USER_MAXLEN);
-       memcpy(user_data->prev_user_id, info.switch_user.prev_user, SUBSESSION_USER_MAXLEN);
-       user_data->callback_result = 0;
+       test_user_data_cb_t *udata = (test_user_data_cb_t *)user_data;
+       udata->session_uid = info.session_uid;
+       udata->switch_id = info.switch_user.switch_id;
+       memcpy(udata->user_id, info.switch_user.next_user, SUBSESSION_USER_MAXLEN);
+       memcpy(udata->prev_user_id, info.switch_user.prev_user, SUBSESSION_USER_MAXLEN);
+       udata->callback_result = 0;
 }
 
 gboolean callback_pending(gpointer data)
@@ -89,9 +89,9 @@ gboolean callback_pending(gpointer data)
        return TRUE;
 }
 
-void test_reply_adduser_callback(int result, void *cb_data)
+void test_reply_adduser_callback(int result, void *user_data)
 {
-       assert(cb_data);
+       assert(user_data);
 
        /* Use a conditional variable (with the associated mutex)
         * to make calls synchronous. This is just for example purposes,
@@ -100,20 +100,20 @@ void test_reply_adduser_callback(int result, void *cb_data)
        g_mutex_lock(&mutex);
        g_atomic_int_inc(&callback_pending_reference);
 
-       test_user_data *user_data = (test_user_data *)cb_data;
+       test_user_data *udata = (test_user_data *)user_data;
 
        /* We set the value below ourselves. Arbitrary metadata
         * can be passed to and from the callback. */
-       assert(user_data->callback_result == CALLBACK_DATA_MAGIC);
-       user_data->callback_result = result;
+       assert(udata->callback_result == CALLBACK_DATA_MAGIC);
+       udata->callback_result = result;
 
        g_cond_signal(&cond);
        g_mutex_unlock(&mutex);
 }
 
-void test_reply_removeuser_callback(int result, void *cb_data)
+void test_reply_removeuser_callback(int result, void *user_data)
 {
-       assert(cb_data);
+       assert(user_data);
 
        /* NB: no conditional vars here. The callback is ran
         * asynchronously via the main loop. See below,
@@ -126,18 +126,18 @@ void test_reply_removeuser_callback(int result, void *cb_data)
 
        g_atomic_int_inc(&callback_pending_reference);
 
-       test_user_data *user_data = (test_user_data *)cb_data;
-       user_data->callback_result = result;
+       test_user_data *udata = (test_user_data *)user_data;
+       udata->callback_result = result;
 }
 
-void test_reply_switchuser_callback(int result, void *cb_data)
+void test_reply_switchuser_callback(int result, void *user_data)
 {
        g_mutex_lock(&mutex);
 
        g_atomic_int_inc(&callback_pending_reference);
 
-       test_user_data *user_data = (test_user_data *)cb_data;
-       user_data->callback_result = result;
+       test_user_data *udata = (test_user_data *)user_data;
+       udata->callback_result = result;
 
        g_cond_signal(&cond);
        g_mutex_unlock(&mutex);

diff --git a/libsessiond/include/sessiond.h b/libsessiond/include/sessiond.h
index 4114cf7..2863279 100644 (file)
--- a/libsessiond/include/sessiond.h
+++ b/libsessiond/include/sessiond.h
@@ -88,10 +88,10 @@ typedef struct subsession_event_info {
  *  #SUBSESSION_ERROR_IO_ERROR Internal error occurred \n
  *  #SUBSESSION_ERROR_PERMISSION_DENIED Not permitted \n
  *  #SUBSESSION_ERROR_NOT_SUPPORTED Not supported
- * @param[in] cb_data The user data passed from the callback registration function
+ * @param[in] user_data The user data passed from the callback registration function
  * @remarks Callback will be called only when operation succeeds.
  */
-typedef void (*subsession_reply_callback) (int result, void *cb_data);
+typedef void (*subsession_reply_callback) (int result, void *user_data);
 
 /**
  * @brief Request new subsession to be created.
@@ -100,7 +100,7 @@ typedef void (*subsession_reply_callback) (int result, void *cb_data);
  * @param[in] session_uid User ID of the session
  * @param[in] user Subsession user name to be created
  * @param[in] cb Callback to be called when operation completes or error is reported
- * @param[in] cb_data User defined data
+ * @param[in] user_data User defined data
  *
  * @return 0 on success, otherwise a negative error value
  * @retval #SUBSESSION_ERROR_NONE Success
@@ -109,7 +109,7 @@ typedef void (*subsession_reply_callback) (int result, void *cb_data);
  * @remarks Use `subsession_get_user_list()` to list currently used session IDs.
  *  Subsession ID must not start with a dot or have slashes.
  */
-int subsession_add_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data);
+int subsession_add_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *user_data);
 
 /**
  * @brief Request existing subsession to be removed.
@@ -118,7 +118,7 @@ int subsession_add_user(int session_uid, const subsession_user_t user, subsessio
  * @param[in] session_uid User ID of the session
  * @param[in] user Subsession user name to be removed
  * @param[in] cb Callback to be called when operation completes or error is reported
- * @param[in] cb_data User defined data
+ * @param[in] user_data User defined data
  *
  * @return 0 on success, otherwise a negative error value
  * @retval #SUBSESSION_ERROR_NONE Success
@@ -129,7 +129,7 @@ int subsession_add_user(int session_uid, const subsession_user_t user, subsessio
  * In order remove currently used session ID first switch to special session ID "" (empty string),
  * and only after switch completes, remove previously active session ID.
  */
-int subsession_remove_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data);
+int subsession_remove_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *user_data);
 
 /**
  * @brief Switch subsession.
@@ -138,7 +138,7 @@ int subsession_remove_user(int session_uid, const subsession_user_t user, subses
  * @param[in] session_uid User ID of the session
  * @param[in] next_user Target subsession user name to be switched to
  * @param[in] cb Callback to be called when operation completes or error is reported
- * @param[in] cb_data User defined data
+ * @param[in] user_data User defined data
  *
  * @return 0 on success, otherwise a negative error value
  * @retval #SUBSESSION_ERROR_NONE Success
@@ -148,7 +148,7 @@ int subsession_remove_user(int session_uid, const subsession_user_t user, subses
  * Special subsession ID "" (empty string) can be switched to, when it's required to deactivate
  * current subsession (this step is needed when current session is to be removed).
  */
-int subsession_switch_user(int session_uid, const subsession_user_t next_user, subsession_reply_callback cb, void *cb_data);
+int subsession_switch_user(int session_uid, const subsession_user_t next_user, subsession_reply_callback cb, void *user_data);
 
 /**
  * @brief Get list of all available subsessions for given session ID
@@ -209,9 +209,9 @@ int subsession_get_current_user(int session_uid, subsession_user_t user);
  * @since_tizen 7.0
  *
  * @param[in] info Information associated with the event itself
- * @param[in] cb_data The user data passed from the callback registration function
+ * @param[in] user_data The user data passed from the callback registration function
  */
-typedef void (*subsession_event_callback) (subsession_event_info info, void *cb_data);
+typedef void (*subsession_event_callback) (subsession_event_info info, void *user_data);
 
 /**
  * @brief Register the event "wait lock"
@@ -220,7 +220,7 @@ typedef void (*subsession_event_callback) (subsession_event_info info, void *cb_
  * @param[in] session_uid User ID of the session
  * @param[in] event_bits Events to register for
  * @param[in] cb Callback which will handle requested events
- * @param[in] cb_data User defined data
+ * @param[in] user_data User defined data
  * @remarks Client can register "wait lock" only for its own process.
  *
  * @return 0 on success, otherwise a negative error value
@@ -230,7 +230,7 @@ typedef void (*subsession_event_callback) (subsession_event_info info, void *cb_
  * @retval #SUBSESSION_ERROR_PERMISSION_DENIED Not permitted
  * @retval #SUBSESSION_ERROR_NOT_SUPPORTED Not supported
  */
-int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *cb_data);
+int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *user_data);
 
 /**
  * @brief Unregister the event "wait lock"

diff --git a/libsessiond/src/lib.c b/libsessiond/src/lib.c
index b0027b9..87d9cf8 100644 (file)
--- a/libsessiond/src/lib.c
+++ b/libsessiond/src/lib.c
@@ -587,7 +587,7 @@ static void async_method_reply_handler(GObject *source_obj, GAsyncResult *res, g
        reply_info->reply_callback(s_err, reply_info->reply_data);
 }
 
-static int method_call_async(gchar *method, GVariant *params, subsession_reply_callback cb, void *cb_data)
+static int method_call_async(gchar *method, GVariant *params, subsession_reply_callback cb, void *user_data)
 {
        assert(method);
 
@@ -602,7 +602,7 @@ static int method_call_async(gchar *method, GVariant *params, subsession_reply_c
                if (!reply_info)
                        return SUBSESSION_ERROR_OUT_OF_MEMORY;
                reply_info->reply_callback = cb;
-               reply_info->reply_data = cb_data;
+               reply_info->reply_data = user_data;
        }
 
        g_dbus_connection_call(
@@ -620,37 +620,37 @@ static int method_call_async(gchar *method, GVariant *params, subsession_reply_c
        return SUBSESSION_ERROR_NONE;
 }
 
-EXPORT_API int subsession_add_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data)
+EXPORT_API int subsession_add_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *user_data)
 {
        return_if(
                session_uid_is_not_valid(session_uid,
                user_id_is_not_valid(user))
        )
 
-       return_with_log_error_result_(method_call_async(dbus_method_call.AddUser, g_variant_new("(is)", session_uid, user), cb, cb_data))
+       return_with_log_error_result_(method_call_async(dbus_method_call.AddUser, g_variant_new("(is)", session_uid, user), cb, user_data))
 }
 
-EXPORT_API int subsession_remove_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data)
+EXPORT_API int subsession_remove_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *user_data)
 {
        return_if(
                session_uid_is_not_valid(session_uid,
                user_id_is_not_valid(user))
        )
 
-       return_with_log_error_result_(method_call_async(dbus_method_call.RemoveUser, g_variant_new("(is)", session_uid, user), cb, cb_data))
+       return_with_log_error_result_(method_call_async(dbus_method_call.RemoveUser, g_variant_new("(is)", session_uid, user), cb, user_data))
 }
 
-EXPORT_API int subsession_switch_user(int session_uid, const subsession_user_t next_user, subsession_reply_callback cb, void *cb_data)
+EXPORT_API int subsession_switch_user(int session_uid, const subsession_user_t next_user, subsession_reply_callback cb, void *user_data)
 {
        return_if(
                switched_user_is_not_valid(next_user,
                session_uid_is_not_valid(session_uid))
        )
 
-       return_with_log_error_result_(method_call_async(dbus_method_call.SwitchUser, g_variant_new("(is)", session_uid, next_user), cb, cb_data))
+       return_with_log_error_result_(method_call_async(dbus_method_call.SwitchUser, g_variant_new("(is)", session_uid, next_user), cb, user_data))
 }
 
-static int callbacks_data_push(client_callbacks_data_t *callbacks_data, GVariant *params, subsession_event_callback cb, void *cb_data, signal_client_data_t **client_data)
+static int callbacks_data_push(client_callbacks_data_t *callbacks_data, GVariant *params, subsession_event_callback cb, void *user_data, signal_client_data_t **client_data)
 {
        assert(callbacks_data);
        assert(client_data);
@@ -665,7 +665,7 @@ static int callbacks_data_push(client_callbacks_data_t *callbacks_data, GVariant
                }
        }
 
-       signal_client_data_t *signal_client_data = signal_client_data_new(cb, cb_data, params);
+       signal_client_data_t *signal_client_data = signal_client_data_new(cb, user_data, params);
        if (signal_client_data == NULL) {
                g_mutex_unlock(&callbacks_data->mutex);
                return SUBSESSION_ERROR_OUT_OF_MEMORY;
@@ -678,7 +678,7 @@ static int callbacks_data_push(client_callbacks_data_t *callbacks_data, GVariant
        return SUBSESSION_ERROR_NONE;
 }
 
-static int register_event_callback(client_callbacks_data_t *callbacks_data, GDBusSignalCallback signal_callback, int session_uid, subsession_event_callback cb, void *cb_data)
+static int register_event_callback(client_callbacks_data_t *callbacks_data, GDBusSignalCallback signal_callback, int session_uid, subsession_event_callback cb, void *user_data)
 {
        assert(callbacks_data);
        assert(signal_callback);
@@ -695,7 +695,7 @@ static int register_event_callback(client_callbacks_data_t *callbacks_data, GDBu
        MAKE_SURE_CONNECTION_IS_NOT_NULL();
 
        signal_client_data_t *client_data = NULL;
-       int ret = callbacks_data_push(callbacks_data, params, cb, cb_data, &client_data);
+       int ret = callbacks_data_push(callbacks_data, params, cb, user_data, &client_data);
        if (ret != SUBSESSION_ERROR_NONE) {
                return_with_log_error_result_(ret);
        }
@@ -726,19 +726,19 @@ static int register_event_callback(client_callbacks_data_t *callbacks_data, GDBu
        return ret;
 }
 
-EXPORT_API int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *cb_data) {
+EXPORT_API int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *user_data) {
 
        if (event_bits & SUBSESSION_ADD_USER_WAIT) {
-               ret_if_err_(register_event_callback(&add_user_wait_callbacks_data_mt, signal_add_user_started_handler, session_uid, cb, cb_data))
+               ret_if_err_(register_event_callback(&add_user_wait_callbacks_data_mt, signal_add_user_started_handler, session_uid, cb, user_data))
        }
        if (event_bits & SUBSESSION_REMOVE_USER_WAIT) {
-               ret_if_err_(register_event_callback(&remove_user_wait_callbacks_data_mt, signal_remove_user_started_handler, session_uid, cb, cb_data))
+               ret_if_err_(register_event_callback(&remove_user_wait_callbacks_data_mt, signal_remove_user_started_handler, session_uid, cb, user_data))
        }
        if (event_bits & SUBSESSION_SWITCH_USER_WAIT) {
-               ret_if_err_(register_event_callback(&switch_user_wait_callbacks_data_mt, signal_switch_user_started_handler, session_uid, cb, cb_data))
+               ret_if_err_(register_event_callback(&switch_user_wait_callbacks_data_mt, signal_switch_user_started_handler, session_uid, cb, user_data))
        }
        if (event_bits & SUBSESSION_SWITCH_USER_COMPLETION) {
-               ret_if_err_(register_event_callback(&switch_user_completion_callbacks_data_mt, signal_switch_user_completion_handler, session_uid, cb, cb_data))
+               ret_if_err_(register_event_callback(&switch_user_completion_callbacks_data_mt, signal_switch_user_completion_handler, session_uid, cb, user_data))
        }
        return SUBSESSION_ERROR_NONE;
 }

diff --git a/libsessiond/target_test/test_hlp.hpp b/libsessiond/target_test/test_hlp.hpp
index 8c8b9b3..23b7e1b 100644 (file)
--- a/libsessiond/target_test/test_hlp.hpp
+++ b/libsessiond/target_test/test_hlp.hpp
@@ -197,84 +197,84 @@ void atomic_set_0(T arg, V... args) {
 /* Magic constants set by various callbacks
  * to verify whether they were called. */
 
-void test_reply_callback_default (int result, void *cb_data) {
+void test_reply_callback_default (int result, void *user_data) {
 
        //std::cout << "call callback default" << std::endl;
-       test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
+       test_user_data_cb_t *udata = (test_user_data_cb_t *)user_data;
 
-       user_data->callback_result = result;
+       udata->callback_result = result;
 
-       //std::cout << "call_callback_default for magic: " << user_data->magic << " get ref :" << g_atomic_int_get(&user_data->callback_reference) <<std::endl;
-       g_atomic_int_inc(&user_data->callback_reference);
+       //std::cout << "call_callback_default for magic: " << udata->magic << " get ref :" << g_atomic_int_get(&udata->callback_reference) <<std::endl;
+       g_atomic_int_inc(&udata->callback_reference);
 }
 
-void test_event_add_user_callback(subsession_event_info info, void *cb_data) {
+void test_event_add_user_callback(subsession_event_info info, void *user_data) {
 
-       test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
+       test_user_data_cb_t *udata = (test_user_data_cb_t *)user_data;
 
-       if (cb_data == NULL) {
+       if (user_data == NULL) {
                std::cout << "test_event_add_user_callback == null";
                return;
        }
 
-       user_data->session_uid = info.session_uid;
-       //std::cout << "on callback: user_data->session_uid: " << user_data->session_uid << std::endl;
-       user_data->event = info.event;
-       //std::cout << "on callback: user_data->event: " << user_data->event << std::endl;
-       user_data->user_id = info.add_user.user;
-       //std::cout << "on callback:user_data->user_id: " << user_data->user_id << std::endl;
+       udata->session_uid = info.session_uid;
+       //std::cout << "on callback: udata->session_uid: " << udata->session_uid << std::endl;
+       udata->event = info.event;
+       //std::cout << "on callback: udata->event: " << udata->event << std::endl;
+       udata->user_id = info.add_user.user;
+       //std::cout << "on callback:udata->user_id: " << udata->user_id << std::endl;
        //std::cout << "go to  subsession_event_wait_done(info)" << std::endl;
-       user_data->callback_result = subsession_event_wait_done(info);
-       //std::cout << "on callback: user_data->callback_result: " << user_data->callback_result << std::endl;
-       g_atomic_int_inc(&user_data->callback_reference);
+       udata->callback_result = subsession_event_wait_done(info);
+       //std::cout << "on callback: udata->callback_result: " << udata->callback_result << std::endl;
+       g_atomic_int_inc(&udata->callback_reference);
 }
 
 
-void test_event_remove_user_callback(subsession_event_info info, void *cb_data) {
+void test_event_remove_user_callback(subsession_event_info info, void *user_data) {
 
-       test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
+       test_user_data_cb_t *udata = (test_user_data_cb_t *)user_data;
 
-       if (cb_data == NULL)
+       if (user_data == NULL)
                return;
 
-       user_data->session_uid = info.session_uid;
-       user_data->event = info.event;
-       user_data->user_id = info.remove_user.user;
+       udata->session_uid = info.session_uid;
+       udata->event = info.event;
+       udata->user_id = info.remove_user.user;
 
-       user_data->callback_result = subsession_event_wait_done(info);
-       g_atomic_int_inc(&user_data->callback_reference);
+       udata->callback_result = subsession_event_wait_done(info);
+       g_atomic_int_inc(&udata->callback_reference);
 }
 
-void test_event_switch_user_callback(subsession_event_info info, void *cb_data) {
+void test_event_switch_user_callback(subsession_event_info info, void *user_data) {
 
-       test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
+       test_user_data_cb_t *udata = (test_user_data_cb_t *)user_data;
 
-       if (cb_data == NULL)
+       if (user_data == NULL)
                return;
 
-       user_data->session_uid = info.session_uid;
-       user_data->event = info.event;
-       user_data->user_id = info.switch_user.next_user;
-       user_data->switch_id = info.switch_user.switch_id;
+       udata->session_uid = info.session_uid;
+       udata->event = info.event;
+       udata->user_id = info.switch_user.next_user;
+       udata->switch_id = info.switch_user.switch_id;
 
-       user_data->callback_result = subsession_event_wait_done(info);
-       g_atomic_int_inc(&user_data->callback_reference);
+       udata->callback_result = subsession_event_wait_done(info);
+       g_atomic_int_inc(&udata->callback_reference);
 }
 
 
-void test_event_switch_user_completion_callback(subsession_event_info info, void *cb_data) {
+void test_event_switch_user_completion_callback(subsession_event_info info, void *user_data) {
 
-       test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
+       test_user_data_cb_t *udata = (test_user_data_cb_t *)user_data;
 
-       if (cb_data == NULL)
+       if (user_data == NULL)
                return;
 
-       user_data->session_uid = info.session_uid;
-       user_data->event = info.event;
-       user_data->user_id = info.switch_user.next_user;
-       user_data->switch_id = info.switch_user.switch_id;
-       user_data->callback_result = SUBSESSION_ERROR_NONE;
-       g_atomic_int_inc(&user_data->callback_reference);
+       udata->session_uid = info.session_uid;
+       udata->event = info.event;
+       udata->user_id = info.switch_user.next_user;
+       udata->switch_id = info.switch_user.switch_id;
+       udata->callback_result = SUBSESSION_ERROR_NONE;
+       g_atomic_int_inc(&udata->callback_reference);
 }