webrtc/webrtc_websocket: Apply g_mutex_locker_new()

Unused macros are removed

[Version] 0.2.75
[Issue Type] Refactoring

Change-Id: Icba100fdca5d5f8a92bd25bd7cfab4a8eb31fc88
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/include/webrtc_private.h b/include/webrtc_private.h
index ba3be081ed856d570909c8057df93c7f773c987e..b5a36abfb90cd7f4b7fa8d4269c198b64b6a7fe0 100644 (file)
--- a/include/webrtc_private.h
+++ b/include/webrtc_private.h
@@ -110,24 +110,6 @@ do { \
        } \
 } while (0)
 
-#define RET_WITH_UNLOCK_IF(expr, mutex, fmt, arg...) \
-do { \
-       if ((expr)) { \
-               LOG_ERROR(""fmt"", ##arg); \
-               g_mutex_unlock(mutex); \
-               return; \
-       } \
-} while (0)
-
-#define RET_VAL_WITH_UNLOCK_IF(expr, val, mutex, fmt, arg...) \
-do { \
-       if ((expr)) { \
-               LOG_ERROR(""fmt"", ##arg); \
-               g_mutex_unlock(mutex); \
-               return (val);\
-       } \
-} while (0)
-
 #define RET_ERR_IF_PRIVILEGE_IS_NOT_ALLOWED(x_privilege) \
 do { \
        int ret = _check_privilege(x_privilege); \

diff --git a/packaging/capi-media-webrtc.spec b/packaging/capi-media-webrtc.spec
index b319a8b3f3c611105d9768e5a977200e1125d8dd..f8edf768a52ee17b39c768002dba007dc7a0c4a3 100644 (file)
--- a/packaging/capi-media-webrtc.spec
+++ b/packaging/capi-media-webrtc.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-webrtc
 Summary:    A WebRTC library in Tizen Native API
-Version:    0.2.74
+Version:    0.2.75
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/webrtc.c b/src/webrtc.c
index d85bbc4b49589907f4f9b5661b3441589cab7811..98a03f2cb7f8a7bef555e561a67d798dae059992 100644 (file)
--- a/src/webrtc.c
+++ b/src/webrtc.c
@@ -50,13 +50,14 @@ int webrtc_set_error_cb(webrtc_h webrtc, webrtc_error_cb callback, void *user_da
 
 int webrtc_unset_error_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->error_cb.callback, _webrtc->error_cb.user_data);
@@ -64,8 +65,6 @@ int webrtc_unset_error_cb(webrtc_h webrtc)
        _webrtc->error_cb.callback = NULL;
        _webrtc->error_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -116,18 +115,19 @@ int webrtc_create(webrtc_h *webrtc)
 int webrtc_destroy(webrtc_h webrtc)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
        ret = _gst_pipeline_set_state(_webrtc, GST_STATE_NULL);
-       RET_VAL_WITH_UNLOCK_IF(ret != WEBRTC_ERROR_NONE, ret, &_webrtc->mutex, "failed to _gst_pipeline_set_state()");
+       RET_VAL_IF(ret != WEBRTC_ERROR_NONE, ret, "failed to _gst_pipeline_set_state()");
 
 #ifndef TIZEN_TV
        ret = _destroy_resource_manager(_webrtc);
-       RET_VAL_WITH_UNLOCK_IF(ret != WEBRTC_ERROR_NONE, ret, &_webrtc->mutex, "failed to _destroy_resource_manager()");
+       RET_VAL_IF(ret != WEBRTC_ERROR_NONE, ret, "failed to _destroy_resource_manager()");
 #endif
        _webrtc->pend_state = WEBRTC_STATE_IDLE;
        _webrtc->state = _webrtc->pend_state;
@@ -141,7 +141,7 @@ int webrtc_destroy(webrtc_h webrtc)
 
        LOG_INFO("webrtc[%p] is destroyed", webrtc);
 
-       g_mutex_unlock(&_webrtc->mutex);
+       g_clear_pointer(&locker, g_mutex_locker_free);
        g_mutex_clear(&_webrtc->mutex);
 
        g_free(_webrtc);
@@ -152,34 +152,33 @@ int webrtc_destroy(webrtc_h webrtc)
 int webrtc_start(webrtc_h webrtc)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "the ice candidate callback should be set");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->gst.webrtcbin == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "webrtcbin is NULL");
-       RET_VAL_WITH_UNLOCK_IF(!_check_if_format_is_set_to_packet_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "the media format should be set");
-       RET_VAL_WITH_UNLOCK_IF(!_check_if_path_is_set_to_file_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "the media path should be set");
+       RET_VAL_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "the ice candidate callback should be set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->gst.webrtcbin == NULL, WEBRTC_ERROR_INVALID_OPERATION, "webrtcbin is NULL");
+       RET_VAL_IF(!_check_if_format_is_set_to_packet_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, "the media format should be set");
+       RET_VAL_IF(!_check_if_path_is_set_to_file_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, "the media path should be set");
 
 #ifndef TIZEN_TV
        ret = _acquire_resource_if_needed(_webrtc);
        if (ret != WEBRTC_ERROR_NONE) {
                LOG_ERROR("failed to acquire resource, webrtc[%p]", _webrtc);
-               g_mutex_unlock(&_webrtc->mutex);
                return ret;
        }
 #endif
        ret = _gst_pipeline_set_state(_webrtc, GST_STATE_PLAYING);
-       RET_VAL_WITH_UNLOCK_IF(ret != WEBRTC_ERROR_NONE, ret, &_webrtc->mutex, "failed to change GST state to PLAYING");
+       RET_VAL_IF(ret != WEBRTC_ERROR_NONE, ret, "failed to change GST state to PLAYING");
 
        _webrtc->pend_state = WEBRTC_STATE_NEGOTIATING;
 
        LOG_INFO("webrtc[%p] is started", webrtc);
 
-       g_mutex_unlock(&_webrtc->mutex);
 
        return WEBRTC_ERROR_NONE;
 }
@@ -216,13 +215,14 @@ int webrtc_set_state_changed_cb(webrtc_h webrtc, webrtc_state_changed_cb callbac
 
 int webrtc_unset_state_changed_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->state_changed_cb.callback, _webrtc->state_changed_cb.user_data);
@@ -230,8 +230,6 @@ int webrtc_unset_state_changed_cb(webrtc_h webrtc)
        _webrtc->state_changed_cb.callback = NULL;
        _webrtc->state_changed_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -256,6 +254,7 @@ int webrtc_get_state(webrtc_h webrtc, webrtc_state_e *state)
 int webrtc_add_media_source(webrtc_h webrtc, webrtc_media_source_type_e type, unsigned int *source_id)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        if (type == WEBRTC_MEDIA_SOURCE_TYPE_CAMERA) {
@@ -269,56 +268,52 @@ int webrtc_add_media_source(webrtc_h webrtc, webrtc_media_source_type_e type, un
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(source_id == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        ret = _add_media_source(webrtc, type, source_id);
        if (ret == WEBRTC_ERROR_NONE)
                LOG_INFO("source_id[%u]", *source_id);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_remove_media_source(webrtc_h webrtc, unsigned int source_id)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        ret = _remove_media_source(webrtc, source_id);
        if (ret == WEBRTC_ERROR_NONE)
                LOG_INFO("source_id[%u]", source_id);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_media_source_set_transceiver_direction(webrtc_h webrtc, unsigned int source_id, webrtc_media_type_e media_type, webrtc_transceiver_direction_e direction)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        ret = _set_transceiver_direction(webrtc, source_id, media_type, direction);
        if (ret == WEBRTC_ERROR_NONE)
                LOG_INFO("source_id[%u] media_type[%d] direction[%d]", source_id, media_type, direction);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
@@ -477,24 +472,24 @@ int webrtc_media_source_get_video_resolution(webrtc_h webrtc, unsigned int sourc
 int webrtc_mic_source_set_sound_stream_info(webrtc_h webrtc, unsigned int source_id, sound_stream_info_h stream_info)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(stream_info == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "stream_info is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        ret = _set_sound_stream_info(webrtc, source_id, stream_info);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_media_packet_source_set_buffer_state_changed_cb(webrtc_h webrtc, unsigned int source_id, webrtc_media_packet_source_buffer_state_changed_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
        webrtc_gst_slot_s *source;
 
@@ -502,11 +497,11 @@ int webrtc_media_packet_source_set_buffer_state_changed_cb(webrtc_h webrtc, unsi
        RET_VAL_IF(source_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is 0");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, WEBRTC_ERROR_INVALID_PARAMETER,
-               &_webrtc->mutex, "source is NULL");
-       RET_VAL_WITH_UNLOCK_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex,
+       RET_VAL_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL,
+               WEBRTC_ERROR_INVALID_PARAMETER, "source is NULL");
+       RET_VAL_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER,
                "source is not media packet type");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(source->buffer_state_changed_cb);
@@ -516,26 +511,25 @@ int webrtc_media_packet_source_set_buffer_state_changed_cb(webrtc_h webrtc, unsi
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_media_packet_source_unset_buffer_state_changed_cb(webrtc_h webrtc, unsigned int source_id)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
        webrtc_gst_slot_s *source;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(source_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is 0");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, WEBRTC_ERROR_INVALID_PARAMETER,
-               &_webrtc->mutex, "source is NULL");
-       RET_VAL_WITH_UNLOCK_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex,
+       RET_VAL_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL,
+               WEBRTC_ERROR_INVALID_PARAMETER, "source is NULL");
+       RET_VAL_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER,
                "source is not media packet type");
-       RET_VAL_WITH_UNLOCK_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex,\
+       RET_VAL_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION,
                "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
@@ -544,105 +538,100 @@ int webrtc_media_packet_source_unset_buffer_state_changed_cb(webrtc_h webrtc, un
        source->buffer_state_changed_cb.callback = NULL;
        source->buffer_state_changed_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_media_packet_source_set_format(webrtc_h webrtc, unsigned int source_id, media_format_h format)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(format == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "format is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        ret = _set_media_format(_webrtc, source_id, format);
        if (ret == WEBRTC_ERROR_NONE)
                LOG_INFO("source_id[%u] format[%p]", source_id, format);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_media_packet_source_push_packet(webrtc_h webrtc, unsigned int source_id, media_packet_h packet)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
        webrtc_gst_slot_s *source;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(packet == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "packet is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, WEBRTC_ERROR_INVALID_PARAMETER,
-               &_webrtc->mutex, "source is NULL");
-       RET_VAL_WITH_UNLOCK_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex,
+       RET_VAL_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL,
+               WEBRTC_ERROR_INVALID_PARAMETER, "source is NULL");
+       RET_VAL_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER,
                "source is not media packet type");
-       RET_VAL_WITH_UNLOCK_IF(source->media_format == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex,
+       RET_VAL_IF(source->media_format == NULL, WEBRTC_ERROR_INVALID_OPERATION,
                "the media format should be set");
-       RET_VAL_WITH_UNLOCK_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex,
+       RET_VAL_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION,
                "the buffer state changed callback should be set");
 
        ret = _push_media_packet(webrtc, source_id, packet);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_file_source_set_path(webrtc_h webrtc, unsigned int source_id, const char *path)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(source_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is 0");
        RET_VAL_IF(path == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "path is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        ret = _set_media_path(_webrtc, source_id, path);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_set_sound_stream_info(webrtc_h webrtc, unsigned int track_id, sound_stream_info_h stream_info)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(track_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "track id is 0");
        RET_VAL_IF(stream_info == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "stream_info is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "track added callback was not set");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_audio_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "encoded audio frame callback was set");
-       RET_VAL_WITH_UNLOCK_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex,
-                       "this function should be called within the track added callback");
+       RET_VAL_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "track added callback was not set");
+       RET_VAL_IF(_webrtc->encoded_audio_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, "encoded audio frame callback was set");
+       RET_VAL_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION,
+               "this function should be called within the track added callback");
 
        ret = _set_stream_info_to_sink(webrtc, track_id, stream_info);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
 int webrtc_set_display(webrtc_h webrtc, unsigned int track_id, webrtc_display_type_e type, webrtc_display_h display)
 {
        int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
@@ -650,17 +639,15 @@ int webrtc_set_display(webrtc_h webrtc, unsigned int track_id, webrtc_display_ty
        RET_VAL_IF(type > WEBRTC_DISPLAY_TYPE_EVAS, WEBRTC_ERROR_INVALID_PARAMETER, "invalid display type(%d)", type);
        RET_VAL_IF(display == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "display is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "track added callback was not set");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_video_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "encoded video frame callback was set");
-       RET_VAL_WITH_UNLOCK_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex,
-                       "this function should be called within the track added callback");
+       RET_VAL_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "track added callback was not set");
+       RET_VAL_IF(_webrtc->encoded_video_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, "encoded video frame callback was set");
+       RET_VAL_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION,
+               "this function should be called within the track added callback");
 
        ret = _set_display_to_sink(webrtc, track_id, (unsigned int)type, (void *)display);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return ret;
 }
 
@@ -749,14 +736,15 @@ int webrtc_get_display_visible(webrtc_h webrtc, unsigned int track_id, bool *vis
 
 int webrtc_set_encoded_audio_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING");
+       RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->encoded_audio_frame_cb);
 
@@ -765,21 +753,20 @@ int webrtc_set_encoded_audio_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb c
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_encoded_audio_frame_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_audio_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING");
+       RET_VAL_IF(_webrtc->encoded_audio_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
+       RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->encoded_audio_frame_cb.callback, _webrtc->encoded_audio_frame_cb.user_data);
@@ -787,21 +774,20 @@ int webrtc_unset_encoded_audio_frame_cb(webrtc_h webrtc)
        _webrtc->encoded_audio_frame_cb.callback = NULL;
        _webrtc->encoded_audio_frame_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_set_encoded_video_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING");
+       RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->encoded_video_frame_cb);
 
@@ -810,21 +796,20 @@ int webrtc_set_encoded_video_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb c
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_encoded_video_frame_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_video_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING");
+       RET_VAL_IF(_webrtc->encoded_video_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
+       RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->encoded_video_frame_cb.callback, _webrtc->encoded_video_frame_cb.user_data);
@@ -832,8 +817,6 @@ int webrtc_unset_encoded_video_frame_cb(webrtc_h webrtc)
        _webrtc->encoded_video_frame_cb.callback = NULL;
        _webrtc->encoded_video_frame_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -876,14 +859,15 @@ int webrtc_media_source_set_video_loopback(webrtc_h webrtc, unsigned int source_
 
 int webrtc_set_stun_server(webrtc_h webrtc, const char *stun_server)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(stun_server == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "stun_server is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        g_free(_webrtc->stun_server_url);
 
@@ -893,8 +877,6 @@ int webrtc_set_stun_server(webrtc_h webrtc, const char *stun_server)
 
        LOG_INFO("stun_server[%s]", stun_server);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -922,24 +904,23 @@ int webrtc_get_stun_server(webrtc_h webrtc, char **stun_server)
 int webrtc_add_turn_server(webrtc_h webrtc, const char *turn_server)
 {
        gboolean ret = FALSE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(turn_server == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "turn_server is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        g_signal_emit_by_name(G_OBJECT(_webrtc->gst.webrtcbin), "add-turn-server", turn_server, &ret);
-       RET_VAL_WITH_UNLOCK_IF(!ret, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex, "invalid turn server url (%s)", turn_server);
+       RET_VAL_IF(!ret, WEBRTC_ERROR_INVALID_PARAMETER, "invalid turn server url (%s)", turn_server);
 
        _webrtc->turn_server_urls = g_list_append(_webrtc->turn_server_urls, g_strdup(turn_server));
 
        LOG_INFO("turn_server[%s]", turn_server);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -972,21 +953,20 @@ int webrtc_foreach_turn_server(webrtc_h webrtc, webrtc_turn_server_cb callback,
 
 int webrtc_set_ice_transport_policy(webrtc_h webrtc, webrtc_ice_transport_policy_e policy)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(policy > WEBRTC_ICE_TRANSPORT_POLICY_RELAY, WEBRTC_ERROR_INVALID_PARAMETER, "invalid policy(%d)", policy);
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        g_object_set(G_OBJECT(_webrtc->gst.webrtcbin), "ice-transport-policy", (GstWebRTCICETransportPolicy)policy, NULL);
 
        LOG_INFO("policy[%s]", (policy == WEBRTC_ICE_TRANSPORT_POLICY_ALL) ? "all" : "relay");
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1013,14 +993,15 @@ int webrtc_get_ice_transport_policy(webrtc_h webrtc, webrtc_ice_transport_policy
 
 int webrtc_set_peer_connection_state_change_cb(webrtc_h webrtc, webrtc_peer_connection_state_change_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->peer_connection_state_change_cb);
 
@@ -1029,21 +1010,20 @@ int webrtc_set_peer_connection_state_change_cb(webrtc_h webrtc, webrtc_peer_conn
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_peer_connection_state_change_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->peer_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->peer_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->peer_connection_state_change_cb.callback, _webrtc->peer_connection_state_change_cb.user_data);
@@ -1051,8 +1031,6 @@ int webrtc_unset_peer_connection_state_change_cb(webrtc_h webrtc)
        _webrtc->peer_connection_state_change_cb.callback = NULL;
        _webrtc->peer_connection_state_change_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1076,14 +1054,15 @@ int webrtc_get_peer_connection_state(webrtc_h webrtc, webrtc_peer_connection_sta
 
 int webrtc_set_signaling_state_change_cb(webrtc_h webrtc, webrtc_signaling_state_change_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->signaling_state_change_cb);
 
@@ -1092,21 +1071,20 @@ int webrtc_set_signaling_state_change_cb(webrtc_h webrtc, webrtc_signaling_state
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_signaling_state_change_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->signaling_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->signaling_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->signaling_state_change_cb.callback, _webrtc->signaling_state_change_cb.user_data);
@@ -1114,8 +1092,6 @@ int webrtc_unset_signaling_state_change_cb(webrtc_h webrtc)
        _webrtc->signaling_state_change_cb.callback = NULL;
        _webrtc->signaling_state_change_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1139,14 +1115,15 @@ int webrtc_get_signaling_state(webrtc_h webrtc, webrtc_signaling_state_e *state)
 
 int webrtc_set_ice_gathering_state_change_cb(webrtc_h webrtc, webrtc_ice_gathering_state_change_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->ice_gathering_state_change_cb);
 
@@ -1155,21 +1132,20 @@ int webrtc_set_ice_gathering_state_change_cb(webrtc_h webrtc, webrtc_ice_gatheri
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_ice_gathering_state_change_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_gathering_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->ice_gathering_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->ice_gathering_state_change_cb.callback, _webrtc->ice_gathering_state_change_cb.user_data);
@@ -1177,8 +1153,6 @@ int webrtc_unset_ice_gathering_state_change_cb(webrtc_h webrtc)
        _webrtc->ice_gathering_state_change_cb.callback = NULL;
        _webrtc->ice_gathering_state_change_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1202,14 +1176,15 @@ int webrtc_get_ice_gathering_state(webrtc_h webrtc, webrtc_ice_gathering_state_e
 
 int webrtc_set_ice_connection_state_change_cb(webrtc_h webrtc, webrtc_ice_connection_state_change_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->ice_connection_state_change_cb);
 
@@ -1218,21 +1193,20 @@ int webrtc_set_ice_connection_state_change_cb(webrtc_h webrtc, webrtc_ice_connec
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_ice_connection_state_change_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->ice_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->ice_connection_state_change_cb.callback, _webrtc->ice_connection_state_change_cb.user_data);
@@ -1240,8 +1214,6 @@ int webrtc_unset_ice_connection_state_change_cb(webrtc_h webrtc)
        _webrtc->ice_connection_state_change_cb.callback = NULL;
        _webrtc->ice_connection_state_change_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1265,14 +1237,15 @@ int webrtc_get_ice_connection_state(webrtc_h webrtc, webrtc_ice_connection_state
 
 int webrtc_set_negotiation_needed_cb(webrtc_h webrtc, webrtc_negotiation_needed_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->negotiation_needed_cb);
 
@@ -1281,21 +1254,20 @@ int webrtc_set_negotiation_needed_cb(webrtc_h webrtc, webrtc_negotiation_needed_
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_negotiation_needed_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->negotiation_needed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->negotiation_needed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->negotiation_needed_cb.callback, _webrtc->negotiation_needed_cb.user_data);
@@ -1303,21 +1275,20 @@ int webrtc_unset_negotiation_needed_cb(webrtc_h webrtc)
        _webrtc->negotiation_needed_cb.callback = NULL;
        _webrtc->negotiation_needed_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_set_ice_candidate_cb(webrtc_h webrtc, webrtc_ice_candidate_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->ice_candidate_cb);
 
@@ -1326,21 +1297,20 @@ int webrtc_set_ice_candidate_cb(webrtc_h webrtc, webrtc_ice_candidate_cb callbac
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_ice_candidate_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->ice_candidate_cb.callback, _webrtc->ice_candidate_cb.user_data);
@@ -1348,21 +1318,20 @@ int webrtc_unset_ice_candidate_cb(webrtc_h webrtc)
        _webrtc->ice_candidate_cb.callback = NULL;
        _webrtc->ice_candidate_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_set_track_added_cb(webrtc_h webrtc, webrtc_track_added_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING");
+       RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->track_added_cb);
 
@@ -1371,20 +1340,19 @@ int webrtc_set_track_added_cb(webrtc_h webrtc, webrtc_track_added_cb callback, v
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_track_added_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->track_added_cb.callback, _webrtc->track_added_cb.user_data);
@@ -1392,135 +1360,109 @@ int webrtc_unset_track_added_cb(webrtc_h webrtc)
        _webrtc->track_added_cb.callback = NULL;
        _webrtc->track_added_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_create_offer(webrtc_h webrtc, bundle *options, char **offer)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(offer == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "offer is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING");
 
        LOG_INFO("offer[%p]", offer);
 
-       ret = _webrtcbin_create_session_description(webrtc, true, offer);
-
-       g_mutex_unlock(&_webrtc->mutex);
-
-       return ret;
+       return _webrtcbin_create_session_description(webrtc, true, offer);
 }
 
 int webrtc_create_answer(webrtc_h webrtc, bundle *options, char **answer)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(answer == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "answer is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING");
-       RET_VAL_WITH_UNLOCK_IF(!_webrtcbin_have_remote_offer(_webrtc), WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "remote offer should be set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING");
+       RET_VAL_IF(!_webrtcbin_have_remote_offer(_webrtc), WEBRTC_ERROR_INVALID_STATE, "remote offer should be set");
 
        LOG_INFO("answer[%p]", answer);
 
-       ret = _webrtcbin_create_session_description(webrtc, false, answer);
-
-       g_mutex_unlock(&_webrtc->mutex);
-
-       return ret;
+       return _webrtcbin_create_session_description(webrtc, false, answer);
 }
 
 int webrtc_set_local_description(webrtc_h webrtc, const char *description)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(description == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "description is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING");
 
        LOG_INFO("description: %s", description);
 
-       ret = _webrtcbin_set_session_description(webrtc, description, false);
-
-       g_mutex_unlock(&_webrtc->mutex);
-
-       return ret;
+       return _webrtcbin_set_session_description(webrtc, description, false);
 }
 
 int webrtc_set_remote_description(webrtc_h webrtc, const char *description)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(description == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "description is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING");
 
        LOG_INFO("description: %s", description);
 
-       ret = _webrtcbin_set_session_description(webrtc, description, true);
-
-       g_mutex_unlock(&_webrtc->mutex);
-
-       return ret;
+       return _webrtcbin_set_session_description(webrtc, description, true);
 }
 
 int webrtc_add_ice_candidate(webrtc_h webrtc, const char *candidate)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(candidate == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "candidate is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING");
 
        LOG_INFO("candidate: %s", candidate);
 
-       ret = _webrtcbin_add_ice_candidate(webrtc, candidate);
-
-       g_mutex_unlock(&_webrtc->mutex);
-
-       return ret;
+       return _webrtcbin_add_ice_candidate(webrtc, candidate);
 }
 
 int webrtc_create_data_channel(webrtc_h webrtc, const char *label, bundle *options, webrtc_data_channel_h *channel)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(label == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "label is NULL");
        RET_VAL_IF(channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
-
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-
-       ret = _create_data_channel(webrtc, label, options, (webrtc_data_channel_s **)channel);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       g_mutex_unlock(&_webrtc->mutex);
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
-       return ret;
+       return _create_data_channel(webrtc, label, options, (webrtc_data_channel_s **)channel);
 }
 
 int webrtc_destroy_data_channel(webrtc_data_channel_h channel)
@@ -1532,14 +1474,15 @@ int webrtc_destroy_data_channel(webrtc_data_channel_h channel)
 
 int webrtc_set_data_channel_cb(webrtc_h webrtc, webrtc_data_channel_cb callback, void *user_data)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
        RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
 
        LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->data_channel_cb);
 
@@ -1548,21 +1491,20 @@ int webrtc_set_data_channel_cb(webrtc_h webrtc, webrtc_data_channel_cb callback,
 
        LOG_INFO("callback[%p] user_data[%p]", callback, user_data);
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
 int webrtc_unset_data_channel_cb(webrtc_h webrtc)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_s *_webrtc = (webrtc_s*)webrtc;
 
        RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL");
 
-       g_mutex_lock(&_webrtc->mutex);
+       locker = g_mutex_locker_new(&_webrtc->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE");
-       RET_VAL_WITH_UNLOCK_IF(_webrtc->data_channel_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set");
+       RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE");
+       RET_VAL_IF(_webrtc->data_channel_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("callback[%p] user_data[%p] is reset to NULL",
                _webrtc->data_channel_cb.callback, _webrtc->data_channel_cb.user_data);
@@ -1570,8 +1512,6 @@ int webrtc_unset_data_channel_cb(webrtc_h webrtc)
        _webrtc->data_channel_cb.callback = NULL;
        _webrtc->data_channel_cb.user_data = NULL;
 
-       g_mutex_unlock(&_webrtc->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1598,13 +1538,14 @@ int webrtc_data_channel_set_open_cb(webrtc_data_channel_h channel, webrtc_data_c
 
 int webrtc_data_channel_unset_open_cb(webrtc_data_channel_h channel)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel;
 
        RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL");
 
-       g_mutex_lock(&_channel->mutex);
+       locker = g_mutex_locker_new(&_channel->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_channel->open_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set");
+       RET_VAL_IF(_channel->open_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL",
                _channel, _channel->open_cb.callback, _channel->open_cb.user_data);
@@ -1612,8 +1553,6 @@ int webrtc_data_channel_unset_open_cb(webrtc_data_channel_h channel)
        _channel->open_cb.callback = NULL;
        _channel->open_cb.user_data = NULL;
 
-       g_mutex_unlock(&_channel->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1640,13 +1579,14 @@ int webrtc_data_channel_set_message_cb(webrtc_data_channel_h channel, webrtc_dat
 
 int webrtc_data_channel_unset_message_cb(webrtc_data_channel_h channel)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel;
 
        RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL");
 
-       g_mutex_lock(&_channel->mutex);
+       locker = g_mutex_locker_new(&_channel->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_channel->message_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set");
+       RET_VAL_IF(_channel->message_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL",
                _channel, _channel->message_cb.callback, _channel->message_cb.user_data);
@@ -1654,8 +1594,6 @@ int webrtc_data_channel_unset_message_cb(webrtc_data_channel_h channel)
        _channel->message_cb.callback = NULL;
        _channel->message_cb.user_data = NULL;
 
-       g_mutex_unlock(&_channel->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1682,13 +1620,14 @@ int webrtc_data_channel_set_error_cb(webrtc_data_channel_h channel, webrtc_data_
 
 int webrtc_data_channel_unset_error_cb(webrtc_data_channel_h channel)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel;
 
        RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL");
 
-       g_mutex_lock(&_channel->mutex);
+       locker = g_mutex_locker_new(&_channel->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_channel->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set");
+       RET_VAL_IF(_channel->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL",
                _channel, _channel->error_cb.callback, _channel->error_cb.user_data);
@@ -1696,8 +1635,6 @@ int webrtc_data_channel_unset_error_cb(webrtc_data_channel_h channel)
        _channel->error_cb.callback = NULL;
        _channel->error_cb.user_data = NULL;
 
-       g_mutex_unlock(&_channel->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 
@@ -1724,13 +1661,14 @@ int webrtc_data_channel_set_close_cb(webrtc_data_channel_h channel, webrtc_data_
 
 int webrtc_data_channel_unset_close_cb(webrtc_data_channel_h channel)
 {
+       g_autoptr(GMutexLocker) locker = NULL;
        webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel;
 
        RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL");
 
-       g_mutex_lock(&_channel->mutex);
+       locker = g_mutex_locker_new(&_channel->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(_channel->close_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set");
+       RET_VAL_IF(_channel->close_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set");
 
        LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL",
                _channel, _channel->close_cb.callback, _channel->close_cb.user_data);
@@ -1738,8 +1676,6 @@ int webrtc_data_channel_unset_close_cb(webrtc_data_channel_h channel)
        _channel->close_cb.callback = NULL;
        _channel->close_cb.user_data = NULL;
 
-       g_mutex_unlock(&_channel->mutex);
-
        return WEBRTC_ERROR_NONE;
 }
 

diff --git a/src/webrtc_display.c b/src/webrtc_display.c
index 3cd8ff3dc337862f361a6832c7f283add71db8f5..9778de0fbf9200efc149cf1a5cae9c4dea02fac0 100644 (file)
--- a/src/webrtc_display.c
+++ b/src/webrtc_display.c
@@ -786,8 +786,8 @@ int _set_display_mode(webrtc_display_s *display, webrtc_display_mode_e mode)
 
        locker = g_mutex_locker_new(&display->mutex);
 
-       RET_VAL_WITH_UNLOCK_IF(display->mm_display == NULL, WEBRTC_ERROR_INVALID_OPERATION, &display->mutex, "mm_display is NULL");
-       RET_VAL_WITH_UNLOCK_IF(display->surface == NULL, WEBRTC_ERROR_INVALID_OPERATION, &display->mutex, "surface is NULL");
+       RET_VAL_IF(display->mm_display == NULL, WEBRTC_ERROR_INVALID_OPERATION, "mm_display is NULL");
+       RET_VAL_IF(display->surface == NULL, WEBRTC_ERROR_INVALID_OPERATION, "surface is NULL");
 
        switch (display->type) {
        case WEBRTC_DISPLAY_TYPE_OVERLAY:

diff --git a/src/webrtc_signaling_server.c b/src/webrtc_signaling_server.c
index 3f28165f2921a8899ab6ee3b17f52d28dd4cbe94..a47d2ff802e55ac7c19e2a02db691958c77ccdc5 100644 (file)
--- a/src/webrtc_signaling_server.c
+++ b/src/webrtc_signaling_server.c
@@ -434,7 +434,7 @@ int webrtc_signaling_server_start(webrtc_signaling_server_h server)
        _server->exit_thread = false;
 
        _server->thread = g_thread_try_new("signaling-thread", __thread_func, _server, &error);
-       RET_VAL_WITH_UNLOCK_IF(_server->thread == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_server->mutex,
+       RET_VAL_IF(_server->thread == NULL, WEBRTC_ERROR_INVALID_OPERATION,
                "failed to g_thread_try_new(), error[%s]", error->message);
 
        LOG_INFO("server[%p, thread:%p]", _server, _server->thread);

diff --git a/src/webrtc_websocket.c b/src/webrtc_websocket.c
index 4b238b86be28cc66ba5e5e93acdcbc06997ad74e..2f6f3f710b0caa70e16f0c89de4944aab8f9d959 100644 (file)
--- a/src/webrtc_websocket.c
+++ b/src/webrtc_websocket.c
@@ -82,23 +82,21 @@ void _release_websocket(webrtc_websocket_s *ws)
 int _start_websocket(webrtc_websocket_s *ws, int timeout_ms)
 {
        int ret;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        RET_VAL_IF(ws == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "ws is NULL");
        RET_VAL_IF(timeout_ms < 0, WEBRTC_ERROR_INVALID_PARAMETER, "invalid timeout_ms(%d)", timeout_ms);
 
-       g_mutex_lock(&ws->mutex);
+       locker = g_mutex_locker_new(&ws->mutex);
 
        ret = lws_service(ws->context, timeout_ms);
        if (ret != 0) {
                LOG_ERROR("failed to lws_service(), ret[%d]", ret);
-               g_mutex_unlock(&ws->mutex);
                return WEBRTC_ERROR_INVALID_OPERATION;
        }
 
        LOG_DEBUG("ws[%p, context:%p], timeout_ms[%d]", ws, ws->context, timeout_ms);
 
-       g_mutex_unlock(&ws->mutex);
-
        return WEBRTC_ERROR_NONE;
 }