hwc: Modify ds_tizen_hwc destruction logic

AS-IS
- when hwc is destroyed, client is not destroyed together

TO-BE
- client is also destroyed with hwc

Change-Id: I3706afeacc3388350391531188786cae3127eb3f

diff --git a/include/libds-tizen/blur.h b/include/libds-tizen/blur.h
index 84fe80f..e66dcbd 100644 (file)
--- a/include/libds-tizen/blur.h
+++ b/include/libds-tizen/blur.h
@@ -11,18 +11,33 @@ extern "C" {
 
 struct ds_tizen_blur_manager;
 struct ds_tizen_blur;
+struct ds_tizen_blur_rectangle;
+struct ds_tizen_blur_behind;
 
 enum ds_tizen_blur_state_field {
     DS_TIZEN_BLUR_STATE_NONE = 0,
-    DS_TIZEN_BLUR_STATE_REGION = (1 << 0),
+    DS_TIZEN_BLUR_STATE_REGION = (1 << 0),//temporary
     DS_TIZEN_BLUR_STATE_RADIUS = (1 << 1),
+    DS_TIZEN_BLUR_STATE_RECTANGLE = (1 << 2),
 };
 
 struct ds_tizen_blur_state
 {
     enum ds_tizen_blur_state_field committed;
 
-    pixman_region32_t region;
+    pixman_region32_t region; //temporary
+    uint32_t radius;
+};
+
+enum ds_tizen_blur_behind_state_field {
+    DS_TIZEN_BLUR_BEHIND_STATE_NONE = 0,
+    DS_TIZEN_BLUR_BEHIND_STATE_RADIUS = (1 << 0),
+};
+
+struct ds_tizen_blur_behind_state
+{
+    enum ds_tizen_blur_behind_state_field committed;
+
     uint32_t radius;
 };
 
@@ -30,15 +45,11 @@ struct ds_tizen_blur_manager *
 ds_tizen_blur_manager_create(struct wl_display *display);
 
 void
-ds_tizen_blur_manager_add_destroy_listener(struct ds_tizen_blur_manager *blur,
-        struct wl_listener *listener);
-
-void
-ds_tizen_blur_manager_add_destroy_listener(struct ds_tizen_blur_manager *blur,
+ds_tizen_blur_manager_add_destroy_listener(struct ds_tizen_blur_manager *blur_manager,
         struct wl_listener *listener);
 
 void
-ds_tizen_blur_manager_add_new_blur_listener(struct ds_tizen_blur_manager *blur,
+ds_tizen_blur_manager_add_new_blur_listener(struct ds_tizen_blur_manager *blur_manager,
         struct wl_listener *listener);
 
 void
@@ -55,6 +66,40 @@ ds_tizen_blur_get_surface(struct ds_tizen_blur *blur);
 struct ds_tizen_blur_state *
 ds_tizen_blur_get_state(struct ds_tizen_blur *blur);
 
+void
+ds_tizen_blur_add_new_rectangle_listener(struct ds_tizen_blur *blur,
+        struct wl_listener *listener);
+
+void
+ds_tizen_blur_rectangle_add_destroy_listener(struct ds_tizen_blur_rectangle *blur_rectangle,
+        struct wl_listener *listener);
+
+void
+ds_tizen_blur_rectangle_get_geometry(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *x, int *y, int *width, int *height);
+
+void
+ds_tizen_blur_rectangle_get_corner_radius(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *rx, int *ry);
+
+void
+ds_tizen_blur_manager_add_new_blur_behind_listener(struct ds_tizen_blur_manager *blur,
+        struct wl_listener *listener);
+
+void
+ds_tizen_blur_behind_add_destroy_listener(struct ds_tizen_blur_behind *blur_behind,
+        struct wl_listener *listener);
+
+void
+ds_tizen_blur_behind_add_commit_listener(struct ds_tizen_blur_behind *blur_behind,
+        struct wl_listener *listener);
+
+struct ds_surface *
+ds_tizen_blur_behind_get_surface(struct ds_tizen_blur_behind *blur_behind);
+
+struct ds_tizen_blur_behind_state *
+ds_tizen_blur_behind_get_state(struct ds_tizen_blur_behind *blur_behind);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/include/libds-tizen/memory_flusher.h b/include/libds-tizen/memory_flusher.h
index 0b72425..7a9ec2a 100644 (file)
--- a/include/libds-tizen/memory_flusher.h
+++ b/include/libds-tizen/memory_flusher.h
@@ -42,6 +42,10 @@ void
 ds_tizen_memory_flusher_info_send_free_flush(
     struct ds_tizen_memory_flusher_info *info);
 
+bool
+ds_tizen_memory_flusher_info_supported_free_flush(
+    struct ds_tizen_memory_flusher_info *info);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/backend/tdm/backend.c b/src/backend/tdm/backend.c
index bf1b0d6..8ca365e 100644 (file)
--- a/src/backend/tdm/backend.c
+++ b/src/backend/tdm/backend.c
@@ -125,7 +125,7 @@ tdm_backend_scan_outputs(struct ds_tdm_backend *tdm)
 
         wl_list_insert(&tdm->outputs, &output->link);
 
-        wl_signal_emit_mutable(&tdm->base.events.new_output, &output->base);
+        wl_signal_emit(&tdm->base.events.new_output, &output->base);
     }
 
     return true;

diff --git a/src/backend/tdm/output.c b/src/backend/tdm/output.c
index 03f4c62..4a236a8 100644 (file)
--- a/src/backend/tdm/output.c
+++ b/src/backend/tdm/output.c
@@ -333,7 +333,7 @@ output_hwc_commit_handler(struct wl_listener *listener, void *data)
 
     output_update_front_buffer(output);
 
-    wl_signal_emit_mutable(&output->base.events.frame, &output->base);
+    wl_signal_emit(&output->base.events.frame, &output->base);
 }
 
 static void

diff --git a/src/backend/tdm/tdm_buffer_queue.c b/src/backend/tdm/tdm_buffer_queue.c
index 954954b..6f0e497 100644 (file)
--- a/src/backend/tdm/tdm_buffer_queue.c
+++ b/src/backend/tdm/tdm_buffer_queue.c
@@ -306,7 +306,7 @@ buffer_queue_handle_acquirable_efd(int fd, uint32_t mask, void *data)
     if (len < 0 && errno != EAGAIN)
         return -1;
 
-    wl_signal_emit_mutable(&queue->events.acquirable, queue);
+    wl_signal_emit(&queue->events.acquirable, queue);
 
     return 0;
 }

diff --git a/src/backend/tdm/tdm_output_hwc.c b/src/backend/tdm/tdm_output_hwc.c
index a5bba62..3618aff 100644 (file)
--- a/src/backend/tdm/tdm_output_hwc.c
+++ b/src/backend/tdm/tdm_output_hwc.c
@@ -181,7 +181,7 @@ ds_tdm_output_hwc_create(struct ds_tdm_output *output, tdm_hwc *thwc)
 void
 ds_tdm_output_hwc_destroy(struct ds_tdm_output_hwc *hwc)
 {
-    wl_signal_emit_mutable(&hwc->events.destroy, hwc);
+    wl_signal_emit(&hwc->events.destroy, hwc);
 
     free(hwc);
 }
@@ -622,7 +622,7 @@ ds_tdm_output_hwc_commit_handler(tdm_hwc *thwc, unsigned int sequence,
     wl_list_for_each_safe(hwc_window, tmp, &hwc->hwc_windows, link)
         hwc_window_update_front_buffer(hwc_window);
 
-    wl_signal_emit_mutable(&hwc->events.commit_handler, hwc);
+    wl_signal_emit(&hwc->events.commit_handler, hwc);
 }
 
 bool

diff --git a/src/blender/blender.c b/src/blender/blender.c
index 272b0a8..0096c7c 100644 (file)
--- a/src/blender/blender.c
+++ b/src/blender/blender.c
@@ -35,10 +35,6 @@ struct ds_tizen_blender_client
 
     struct wl_resource *resource;
     struct wl_client *wl_client;
-
-    struct {
-        struct wl_signal destroy;
-    } events;
 };
 
 struct ds_tizen_blend
@@ -148,7 +144,7 @@ blender_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: blender(%p)", blender);
 
-    wl_signal_emit_mutable(&blender->events.destroy, blender);
+    wl_signal_emit(&blender->events.destroy, blender);
     wl_list_remove(&blender->destroy.link);
     wl_global_destroy(blender->global);
     free(blender);
@@ -195,7 +191,7 @@ blend_destroy(struct ds_tizen_blend *blend)
 {
     ds_inf("blend_destroy (blend:%p)", blend);
 
-    wl_signal_emit_mutable(&blend->events.destroy, blend);
+    wl_signal_emit(&blend->events.destroy, blend);
 
     if (blend->listener.surface_commit.notify)
         wl_list_remove(&blend->listener.surface_commit.link);
@@ -249,7 +245,7 @@ blend_handle_surface_commit(struct wl_listener *listener, void *data)
     blend->current.committed = blend->pending.committed;
     blend->pending.committed = DS_TIZEN_BLEND_STATE_NONE;
 
-    wl_signal_emit_mutable(&blend->events.commit, blend);
+    wl_signal_emit(&blend->events.commit, blend);
 }
 
 static void
@@ -347,7 +343,7 @@ blender_handle_get_blend(struct wl_client *wl_client,
     wl_signal_init(&blend->events.destroy);
     wl_signal_init(&blend->events.commit);
 
-    wl_signal_emit_mutable(&client->blender->events.new_blend, blend);
+    wl_signal_emit(&client->blender->events.new_blend, blend);
 }
 
 static void
@@ -407,7 +403,5 @@ blender_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &blender_impl, client,
             blender_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&blender->clients, &client->link);
 }

diff --git a/src/blur/blur.c b/src/blur/blur.c
index 48d7329..c3132aa 100644 (file)
--- a/src/blur/blur.c
+++ b/src/blur/blur.c
@@ -26,6 +26,7 @@ struct ds_tizen_blur_manager
     struct {
         struct wl_signal destroy;
         struct wl_signal new_blur;
+        struct wl_signal new_blur_behind;
     } events;
 };
 
@@ -37,18 +38,64 @@ struct ds_tizen_blur_client
 
     struct wl_resource *resource;
     struct wl_client *wl_client;
+};
+
+struct ds_tizen_blur
+{
+    struct wl_resource *resource;
+    struct wl_client *wl_client;
+
+    struct wl_list rectangles;
+
+    struct ds_tizen_blur_state current, pending;
+
+    struct ds_surface *surface;
+    struct ds_addon surface_addon;
+
+    struct {
+        struct wl_listener surface_commit;
+    } listener;
 
     struct {
+        struct wl_signal commit;
         struct wl_signal destroy;
+        struct wl_signal new_rectangle;
     } events;
 };
 
-struct ds_tizen_blur
+struct ds_tizen_blur_rectangle
 {
+    struct wl_list link; //rectangles
+
     struct wl_resource *resource;
     struct wl_client *wl_client;
 
-    struct ds_tizen_blur_state current, pending;
+    struct ds_tizen_blur *blur;
+
+    bool pending;
+
+    int x;
+    int y;
+    int width;
+    int height;
+    int rx;
+    int ry;
+
+    struct {
+        struct wl_listener blur_destroy;
+    } listener;
+
+    struct {
+        struct wl_signal destroy;
+    } events;
+};
+
+struct ds_tizen_blur_behind
+{
+    struct wl_resource *resource;
+    struct wl_client *wl_client;
+
+    struct ds_tizen_blur_behind_state current, pending;
 
     struct ds_surface *surface;
     struct ds_addon surface_addon;
@@ -95,6 +142,7 @@ ds_tizen_blur_manager_create(struct wl_display *display)
 
     wl_signal_init(&blur_manager->events.destroy);
     wl_signal_init(&blur_manager->events.new_blur);
+    wl_signal_init(&blur_manager->events.new_blur_behind);
 
     ds_inf("Global created: tizen_blur_manager(%p)", blur_manager);
 
@@ -102,17 +150,17 @@ ds_tizen_blur_manager_create(struct wl_display *display)
 }
 
 WL_EXPORT void
-ds_tizen_blur_manager_add_destroy_listener(struct ds_tizen_blur_manager *blur,
+ds_tizen_blur_manager_add_destroy_listener(struct ds_tizen_blur_manager *blur_manager,
         struct wl_listener *listener)
 {
-    wl_signal_add(&blur->events.destroy, listener);
+    wl_signal_add(&blur_manager->events.destroy, listener);
 }
 
 WL_EXPORT void
-ds_tizen_blur_manager_add_new_blur_listener(struct ds_tizen_blur_manager *blur,
+ds_tizen_blur_manager_add_new_blur_listener(struct ds_tizen_blur_manager *blur_manager,
         struct wl_listener *listener)
 {
-    wl_signal_add(&blur->events.new_blur, listener);
+    wl_signal_add(&blur_manager->events.new_blur, listener);
 }
 
 WL_EXPORT void
@@ -141,6 +189,71 @@ ds_tizen_blur_get_state(struct ds_tizen_blur *blur)
     return &blur->current;
 }
 
+WL_EXPORT void
+ds_tizen_blur_add_new_rectangle_listener(struct ds_tizen_blur *blur,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur->events.new_rectangle, listener);
+}
+
+WL_EXPORT void
+ds_tizen_blur_rectangle_add_destroy_listener(struct ds_tizen_blur_rectangle *blur_rectangle,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur_rectangle->events.destroy, listener);
+}
+
+WL_EXPORT void
+ds_tizen_blur_rectangle_get_geometry(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *x, int *y, int *width, int *height)
+{
+    if (x) *x = blur_rectangle->x;
+    if (y) *y = blur_rectangle->y;
+    if (width) *width = blur_rectangle->width;
+    if (height) *height = blur_rectangle->height;
+}
+
+WL_EXPORT void
+ds_tizen_blur_rectangle_get_corner_radius(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *rx, int *ry)
+{
+    if (rx) *rx = blur_rectangle->rx;
+    if (ry) *ry = blur_rectangle->ry;
+}
+
+WL_EXPORT void
+ds_tizen_blur_manager_add_new_blur_behind_listener(struct ds_tizen_blur_manager *blur_manager,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur_manager->events.new_blur_behind, listener);
+}
+
+WL_EXPORT void
+ds_tizen_blur_behind_add_destroy_listener(struct ds_tizen_blur_behind *blur_behind,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur_behind->events.destroy, listener);
+}
+
+WL_EXPORT void
+ds_tizen_blur_behind_add_commit_listener(struct ds_tizen_blur_behind *blur_behind,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur_behind->events.commit, listener);
+}
+
+WL_EXPORT struct ds_surface *
+ds_tizen_blur_behind_get_surface(struct ds_tizen_blur_behind *blur_behind)
+{
+    return blur_behind->surface;
+}
+
+WL_EXPORT struct ds_tizen_blur_behind_state *
+ds_tizen_blur_behind_get_state(struct ds_tizen_blur_behind *blur_behind)
+{
+    return &blur_behind->current;
+}
+
 static void
 blur_manager_handle_display_destroy(struct wl_listener *listener, void *data)
 {
@@ -150,7 +263,7 @@ blur_manager_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: blur_manager(%p)", blur_manager);
 
-    wl_signal_emit_mutable(&blur_manager->events.destroy, blur_manager);
+    wl_signal_emit(&blur_manager->events.destroy, blur_manager);
     wl_list_remove(&blur_manager->destroy.link);
     wl_global_destroy(blur_manager->global);
     free(blur_manager);
@@ -194,10 +307,129 @@ blur_handle_set_radius(struct wl_client *client, struct wl_resource *resource,
     blur->pending.committed |= DS_TIZEN_BLUR_STATE_RADIUS;
 }
 
+static void
+blur_rectangle_handle_destroy(struct wl_client *client, struct wl_resource *resource)
+{
+    wl_resource_destroy(resource);
+}
+
+static const struct wtz_blur_rectangle_interface blur_rectangle_impl = {
+   blur_rectangle_handle_destroy,
+};
+
+static void
+blur_rectangle_destroy(struct ds_tizen_blur_rectangle *blur_rectangle)
+{
+    ds_inf("blur_rectangle_destroy (blur_rectangle:%p)", blur_rectangle);
+
+    wl_signal_emit(&blur_rectangle->events.destroy, blur_rectangle);
+
+    if (blur_rectangle->listener.blur_destroy.notify)
+        wl_list_remove(&blur_rectangle->listener.blur_destroy.link);
+
+    if (blur_rectangle->blur)
+        wl_list_remove(&blur_rectangle->link);
+
+    free(blur_rectangle);
+}
+
+static void
+blur_rectangle_handle_resource_destroy(struct wl_resource *resource)
+{
+    struct ds_tizen_blur_rectangle *blur_rectangle;
+
+    blur_rectangle = wl_resource_get_user_data(resource);
+
+    ds_inf("blur_rectangle_handle_resource_destroy (blur_rectangle:%p)", blur_rectangle);
+
+    if (blur_rectangle->blur) {
+        blur_rectangle->resource = NULL;
+        blur_rectangle->pending = true;
+        blur_rectangle->blur->pending.committed |= DS_TIZEN_BLUR_STATE_RECTANGLE;
+        return;
+    }
+
+    blur_rectangle_destroy(blur_rectangle);
+}
+
+static void
+blur_rectangle_handle_blur_destroy(struct wl_listener *listener, void *data)
+{
+    struct ds_tizen_blur_rectangle *blur_rectangle;
+
+    blur_rectangle = wl_container_of(listener, blur_rectangle, listener.blur_destroy);
+
+    blur_rectangle->listener.blur_destroy.notify = NULL;
+    wl_list_remove(&blur_rectangle->listener.blur_destroy.link);
+
+    blur_rectangle->blur = NULL;
+    wl_list_remove(&blur_rectangle->link);
+
+    if (!blur_rectangle->resource)
+        blur_rectangle_destroy(blur_rectangle);
+}
+
+static void
+blur_handle_create_rectangle(struct wl_client *wl_client, struct wl_resource *resource,
+        uint32_t id, int32_t x, int32_t y,
+        int32_t width, int32_t height, int32_t rx, int32_t ry)
+{
+    struct ds_tizen_blur *blur;
+    struct ds_tizen_blur_rectangle *blur_rectangle;
+
+    ds_inf("tizen_blur: create_rectangle");
+
+    blur = wl_resource_get_user_data(resource);
+    if (!blur) {
+        wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
+                "invalid blur resource:%u",
+                (unsigned int)wl_resource_get_id(resource));
+        return;
+    }
+
+    blur_rectangle = calloc(1, sizeof *blur_rectangle);
+    if (blur_rectangle == NULL) {
+        ds_err("calloc() failed. tizen_blur_rectangle");
+        wl_client_post_no_memory(wl_client);
+        return;
+    }
+
+    blur_rectangle->resource = wl_resource_create(wl_client, &wtz_blur_rectangle_interface,
+           wl_resource_get_version(resource), id);
+    if (blur_rectangle->resource == NULL) {
+        ds_err("tizen_blur_rectangle : wl_resource_create() failed.");
+        free(blur_rectangle);
+        wl_client_post_no_memory(wl_client);
+        return;
+    }
+
+    wl_resource_set_implementation(blur_rectangle->resource, &blur_rectangle_impl, blur_rectangle,
+        blur_rectangle_handle_resource_destroy);
+
+    blur_rectangle->listener.blur_destroy.notify = blur_rectangle_handle_blur_destroy;
+    ds_tizen_blur_add_destroy_listener(blur, &blur_rectangle->listener.blur_destroy);
+
+    blur_rectangle->x = x;
+    blur_rectangle->y = y;
+    blur_rectangle->width = width;
+    blur_rectangle->height = height;
+    blur_rectangle->rx = rx;
+    blur_rectangle->ry = ry;
+
+    blur_rectangle->blur = blur;
+    wl_list_insert(&blur->rectangles, &blur_rectangle->link);
+
+    wl_signal_init(&blur_rectangle->events.destroy);
+
+    blur_rectangle->pending = true;
+    blur->pending.committed |= DS_TIZEN_BLUR_STATE_RECTANGLE;
+}
+
 static const struct wtz_blur_interface blur_impl = {
    blur_handle_destroy,
    blur_handle_set_region,
    blur_handle_set_radius,
+   blur_handle_create_rectangle,
 };
 
 static void
@@ -205,7 +437,7 @@ blur_destroy(struct ds_tizen_blur *blur)
 {
     ds_inf("blur_destroy (blur:%p)", blur);
 
-    wl_signal_emit_mutable(&blur->events.destroy, blur);
+    wl_signal_emit(&blur->events.destroy, blur);
 
     if (blur->listener.surface_commit.notify)
         wl_list_remove(&blur->listener.surface_commit.link);
@@ -239,6 +471,7 @@ static void
 blur_handle_surface_commit(struct wl_listener *listener, void *data)
 {
     struct ds_tizen_blur *blur;
+    struct ds_tizen_blur_rectangle *blur_rectangle, *tmp;
 
     blur = wl_container_of(listener, blur, listener.surface_commit);
 
@@ -247,6 +480,17 @@ blur_handle_surface_commit(struct wl_listener *listener, void *data)
         return;
     }
 
+    wl_list_for_each_safe(blur_rectangle, tmp, &blur->rectangles, link) {
+        if (!blur_rectangle->pending) continue;
+
+        blur_rectangle->pending = false;
+
+        if (blur_rectangle->resource)
+            wl_signal_emit(&blur->events.new_rectangle, blur_rectangle);
+        else
+            blur_rectangle_destroy(blur_rectangle);
+    }
+
     if (blur->pending.committed == DS_TIZEN_BLUR_STATE_NONE) {
         blur->current.committed = DS_TIZEN_BLUR_STATE_NONE;
         return;
@@ -261,7 +505,7 @@ blur_handle_surface_commit(struct wl_listener *listener, void *data)
     blur->current.committed = blur->pending.committed;
     blur->pending.committed = DS_TIZEN_BLUR_STATE_NONE;
 
-    wl_signal_emit_mutable(&blur->events.commit, blur);
+    wl_signal_emit(&blur->events.commit, blur);
 }
 
 static void
@@ -359,10 +603,187 @@ blur_manager_handle_get_blur(struct wl_client *wl_client,
 
     blur->surface = surface;
 
+    wl_list_init(&blur->rectangles);
+
     wl_signal_init(&blur->events.destroy);
     wl_signal_init(&blur->events.commit);
+    wl_signal_init(&blur->events.new_rectangle);
+
+    wl_signal_emit(&client->blur_manager->events.new_blur, blur);
+}
+
+static void
+blur_behind_destroy(struct ds_tizen_blur_behind *blur_behind)
+{
+    ds_inf("blur_behind_destroy (blur_behind:%p)", blur_behind);
+
+    wl_signal_emit(&blur_behind->events.destroy, blur_behind);
+
+    if (blur_behind->surface) {
+        wl_list_remove(&blur_behind->listener.surface_commit.link);
+        ds_addon_finish(&blur_behind->surface_addon);
+    }
+
+    free(blur_behind);
+}
+
+static void
+blur_behind_handle_resource_destroy(struct wl_resource *resource)
+{
+    struct ds_tizen_blur_behind *blur_behind;
+
+    blur_behind = wl_resource_get_user_data(resource);
 
-    wl_signal_emit_mutable(&client->blur_manager->events.new_blur, blur);
+    ds_inf("blur_behind_handle_resource_destroy (blur_behind:%p)", blur_behind);
+
+    if (blur_behind->surface) {
+        blur_behind->resource = NULL;
+        return;
+    }
+
+    blur_behind_destroy(blur_behind);
+}
+
+static void
+blur_behind_handle_surface_commit(struct wl_listener *listener, void *data)
+{
+    struct ds_tizen_blur_behind *blur_behind;
+
+    blur_behind = wl_container_of(listener, blur_behind, listener.surface_commit);
+
+    if (!blur_behind->resource) {
+        blur_behind_destroy(blur_behind);
+        return;
+    }
+
+    if (blur_behind->pending.committed == DS_TIZEN_BLUR_BEHIND_STATE_NONE) {
+        blur_behind->current.committed = DS_TIZEN_BLUR_BEHIND_STATE_NONE;
+        return;
+    }
+
+    if (blur_behind->pending.committed & DS_TIZEN_BLUR_BEHIND_STATE_RADIUS)
+        blur_behind->current.radius = blur_behind->pending.radius;
+
+    blur_behind->current.committed = blur_behind->pending.committed;
+    blur_behind->pending.committed = DS_TIZEN_BLUR_BEHIND_STATE_NONE;
+
+    wl_signal_emit(&blur_behind->events.commit, blur_behind);
+}
+
+static void
+blur_behind_handle_surface_destroy(struct ds_addon *addon)
+{
+    struct ds_tizen_blur_behind *blur_behind;
+
+    blur_behind = wl_container_of(addon, blur_behind, surface_addon);
+
+    wl_list_remove(&blur_behind->listener.surface_commit.link);
+
+    ds_addon_finish(&blur_behind->surface_addon);
+    blur_behind->surface = NULL;
+
+    if (!blur_behind->resource)
+        blur_behind_destroy(blur_behind);
+}
+
+static struct ds_addon_interface blur_behind_addon_impl = {
+       .name = "ds_tizen_blur_behind",
+       .destroy = blur_behind_handle_surface_destroy,
+};
+
+static struct ds_tizen_blur_behind *
+blur_behind_client_get_from_surface(struct ds_tizen_blur_client *client, struct ds_surface *surface)
+{
+   struct ds_addon *addon;
+   struct ds_tizen_blur_behind *blur_behind;
+
+    addon = ds_addon_find(&surface->addons, client, &blur_behind_addon_impl);
+    if (!addon) return NULL;
+
+    return wl_container_of(addon, blur_behind, surface_addon);
+}
+
+static void
+blur_behind_handle_destroy(struct wl_client *client, struct wl_resource *resource)
+{
+    wl_resource_destroy(resource);
+}
+
+static void
+blur_behind_handle_set_radius(struct wl_client *client, struct wl_resource *resource,
+        uint32_t radius)
+{
+    struct ds_tizen_blur_behind *blur_behind;
+
+    blur_behind = wl_resource_get_user_data(resource);
+
+    blur_behind->pending.radius = radius;
+    blur_behind->pending.committed |= DS_TIZEN_BLUR_BEHIND_STATE_RADIUS;
+}
+
+static const struct wtz_blur_behind_interface blur_behind_impl = {
+   blur_behind_handle_destroy,
+   blur_behind_handle_set_radius,
+};
+
+static void
+blur_manager_handle_get_blur_behind(struct wl_client *wl_client,
+        struct wl_resource *resource,
+        uint32_t id, struct wl_resource *surface_resource)
+{
+    struct ds_tizen_blur_client *client;
+    struct ds_surface *surface;
+    struct ds_tizen_blur_behind *blur_behind;
+
+    ds_inf("tizen_blur: get_blur");
+
+    client = wl_resource_get_user_data(resource);
+
+    surface = ds_surface_from_resource(surface_resource);
+    if (!surface) {
+        wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
+                "invalid wl_surface resource:%u",
+                (unsigned int)wl_resource_get_id(surface_resource));
+        return;
+    }
+
+    blur_behind = blur_behind_client_get_from_surface(client, surface);
+    if (blur_behind) {
+        wl_resource_post_error(resource, WTZ_BLUR_MANAGER_ERROR_BLUR_EXISTS,
+                "blend object already exists");
+        return;
+    }
+
+    blur_behind = calloc(1, sizeof *blur_behind);
+    if (blur_behind == NULL) {
+        ds_err("calloc() failed. tizen_blur");
+        wl_client_post_no_memory(wl_client);
+        return;
+    }
+
+    blur_behind->resource = wl_resource_create(wl_client, &wtz_blur_behind_interface,
+           wl_resource_get_version(resource), id);
+    if (blur_behind->resource == NULL) {
+        ds_err("tizen_blur : wl_resource_create() failed.");
+        free(blur_behind);
+        wl_client_post_no_memory(wl_client);
+        return;
+    }
+
+    wl_resource_set_implementation(blur_behind->resource, &blur_behind_impl, blur_behind,
+        blur_behind_handle_resource_destroy);
+
+    ds_addon_init(&blur_behind->surface_addon, &surface->addons, client, &blur_behind_addon_impl);
+
+    blur_behind->listener.surface_commit.notify = blur_behind_handle_surface_commit;
+    ds_surface_add_commit_listener(surface, &blur_behind->listener.surface_commit);
+
+    blur_behind->surface = surface;
+
+    wl_signal_init(&blur_behind->events.destroy);
+    wl_signal_init(&blur_behind->events.commit);
+
+    wl_signal_emit(&client->blur_manager->events.new_blur_behind, blur_behind);
 }
 
 static void
@@ -376,6 +797,7 @@ static const struct wtz_blur_manager_interface blur_manager_impl =
 {
     blur_manager_handle_destroy,
     blur_manager_handle_get_blur,
+    blur_manager_handle_get_blur_behind,
 };
 
 static void
@@ -422,7 +844,5 @@ blur_manager_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &blur_manager_impl, client,
             blur_manager_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&blur_manager->clients, &client->link);
 }

diff --git a/src/clipboard/clipboard.c b/src/clipboard/clipboard.c
index da409c3..bfa9595 100644 (file)
--- a/src/clipboard/clipboard.c
+++ b/src/clipboard/clipboard.c
@@ -219,7 +219,7 @@ clipboard_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: clipboard(%p)", clipboard);
 
-    wl_signal_emit_mutable(&clipboard->events.destroy, clipboard);
+    wl_signal_emit(&clipboard->events.destroy, clipboard);
     wl_list_remove(&clipboard->destroy.link);
     wl_global_destroy(clipboard->global);
     free(clipboard);
@@ -261,7 +261,7 @@ clipboard_handle_show(struct wl_client *wl_client,
         return;
     }
 
-    wl_signal_emit_mutable(&client->clipboard->events.show, surface);
+    wl_signal_emit(&client->clipboard->events.show, surface);
 }
 
 static void
@@ -284,7 +284,7 @@ clipboard_handle_hide(struct wl_client *wl_client,
         return;
     }
 
-    wl_signal_emit_mutable(&client->clipboard->events.hide, surface);
+    wl_signal_emit(&client->clipboard->events.hide, surface);
 }
 
 static void
@@ -298,7 +298,7 @@ clipboard_handle_set_data_only(struct wl_client *wl_client,
     client = wl_resource_get_user_data(resource);
     client->data_only = set;
 
-    wl_signal_emit_mutable(&client->clipboard->events.set_data_only, client);
+    wl_signal_emit(&client->clipboard->events.set_data_only, client);
 }
 
 static const struct tizen_clipboard_interface clipboard_impl =

diff --git a/src/display_policy/display_policy.c b/src/display_policy/display_policy.c
index 0ba779c..558e741 100644 (file)
--- a/src/display_policy/display_policy.c
+++ b/src/display_policy/display_policy.c
@@ -33,10 +33,6 @@ struct ds_tizen_display_policy_client
 
     struct wl_list infos;
 
-   struct {
-        struct wl_signal destroy;
-    } events;
-
     struct wl_list link; // ds_tizen_display_policy::clients
 };
 
@@ -48,6 +44,10 @@ struct ds_tizen_display_policy_info
 
     int32_t brightness_value;
 
+    struct {
+        struct wl_signal destroy;
+    } events;
+
     struct wl_list link; // ds_tizen_display_policy_client::infos
 };
 
@@ -117,7 +117,7 @@ ds_tizen_display_policy_info_add_destroy_listener(
         struct ds_tizen_display_policy_info *info,
         struct wl_listener *listener)
 {
-    wl_signal_add(&info->client->events.destroy, listener);
+    wl_signal_add(&info->events.destroy, listener);
 }
 
 WL_EXPORT struct ds_surface *
@@ -177,6 +177,8 @@ tizen_display_policy_client_get_info(struct ds_tizen_display_policy_client *clie
     info->client = client;
     info->surface = surface;
 
+    wl_signal_init(&info->events.destroy);
+
     wl_list_insert(&client->infos, &info->link);
 
     return info;
@@ -191,7 +193,7 @@ display_policy_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: display_policy(%p)", display_policy);
 
-    wl_signal_emit_mutable(&display_policy->events.destroy, display_policy);
+    wl_signal_emit(&display_policy->events.destroy, display_policy);
     wl_list_remove(&display_policy->destroy.link);
     wl_global_destroy(display_policy->global);
     free(display_policy);
@@ -236,7 +238,7 @@ display_policy_handle_set_brightness(struct wl_client *wl_client,
 
     info->brightness_value = brightness_value;
 
-    wl_signal_emit_mutable(&client->display_policy->events.set_brightness, info);
+    wl_signal_emit(&client->display_policy->events.set_brightness, info);
 }
 
 static const struct tizen_display_policy_interface display_policy_impl =
@@ -256,7 +258,7 @@ _tizen_display_policy_client_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_display_policy_client_handle_destroy (client:%p)", client);
 
     wl_list_for_each_safe(info, tmp, &client->infos, link) {
-        wl_signal_emit_mutable(&client->events.destroy, info);
+        wl_signal_emit(&info->events.destroy, info);
         wl_list_remove(&info->link);
         free(info);
     }
@@ -299,7 +301,5 @@ display_policy_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &display_policy_impl, client,
             _tizen_display_policy_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&display_policy->clients, &client->link);
 }

diff --git a/src/dpms/dpms.c b/src/dpms/dpms.c
index d3e1663..518f2be 100644 (file)
--- a/src/dpms/dpms.c
+++ b/src/dpms/dpms.c
@@ -166,7 +166,7 @@ dpms_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("global destroy : tizen_dpms_manager(%p)", dpms);
 
-    wl_signal_emit_mutable(&dpms->events.destroy, dpms);
+    wl_signal_emit(&dpms->events.destroy, dpms);
     wl_list_remove(&dpms->destroy.link);
     if (dpms->res)
         wl_resource_set_user_data(dpms->res, NULL);
@@ -178,8 +178,14 @@ static void
 _tizen_dpms_manager_handle_destroy(struct wl_client *client,
         struct wl_resource *resource)
 {
+    struct ds_tizen_dpms *dpms;
+
+    dpms = wl_resource_get_user_data(resource);
+
     ds_inf("tizen_dpms_manager cb_destroy (res:%p)", resource);
     wl_resource_destroy(resource);
+
+    wl_signal_emit(&dpms->events.destroy, dpms);
 }
 
 static void
@@ -206,7 +212,7 @@ _tizen_dpms_manager_handle_set_dpms(struct wl_client *client,
         .mode = ds_mode,
     };
 
-    wl_signal_emit_mutable(&dpms->events.set_dpms, &event);
+    wl_signal_emit(&dpms->events.set_dpms, &event);
 }
 
 static void
@@ -219,7 +225,7 @@ _tizen_dpms_manager_handle_get_dpms(struct wl_client *client,
     dpms = wl_resource_get_user_data(resource);
     output = wl_resource_get_user_data(wl_output);
 
-    wl_signal_emit_mutable(&dpms->events.get_dpms, output);
+    wl_signal_emit(&dpms->events.get_dpms, output);
 }
 
 static const struct tizen_dpms_manager_interface dpms_impl =

diff --git a/src/embedded_compositor/embedded_compositor.c b/src/embedded_compositor/embedded_compositor.c
index 0a802fa..29f3bb9 100644 (file)
--- a/src/embedded_compositor/embedded_compositor.c
+++ b/src/embedded_compositor/embedded_compositor.c
@@ -86,7 +86,7 @@ embedded_compositor_handle_display_destroy(struct wl_listener *listener, void *d
 
     ds_inf("Global destroy: embedded_compositor(%p)", embedded_compositor);
 
-    wl_signal_emit_mutable(&embedded_compositor->events.destroy, embedded_compositor);
+    wl_signal_emit(&embedded_compositor->events.destroy, embedded_compositor);
     wl_list_remove(&embedded_compositor->destroy.link);
     wl_global_destroy(embedded_compositor->global);
     free(embedded_compositor);

diff --git a/src/eom/eom.c b/src/eom/eom.c
index ce3e627..030ef84 100644 (file)
--- a/src/eom/eom.c
+++ b/src/eom/eom.c
@@ -457,7 +457,7 @@ ds_tizen_eom_send_output_info(struct ds_tizen_eom *eom,
     ds_inf("send_output_info - id:%d, type:%d, mode:%d, conn:%d, w:%d, h:%d, w_mm:%d, h_mm:%d",
         output->id, output->type, output->mode, output->status,
         output->width, output->height, output->physical_width, output->physical_height);
-    
+
 }
 
 WL_EXPORT void
@@ -547,7 +547,7 @@ _ds_tizen_eom_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("global destroy : eom(%p)", eom);
 
-    wl_signal_emit_mutable(&eom->events.destroy, eom);
+    wl_signal_emit(&eom->events.destroy, eom);
     wl_list_remove(&eom->destroy.link);
     wl_global_destroy(eom->global);
 
@@ -601,7 +601,7 @@ _ds_tizen_eom_handle_set_attribute(struct wl_client *client,
         .attribute = eom_attribute,
     };
 
-    wl_signal_emit_mutable(&eom->events.set_attribute, &event);
+    wl_signal_emit(&eom->events.set_attribute, &event);
 }
 
 static void
@@ -630,7 +630,7 @@ _ds_tizen_eom_handle_set_shell_window(struct wl_client *client,
         .surface = surface,
     };
 
-    wl_signal_emit_mutable(&eom->events.set_shell_window, &event);
+    wl_signal_emit(&eom->events.set_shell_window, &event);
 }
 
 static void
@@ -683,7 +683,7 @@ _ds_tizen_eom_client_cb_destroy(struct wl_resource *resource)
 
     eom_client = wl_resource_get_user_data(resource);
 
-    wl_signal_emit_mutable(&eom_client->eom->events.client_destroy, eom_client);
+    wl_signal_emit(&eom_client->eom->events.client_destroy, eom_client);
     wl_list_remove(&eom_client->link);
     free(eom_client);
 }

diff --git a/src/global_resource/global_resource.c b/src/global_resource/global_resource.c
index d233106..4a05c60 100644 (file)
--- a/src/global_resource/global_resource.c
+++ b/src/global_resource/global_resource.c
@@ -35,10 +35,6 @@ struct ds_tizen_global_resource_client
 
     struct wl_list infos;
 
-    struct {
-        struct wl_signal destroy;
-    } events;
-
     struct wl_list link; // ds_tizen_global_resource::clients
 };
 
@@ -52,6 +48,10 @@ struct ds_tizen_global_resource_info
 
     uint32_t universal_id;
 
+    struct {
+        struct wl_signal destroy;
+    } events;
+
     struct wl_list link; // ds_tizen_global_resource_client::infos
 };
 
@@ -122,7 +122,7 @@ ds_tizen_global_resource_info_add_destroy_listener(
         struct ds_tizen_global_resource_info *info,
         struct wl_listener *listener)
 {
-    wl_signal_add(&info->client->events.destroy, listener);
+    wl_signal_add(&info->events.destroy, listener);
 }
 
 WL_EXPORT struct ds_surface *
@@ -174,6 +174,8 @@ tizen_global_resource_client_get_info(
     info->client = client;
     info->surface = surface;
 
+    wl_signal_init(&info->events.destroy);
+
     wl_list_insert(&client->infos, &info->link);
 
     return info;
@@ -188,7 +190,7 @@ resource_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: resource(%p)", global_resource);
 
-    wl_signal_emit_mutable(&global_resource->events.destroy, global_resource);
+    wl_signal_emit(&global_resource->events.destroy, global_resource);
     wl_list_remove(&global_resource->destroy.link);
     wl_global_destroy(global_resource->global);
     free(global_resource);
@@ -215,7 +217,7 @@ _tizen_surface_handle_destroy(struct wl_resource *resource)
 
     ds_inf("_tizen_surface_handle_destroy (info:%p)", info);
 
-    wl_signal_emit_mutable(&info->client->events.destroy, info);
+    wl_signal_emit(&info->events.destroy, info);
     wl_list_remove(&info->link);
     free(info);
 }
@@ -258,7 +260,7 @@ surface_handle_get_tizen_global_resource(struct wl_client *wl_client,
     wl_resource_set_implementation(info->resource, &resource_impl, info,
         _tizen_surface_handle_destroy);
 
-    wl_signal_emit_mutable(&client->global_resource->events.get_resource_info, info);
+    wl_signal_emit(&client->global_resource->events.get_resource_info, info);
 
     tizen_resource_send_resource_id(info->resource, info->universal_id);
 }
@@ -296,7 +298,7 @@ _tizen_global_resource_client_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_global_resource_client_handle_destroy (client:%p)", client);
 
     wl_list_for_each_safe(info, tmp, &client->infos, link) {
-        wl_signal_emit_mutable(&info->client->events.destroy, info);
+        wl_signal_emit(&info->events.destroy, info);
         wl_list_remove(&info->link);
         free(info);
     }
@@ -339,7 +341,5 @@ resource_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &surface_impl, client,
             _tizen_global_resource_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&global_resource->clients, &client->link);
 }

diff --git a/src/hwc/hwc.c b/src/hwc/hwc.c
index 552632a..d618daf 100644 (file)
--- a/src/hwc/hwc.c
+++ b/src/hwc/hwc.c
@@ -31,9 +31,7 @@ struct ds_tizen_hwc_client
     struct wl_resource *resource;
     struct wl_client *wl_client;
 
-    struct {
-        struct wl_signal destroy;
-    } events;
+    struct wl_list feedbacks;
 
     struct wl_list link;
 };
@@ -52,6 +50,8 @@ struct ds_tizen_hwc_commit_feedback
     struct {
         struct wl_signal destroy;
     } events;
+
+    struct wl_list link;
 };
 
 static void
@@ -84,7 +84,9 @@ _hwc_commit_feedback_cb_resource_destroy(struct wl_resource *commit_feedback_res
         commit_feedback->listener.surface_destroy.notify = NULL;
     }
 
-    wl_signal_emit_mutable(&commit_feedback->events.destroy, commit_feedback);
+    wl_signal_emit(&commit_feedback->events.destroy, commit_feedback);
+
+    wl_list_remove(&commit_feedback->link);
 
     free(commit_feedback);
 }
@@ -131,7 +133,9 @@ hwc_handle_create_commit_feedback(struct wl_client *client,
 
     wl_signal_init(&commit_feedback->events.destroy);
 
-    wl_signal_emit_mutable(&hwc_client->hwc->events.new_commit_feedback, commit_feedback);
+    wl_signal_emit(&hwc_client->hwc->events.new_commit_feedback, commit_feedback);
+
+    wl_list_insert(&hwc_client->feedbacks, &commit_feedback->link);
 }
 
 static void
@@ -151,11 +155,15 @@ static void
 _tizen_hwc_client_handle_resource_destroy(struct wl_resource *resource)
 {
     struct ds_tizen_hwc_client *client;
+    struct ds_tizen_hwc_commit_feedback *commit_feedback, *tmp;
 
     client = wl_resource_get_user_data(resource);
 
     ds_inf("_tizen_hwc_client_handle_destroy (client:%p)", client);
 
+    wl_list_for_each_safe(commit_feedback, tmp, &client->feedbacks, link)
+        wl_resource_destroy(commit_feedback->resource);
+
     wl_list_remove(&client->link);
     free(client);
 }
@@ -191,7 +199,7 @@ hwc_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(hwc_client->resource, &hwc_impl, hwc_client,
             _tizen_hwc_client_handle_resource_destroy);
 
-    wl_signal_init(&hwc_client->events.destroy);
+    wl_list_init(&hwc_client->feedbacks);
 
     wl_list_insert(&hwc->clients, &hwc_client->link);
 }
@@ -200,14 +208,21 @@ static void
 hwc_handle_display_destroy(struct wl_listener *listener, void *data)
 {
     struct ds_tizen_hwc *hwc;
+    struct ds_tizen_hwc_client *client, *tmp;
 
     hwc = wl_container_of(listener, hwc, destroy);
 
     ds_inf("Global destroy: hwc(%p)", hwc);
 
-    wl_signal_emit_mutable(&hwc->events.destroy, hwc);
     wl_list_remove(&hwc->destroy.link);
+
+    wl_list_for_each_safe(client, tmp, &hwc->clients, link)
+        wl_resource_destroy(client->resource);
+
     wl_global_destroy(hwc->global);
+
+    wl_signal_emit(&hwc->events.destroy, hwc);
+
     free(hwc);
 }
 

diff --git a/src/indicator/indicator.c b/src/indicator/indicator.c
index b0bb21c..7b8cf67 100644 (file)
--- a/src/indicator/indicator.c
+++ b/src/indicator/indicator.c
@@ -281,7 +281,7 @@ indicator_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: indicator(%p)", indicator);
 
-    wl_signal_emit_mutable(&indicator->events.destroy, indicator);
+    wl_signal_emit(&indicator->events.destroy, indicator);
     wl_list_remove(&indicator->destroy.link);
     wl_global_destroy(indicator->global);
     free(indicator);
@@ -342,7 +342,7 @@ indicator_handle_set_state(struct wl_client *wl_client,
             surface, info->state, indicator_state);
         info->state = indicator_state;
 
-        wl_signal_emit_mutable(&client->indicator->events.change_state, surface);
+        wl_signal_emit(&client->indicator->events.change_state, surface);
     }
 }
 
@@ -391,7 +391,7 @@ indicator_handle_set_opacity_mode(struct wl_client *wl_client,
             surface, info->opacity_mode, opacity_mode);
         info->opacity_mode = opacity_mode;
 
-        wl_signal_emit_mutable(&client->indicator->events.change_opacity_mode, surface);
+        wl_signal_emit(&client->indicator->events.change_opacity_mode, surface);
     }
 }
 
@@ -431,7 +431,7 @@ indicator_handle_set_visible_type(struct wl_client *wl_client,
             surface, info->visible_type, visible_type);
         info->visible_type = visible_type;
 
-        wl_signal_emit_mutable(&client->indicator->events.change_visible_type, surface);
+        wl_signal_emit(&client->indicator->events.change_visible_type, surface);
     }
 }
 

diff --git a/src/input_devicemgr/input_devicemgr.c b/src/input_devicemgr/input_devicemgr.c
index 4a8236d..d76b1dc 100644 (file)
--- a/src/input_devicemgr/input_devicemgr.c
+++ b/src/input_devicemgr/input_devicemgr.c
@@ -272,7 +272,7 @@ tz_devicemgr_destroy(struct ds_tizen_input_devicemgr *tz_devicemgr)
     tz_devicemgr_ungrab_keyboard(tz_devicemgr);
     ds_seat_keyboard_grab_destroy(tz_devicemgr->grab);
 
-    wl_signal_emit_mutable(&tz_devicemgr->events.destroy, tz_devicemgr);
+    wl_signal_emit(&tz_devicemgr->events.destroy, tz_devicemgr);
     wl_list_remove(&tz_devicemgr->backend_destroy.link);
     wl_list_remove(&tz_devicemgr->seat_destroy.link);
     wl_list_remove(&tz_devicemgr->new_input.link);
@@ -818,7 +818,7 @@ device_manager_handle_pointer_warp(struct wl_client *client,
     ds_inf("Pointer warp. surface:%p, x:%.2f, y:%.2f", ds_event.surface,
             ds_event.x, ds_event.y);
 
-    wl_signal_emit_mutable(&tz_devicemgr->events.pointer_warp, &ds_event);
+    wl_signal_emit(&tz_devicemgr->events.pointer_warp, &ds_event);
     ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
 
 finish:
@@ -964,7 +964,7 @@ tz_devicemgr_init_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
             tz_devicemgr->devices.kbd->ref++;
         }
         if (dev->created) {
-            wl_signal_emit_mutable(&tz_devicemgr->backend->events.new_input,
+            wl_signal_emit(&tz_devicemgr->backend->events.new_input,
                     dev->input_device);
         }
     }
@@ -976,7 +976,7 @@ tz_devicemgr_init_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
             tz_devicemgr->devices.ptr->ref++;
         }
         if (dev->created) {
-            wl_signal_emit_mutable(&tz_devicemgr->backend->events.new_input,
+            wl_signal_emit(&tz_devicemgr->backend->events.new_input,
                     dev->input_device);
         }
     }
@@ -988,7 +988,7 @@ tz_devicemgr_init_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
             tz_devicemgr->devices.touch->ref++;
         }
         if (dev->created) {
-            wl_signal_emit_mutable(&tz_devicemgr->backend->events.new_input,
+            wl_signal_emit(&tz_devicemgr->backend->events.new_input,
                     dev->input_device);
         }
     }
@@ -1242,7 +1242,7 @@ tz_devicemgr_generate_touch_move(struct ds_input_device *device, double x, doubl
     ds_event.y = y;
     ds_inf("Generate touch motion. touch:%p, id:%d (%d, %d)", touch, ds_event.id, x, y);
 
-    wl_signal_emit_mutable(&touch->events.motion, &ds_event);
+    wl_signal_emit(&touch->events.motion, &ds_event);
 
     return true;
 }
@@ -1271,7 +1271,7 @@ tz_devicemgr_generate_touch_down(struct ds_input_device *device, double x, doubl
     ds_event.y = y;
     ds_inf("Generate touch down. touch:%p, id:%d (%d, %d)", touch, ds_event.id, x, y);
 
-    wl_signal_emit_mutable(&touch->events.down, &ds_event);
+    wl_signal_emit(&touch->events.down, &ds_event);
 
     return true;
 }
@@ -1297,7 +1297,7 @@ tz_devicemgr_generate_touch_up(struct ds_input_device *device, uint32_t finger)
     ds_event.id = finger;
     ds_inf("Generate touch up. touch:%p, id:%d", touch, ds_event.id);
 
-    wl_signal_emit_mutable(&touch->events.up, &ds_event);
+    wl_signal_emit(&touch->events.up, &ds_event);
 
     return true;
 }
@@ -1324,7 +1324,7 @@ tz_devicemgr_generate_mouse_move(struct ds_input_device *device, double x, doubl
     ds_event.delta_y = y;
     ds_inf("Generate mouse motion. pointer:%p, x:%f, y:%f", pointer, ds_event.delta_x, ds_event.delta_y);
 
-    wl_signal_emit_mutable(&pointer->events.motion, &ds_event);
+    wl_signal_emit(&pointer->events.motion, &ds_event);
 
     return true;
 }
@@ -1354,7 +1354,7 @@ tz_devicemgr_generate_mouse_button(struct ds_input_device *device, uint32_t butt
         ds_event.state = DS_BUTTON_RELEASED;
     ds_inf("Generate mouse button. pointer:%p, button:%d, state:%s", pointer, ds_event.button, state ? "PRESSED" : "RELEASED");
 
-    wl_signal_emit_mutable(&pointer->events.button, &ds_event);
+    wl_signal_emit(&pointer->events.button, &ds_event);
 
     return true;
 }

diff --git a/src/input_method/input_method.c b/src/input_method/input_method.c
index 93f9a0c..d2e6cbb 100644 (file)
--- a/src/input_method/input_method.c
+++ b/src/input_method/input_method.c
@@ -83,7 +83,7 @@ input_method_mgr_handle_display_destroy(struct wl_listener *listener, void *data
 
     ds_inf("Global destroy: input_method_mgr(%p)", input_method_mgr);
 
-    wl_signal_emit_mutable(&input_method_mgr->events.destroy, input_method_mgr);
+    wl_signal_emit(&input_method_mgr->events.destroy, input_method_mgr);
     wl_list_remove(&input_method_mgr->destroy.link);
 
     wl_global_destroy(input_method_mgr->global);
@@ -105,7 +105,7 @@ input_method_mgr_handle_set_transient_for(struct wl_client *wl_client,
     ds_event.im_mgr = input_method_mgr;
     ds_event.pid_parent = parent_pid;
     ds_event.pid_child = child_pid;
-    wl_signal_emit_mutable(&input_method_mgr->events.set_transient_for, &ds_event);
+    wl_signal_emit(&input_method_mgr->events.set_transient_for, &ds_event);
 }
 
 static const struct zwp_input_method_manager_v1_interface input_method_mgr_impl =
@@ -194,7 +194,7 @@ context_destroy(struct ds_tizen_input_method_context *context)
 {
     ds_inf("input_method_context(%p) destroy", context);
 
-    wl_signal_emit_mutable(&context->events.destroy, context);
+    wl_signal_emit(&context->events.destroy, context);
 
     free(context);
 }
@@ -442,7 +442,7 @@ context_handle_commit_string(struct wl_client *client,
     ds_event.serial = serial;
     ds_event.text = text;
 
-    wl_signal_emit_mutable(&context->events.commit_string, &ds_event);
+    wl_signal_emit(&context->events.commit_string, &ds_event);
 }
 
 static void
@@ -461,7 +461,7 @@ context_handle_preedit_string(struct wl_client *client,
     ds_event.text = text;
     ds_event.commit = commit;
 
-    wl_signal_emit_mutable(&context->events.preedit_string, &ds_event);
+    wl_signal_emit(&context->events.preedit_string, &ds_event);
 }
 
 static void
@@ -480,7 +480,7 @@ context_handle_preedit_styling(struct wl_client *client,
     ds_event.length = length;
     ds_event.style = style;
 
-    wl_signal_emit_mutable(&context->events.preedit_styling, &ds_event);
+    wl_signal_emit(&context->events.preedit_styling, &ds_event);
 }
 
 static void
@@ -494,7 +494,7 @@ context_handle_preedit_cursor(struct wl_client *client,
 
     ds_event.im_context = context;
     ds_event.index = index;
-    wl_signal_emit_mutable(&context->events.preedit_styling, &ds_event);
+    wl_signal_emit(&context->events.preedit_styling, &ds_event);
 }
 
 static void
@@ -509,7 +509,7 @@ context_handle_delete_surrounding_text(struct wl_client *client,
     ds_event.im_context = context;
     ds_event.index = index;
     ds_event.length = length;
-    wl_signal_emit_mutable(&context->events.delete_surrounding_text, &ds_event);
+    wl_signal_emit(&context->events.delete_surrounding_text, &ds_event);
 }
 
 static void
@@ -524,7 +524,7 @@ context_handle_cursor_position(struct wl_client *client,
     ds_event.im_context = context;
     ds_event.index = index;
     ds_event.anchor = anchor;
-    wl_signal_emit_mutable(&context->events.cursor_position, &ds_event);
+    wl_signal_emit(&context->events.cursor_position, &ds_event);
 }
 
 static void
@@ -538,7 +538,7 @@ context_handle_modifiers_map(struct wl_client *client,
 
     ds_event.im_context = context;
     ds_event.map = map;
-    wl_signal_emit_mutable(&context->events.modifiers_map, &ds_event);
+    wl_signal_emit(&context->events.modifiers_map, &ds_event);
 }
 
 static void
@@ -558,7 +558,7 @@ context_handle_keysym(struct wl_client *client, struct wl_resource *resource,
     ds_event.sym = sym;
     ds_event.state = state;
     ds_event.modifiers = modifiers;
-    wl_signal_emit_mutable(&context->events.keysym, &ds_event);
+    wl_signal_emit(&context->events.keysym, &ds_event);
 }
 
 static void
@@ -598,7 +598,7 @@ context_handle_language(struct wl_client *client,
     ds_event.im_context = context;
     ds_event.serial = serial;
     ds_event.language = language;
-    wl_signal_emit_mutable(&context->events.language, &ds_event);
+    wl_signal_emit(&context->events.language, &ds_event);
 }
 
 static void
@@ -613,7 +613,7 @@ context_handle_text_direction(struct wl_client *client,
     ds_event.im_context = context;
     ds_event.serial = serial;
     ds_event.direction = direction;
-    wl_signal_emit_mutable(&context->events.text_direction, &ds_event);
+    wl_signal_emit(&context->events.text_direction, &ds_event);
 }
 
 static const struct zwp_input_method_context_v1_interface context_impl = {
@@ -661,7 +661,7 @@ input_method_handle_display_destroy(struct wl_listener *listener, void *data)
     if (input_method->context)
         context_destroy(input_method->context);
 
-    wl_signal_emit_mutable(&input_method->events.destroy, input_method);
+    wl_signal_emit(&input_method->events.destroy, input_method);
     wl_list_remove(&input_method->destroy.link);
 
     wl_global_destroy(input_method->global);

diff --git a/src/keyrouter/keyrouter.c b/src/keyrouter/keyrouter.c
index b4fae3b..097f4df 100644 (file)
--- a/src/keyrouter/keyrouter.c
+++ b/src/keyrouter/keyrouter.c
@@ -296,7 +296,7 @@ keyrouter_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: ds_tizen_keyrouter(%p)", keyrouter);
 
-    wl_signal_emit_mutable(&keyrouter->events.destroy, keyrouter);
+    wl_signal_emit(&keyrouter->events.destroy, keyrouter);
 
     if (keyrouter->security_initialized)
         tizen_security_finish();

diff --git a/src/launch/appinfo.c b/src/launch/appinfo.c
index 6c5a06a..944797b 100644 (file)
--- a/src/launch/appinfo.c
+++ b/src/launch/appinfo.c
@@ -137,7 +137,7 @@ appinfo_mgr_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: appinfo_mgr(%p)", appinfo_mgr);
 
-    wl_signal_emit_mutable(&appinfo_mgr->events.destroy, appinfo_mgr);
+    wl_signal_emit(&appinfo_mgr->events.destroy, appinfo_mgr);
     wl_list_remove(&appinfo_mgr->destroy.link);
 
     wl_list_for_each_safe(client, tmp_client, &appinfo_mgr->clients, link) {
@@ -258,7 +258,7 @@ appinfo_set_pid(struct ds_tizen_launch_appinfo *info, pid_t pid)
     info->pid = pid;
     ds_inf("appinfo(%p) set pid(%u)", info, pid);
 
-    wl_signal_emit_mutable(&appinfo_mgr->events.set_pid, info);
+    wl_signal_emit(&appinfo_mgr->events.set_pid, info);
 
     return true;
 }
@@ -295,7 +295,7 @@ appinfo_set_appid(struct ds_tizen_launch_appinfo *info, const char *appid)
     info->appid = strdup(appid);
     ds_inf("appinfo(%p) set appid(%u)", info, appid);
 
-    wl_signal_emit_mutable(&appinfo_mgr->events.set_appid, info);
+    wl_signal_emit(&appinfo_mgr->events.set_appid, info);
 
     return true;
 }
@@ -512,7 +512,7 @@ appinfo_handle_ready_metadata(struct wl_client *wl_client,
     if ((uint32_t)info->pid != pid)
         appinfo_set_pid(info, pid);
 
-    wl_signal_emit_mutable(&client->appinfo_mgr->events.metadata_ready, info);
+    wl_signal_emit(&client->appinfo_mgr->events.metadata_ready, info);
 
     /* TODO: base  output resolution */
 }

diff --git a/src/launch/effect.c b/src/launch/effect.c
index 7994776..3ad0bea 100644 (file)
--- a/src/launch/effect.c
+++ b/src/launch/effect.c
@@ -221,7 +221,7 @@ effect_client_destroy(struct ds_tizen_launch_effect_client *client)
     struct ds_tizen_launch_splash *splash, *tmp;
 
     wl_list_for_each_safe(splash, tmp, &client->splashs, link) {
-        wl_signal_emit_mutable(&splash->events.destroy, splash);
+        wl_signal_emit(&splash->events.destroy, splash);
         wl_list_remove(&splash->link);
         free(splash);
     }
@@ -241,7 +241,7 @@ static void effect_handle_display_destroy(struct wl_listener *listener,
 
     ds_inf("Global destroy: effect(%p)", effect);
 
-    wl_signal_emit_mutable(&effect->events.destroy, effect);
+    wl_signal_emit(&effect->events.destroy, effect);
     wl_list_remove(&effect->destroy.link);
 
     wl_list_for_each_safe(client, tmp_client, &effect->clients, link) {
@@ -301,7 +301,7 @@ splash_handle_launch(struct wl_client *wl_client,
 
         ds_inf("Effect type_set. pid:%u type:%s", ds_event.pid, effect_type);
 
-        wl_signal_emit_mutable(&effect->events.type_set, &ds_event);
+        wl_signal_emit(&effect->events.type_set, &ds_event);
     }
 }
 
@@ -317,7 +317,7 @@ splash_handle_owner(struct wl_client *wl_client,
     splash = wl_resource_get_user_data(resource);
 
     ds_event.pid = pid;
-    wl_signal_emit_mutable(&splash->events.owner, &ds_event);
+    wl_signal_emit(&splash->events.owner, &ds_event);
 }
 
 static void
@@ -345,7 +345,7 @@ splash_handle_launch_v2(struct wl_client *wl_client,
 
         ds_inf("Effect type_set. pid:%u type:%s", ds_event.pid, effect_type);
 
-        wl_signal_emit_mutable(&effect->events.type_set, &ds_event);
+        wl_signal_emit(&effect->events.type_set, &ds_event);
     }
 
     //Parse extra config
@@ -395,7 +395,7 @@ splash_client_handle_destroy(struct wl_resource *resource)
 
     ds_inf("splash_client_handle_destroy (client:%p)", splash->client);
 
-    wl_signal_emit_mutable(&splash->events.destroy, splash);
+    wl_signal_emit(&splash->events.destroy, splash);
     wl_list_remove(&splash->link);
     free(splash);
 }
@@ -449,7 +449,7 @@ effect_handle_create_splash_img(struct wl_client *wl_client,
     if (!splash) return;
 
     effect = client->effect;
-    wl_signal_emit_mutable(&effect->events.new_splash, splash);
+    wl_signal_emit(&effect->events.new_splash, splash);
 }
 
 static void
@@ -469,7 +469,7 @@ effect_handle_type_set(struct wl_client *wl_client,
 
     ds_inf("Effect type_set. pid:%u type:%s", pid, effect_type);
 
-    wl_signal_emit_mutable(&effect->events.type_set, &ds_event);
+    wl_signal_emit(&effect->events.type_set, &ds_event);
 }
 
 static void
@@ -487,7 +487,7 @@ effect_handle_type_unset(struct wl_client *wl_client,
 
     ds_inf("Effect type_unset. pid:%u", pid);
 
-    wl_signal_emit_mutable(&effect->events.type_unset, &ds_event);
+    wl_signal_emit(&effect->events.type_unset, &ds_event);
 }
 
 static void

diff --git a/src/memory_flusher/memory_flusher.c b/src/memory_flusher/memory_flusher.c
index 4dadce7..9e8e407 100644 (file)
--- a/src/memory_flusher/memory_flusher.c
+++ b/src/memory_flusher/memory_flusher.c
@@ -33,10 +33,6 @@ struct ds_tizen_memory_flusher_client
 
     struct wl_list infos;
 
-    struct {
-        struct wl_signal destroy;
-    } events;
-
     struct wl_list link; // ds_tizen_memory_flusher::clients
 };
 
@@ -48,6 +44,10 @@ struct ds_tizen_memory_flusher_info
 
     struct ds_surface *surface;
 
+    struct {
+        struct wl_signal destroy;
+    } events;
+
     struct wl_list link; // ds_tizen_memory_flusher_client::infos
 };
 
@@ -118,7 +118,7 @@ ds_tizen_memory_flusher_info_add_destroy_listener(
         struct ds_tizen_memory_flusher_info *info,
         struct wl_listener *listener)
 {
-    wl_signal_add(&info->client->events.destroy, listener);
+    wl_signal_add(&info->events.destroy, listener);
 }
 
 WL_EXPORT struct ds_surface *
@@ -142,6 +142,16 @@ ds_tizen_memory_flusher_info_send_free_flush(
     tizen_surface_shm_flusher_send_free_flush(info->resource);
 }
 
+WL_EXPORT bool
+ds_tizen_memory_flusher_info_supported_free_flush(
+        struct ds_tizen_memory_flusher_info *info)
+{
+    if (wl_resource_get_version(info->resource) < TIZEN_SURFACE_SHM_FLUSHER_FREE_FLUSH_SINCE_VERSION)
+        return false;
+
+    return true;
+}
+
 static struct ds_tizen_memory_flusher_info *
 tizen_memory_flusher_client_find_info(struct ds_tizen_memory_flusher_client *client,
     struct ds_surface *surface)
@@ -175,6 +185,8 @@ tizen_memory_flusher_client_get_info(struct ds_tizen_memory_flusher_client *clie
     info->client = client;
     info->surface = surface;
 
+    wl_signal_init(&info->events.destroy);
+
     wl_list_insert(&client->infos, &info->link);
 
     return info;
@@ -189,7 +201,7 @@ memory_flusher_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: memory_flusher(%p)", memory_flusher);
 
-    wl_signal_emit_mutable(&memory_flusher->events.destroy, memory_flusher);
+    wl_signal_emit(&memory_flusher->events.destroy, memory_flusher);
     wl_list_remove(&memory_flusher->destroy.link);
     wl_global_destroy(memory_flusher->global);
     free(memory_flusher);
@@ -216,7 +228,7 @@ _tizen_memory_flusher_info_handle_destroy(struct wl_resource *resource)
 
     ds_inf("_tizen_memory_flusher_info_handle_destroy (info:%p)", info);
 
-    wl_signal_emit_mutable(&info->client->events.destroy, info);
+    wl_signal_emit(&info->events.destroy, info);
     wl_list_remove(&info->link);
     free(info);
 }
@@ -256,7 +268,7 @@ memory_flusher_handle_get_flusher(struct wl_client *wl_client,
     wl_resource_set_implementation(info->resource, &flusher_impl, info,
         _tizen_memory_flusher_info_handle_destroy);
 
-    wl_signal_emit_mutable(&client->memory_flusher->events.get_flusher, info);
+    wl_signal_emit(&client->memory_flusher->events.get_flusher, info);
 }
 
 static void
@@ -292,7 +304,7 @@ _tizen_memory_flusher_client_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_memory_flusher_client_handle_destroy (client:%p)", client);
 
     wl_list_for_each_safe(info, tmp, &client->infos, link) {
-        wl_signal_emit_mutable(&client->events.destroy, info);
+        wl_signal_emit(&info->events.destroy, info);
         wl_list_remove(&info->link);
         free(info);
     }
@@ -335,7 +347,5 @@ memory_flusher_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &memory_flusher_impl, client,
             _tizen_memory_flusher_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&memory_flusher->clients, &client->link);
 }

diff --git a/src/policy/policy.c b/src/policy/policy.c
index 624720d..ab7e9a6 100644 (file)
--- a/src/policy/policy.c
+++ b/src/policy/policy.c
@@ -993,7 +993,7 @@ tizen_policy_client_get_surface(struct wl_resource *resource,
         .policy = client->policy,
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&client->policy->events.new_surface, &event);
+    wl_signal_emit(&client->policy->events.new_surface, &event);
 
     return policy_surface;
 }
@@ -1007,7 +1007,7 @@ policy_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: policy(%p)", policy);
 
-    wl_signal_emit_mutable(&policy->events.destroy, policy);
+    wl_signal_emit(&policy->events.destroy, policy);
 
     if (policy->use_security)
         tizen_security_finish();
@@ -1039,7 +1039,7 @@ _tizen_policy_visibility_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_policy_visibility_handle_destroy (visibility:%p)",
         visibility);
 
-    wl_signal_emit_mutable(&visibility->events.destroy, visibility);
+    wl_signal_emit(&visibility->events.destroy, visibility);
     wl_list_remove(&visibility->link);
     free(visibility);
 }
@@ -1088,7 +1088,7 @@ policy_handle_get_visibility(struct wl_client *wl_client, struct wl_resource *re
         .policy_surface = policy_surface,
         .visibility = visibility,
     };
-    wl_signal_emit_mutable(&policy_surface->events.new_visibility, &event);
+    wl_signal_emit(&policy_surface->events.new_visibility, &event);
 }
 
 static void
@@ -1110,7 +1110,7 @@ position_handle_set(struct wl_client *wl_client, struct wl_resource *resource,
         .x = x,
         .y = y,
     };
-    wl_signal_emit_mutable(&position->events.set, &event);
+    wl_signal_emit(&position->events.set, &event);
 }
 
 static const struct tizen_position_interface position_impl =
@@ -1129,7 +1129,7 @@ _tizen_policy_position_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_policy_position_handle_destroy (position:%p)",
         position);
 
-    wl_signal_emit_mutable(&position->events.destroy, position);
+    wl_signal_emit(&position->events.destroy, position);
     wl_list_remove(&position->link);
     free(position);
 }
@@ -1179,7 +1179,7 @@ policy_handle_get_position(struct wl_client *wl_client, struct wl_resource *reso
         .policy_surface = policy_surface,
         .position = position,
     };
-    wl_signal_emit_mutable(&policy_surface->events.new_position, &event);
+    wl_signal_emit(&policy_surface->events.new_position, &event);
 }
 
 static void
@@ -1198,7 +1198,7 @@ policy_handle_activate(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_activate event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.activate, &event);
+    wl_signal_emit(&policy_surface->events.activate, &event);
 }
 
 static void
@@ -1215,7 +1215,7 @@ policy_handle_activate_below_by_res_id(struct wl_client *wl_client,
         .universal_id = universal_id,
         .below_universal_id = below_universal_id,
     };
-    wl_signal_emit_mutable(&client->policy->events.activate_below_by_univeral_id, &event);
+    wl_signal_emit(&client->policy->events.activate_below_by_univeral_id, &event);
 }
 
 static void
@@ -1234,7 +1234,7 @@ policy_handle_raise(struct wl_client *wl_client, struct wl_resource *resource,
     struct ds_tizen_policy_surface_event_raise event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.raise, &event);
+    wl_signal_emit(&policy_surface->events.raise, &event);
 }
 
 static void
@@ -1253,7 +1253,7 @@ policy_handle_lower(struct wl_client *wl_client, struct wl_resource *resource,
     struct ds_tizen_policy_surface_event_lower event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.lower, &event);
+    wl_signal_emit(&policy_surface->events.lower, &event);
 }
 
 static void
@@ -1268,7 +1268,7 @@ policy_handle_lower_by_res_id(struct wl_client *wl_client,
         .policy = client->policy,
         .universal_id = universal_id,
     };
-    wl_signal_emit_mutable(&client->policy->events.lower_by_universal_id, &event);
+    wl_signal_emit(&client->policy->events.lower_by_universal_id, &event);
 }
 
 static void
@@ -1287,7 +1287,7 @@ policy_handle_set_focus_skip(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_set_focus_skip event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_focus_skip, &event);
+    wl_signal_emit(&policy_surface->events.set_focus_skip, &event);
 }
 
 static void
@@ -1306,7 +1306,7 @@ policy_handle_unset_focus_skip(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_unset_focus_skip event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.unset_focus_skip, &event);
+    wl_signal_emit(&policy_surface->events.unset_focus_skip, &event);
 }
 
 static void
@@ -1326,7 +1326,7 @@ policy_handle_set_role(struct wl_client *wl_client, struct wl_resource *resource
         .policy_surface = policy_surface,
         .role = role,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_role, &event);
+    wl_signal_emit(&policy_surface->events.set_role, &event);
 }
 
 static void
@@ -1395,7 +1395,7 @@ policy_handle_set_type(struct wl_client *wl_client, struct wl_resource *resource
         .policy_surface = policy_surface,
         .win_type = win_type,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_window_type, &event);
+    wl_signal_emit(&policy_surface->events.set_window_type, &event);
 }
 
 static void
@@ -1417,7 +1417,7 @@ policy_handle_set_conformant(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_set_conformant event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_conformant, &event);
+    wl_signal_emit(&policy_surface->events.set_conformant, &event);
 }
 
 static void
@@ -1439,7 +1439,7 @@ policy_handle_unset_conformant(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_unset_conformant event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.unset_conformant, &event);
+    wl_signal_emit(&policy_surface->events.unset_conformant, &event);
 }
 
 static void
@@ -1458,7 +1458,7 @@ policy_handle_get_conformant(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_get_conformant event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.get_conformant, &event);
+    wl_signal_emit(&policy_surface->events.get_conformant, &event);
 }
 
 static void
@@ -1523,7 +1523,7 @@ policy_handle_set_notification_level(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .level = noti_level,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_notification_level, &event);
+    wl_signal_emit(&policy_surface->events.set_notification_level, &event);
 }
 
 static void
@@ -1539,7 +1539,7 @@ policy_handle_set_transient_for(struct wl_client *wl_client,
         .child_universal_id = child_id,
         .parent_universal_id = parent_id,
     };
-    wl_signal_emit_mutable(&client->policy->events.set_transient_for, &event);
+    wl_signal_emit(&client->policy->events.set_transient_for, &event);
 
     tizen_policy_send_transient_for_done(resource, child_id);
 }
@@ -1556,7 +1556,7 @@ policy_handle_unset_transient_for(struct wl_client *wl_client,
         .policy = client->policy,
         .child_universal_id = child_id,
     };
-    wl_signal_emit_mutable(&client->policy->events.unset_transient_for, &event);
+    wl_signal_emit(&client->policy->events.unset_transient_for, &event);
 }
 
 static void
@@ -1603,7 +1603,7 @@ policy_handle_set_window_screen_mode(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .mode = screen_mode,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_window_screen_mode, &event);
+    wl_signal_emit(&policy_surface->events.set_window_screen_mode, &event);
 }
 
 static void
@@ -1620,7 +1620,7 @@ policy_handle_place_subsurface_below_parent(struct wl_client *wl_client,
         .policy = client->policy,
         .subsurface = subsurface,
     };
-    wl_signal_emit_mutable(
+    wl_signal_emit(
         &client->policy->events.place_subsurface_below_parent,
         &event);
 }
@@ -1639,7 +1639,7 @@ policy_handle_set_subsurface_stand_alone(struct wl_client *wl_client,
         .policy = client->policy,
         .subsurface = subsurface,
     };
-    wl_signal_emit_mutable(
+    wl_signal_emit(
         &client->policy->events.set_subsurface_stand_alone,
         &event);
 }
@@ -1664,7 +1664,7 @@ policy_handle_get_subsurface(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .parent_universal_id = parent_id,
     };
-    wl_signal_emit_mutable(&policy_surface->events.get_subsurface, &event);
+    wl_signal_emit(&policy_surface->events.get_subsurface, &event);
 }
 
 static void
@@ -1704,7 +1704,7 @@ policy_handle_iconify(struct wl_client *wl_client, struct wl_resource *resource,
     struct ds_tizen_policy_surface_event_iconify event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.iconify, &event);
+    wl_signal_emit(&policy_surface->events.iconify, &event);
 }
 
 static void
@@ -1726,7 +1726,7 @@ policy_handle_uniconify(struct wl_client *wl_client, struct wl_resource *resourc
     struct ds_tizen_policy_surface_event_uniconify event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.uniconify, &event);
+    wl_signal_emit(&policy_surface->events.uniconify, &event);
 }
 
 static void
@@ -1749,7 +1749,7 @@ policy_handle_add_aux_hint(struct wl_client *wl_client,
         .name = name,
         .value = value,
     };
-    wl_signal_emit_mutable(&policy_surface->events.add_aux_hint, &event);
+    wl_signal_emit(&policy_surface->events.add_aux_hint, &event);
 }
 
 static void
@@ -1771,7 +1771,7 @@ policy_handle_change_aux_hint(struct wl_client *wl_client,
         .id = id,
         .value = value,
     };
-    wl_signal_emit_mutable(&policy_surface->events.change_aux_hint, &event);
+    wl_signal_emit(&policy_surface->events.change_aux_hint, &event);
 }
 
 static void
@@ -1792,7 +1792,7 @@ policy_handle_delete_aux_hint(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .id = id,
     };
-    wl_signal_emit_mutable(&policy_surface->events.delete_aux_hint, &event);
+    wl_signal_emit(&policy_surface->events.delete_aux_hint, &event);
 }
 
 static void
@@ -1811,7 +1811,7 @@ policy_handle_get_supported_aux_hints(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_get_supported_aux_hints event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.get_supported_aux_hints, &event);
+    wl_signal_emit(&policy_surface->events.get_supported_aux_hints, &event);
 }
 
 static void
@@ -1830,7 +1830,7 @@ policy_handle_set_background_state(struct wl_client *wl_client,
                 .policy = client->policy,
                 .pid = pid,
             };
-            wl_signal_emit_mutable(&client->policy->events.set_background_state, &event);
+            wl_signal_emit(&client->policy->events.set_background_state, &event);
         }
     }
 }
@@ -1851,7 +1851,7 @@ policy_handle_unset_background_state(struct wl_client *wl_client,
                 .policy = client->policy,
                 .pid = pid,
             };
-            wl_signal_emit_mutable(&client->policy->events.unset_background_state, &event);
+            wl_signal_emit(&client->policy->events.unset_background_state, &event);
         }
     }
 }
@@ -1877,7 +1877,7 @@ policy_handle_set_floating_mode(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_set_floating_mode event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_floating_mode, &event);
+    wl_signal_emit(&policy_surface->events.set_floating_mode, &event);
 }
 
 static void
@@ -1901,7 +1901,7 @@ policy_handle_unset_floating_mode(struct wl_client *wl_client,
     struct ds_tizen_policy_surface_event_unset_floating_mode event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.unset_floating_mode, &event);
+    wl_signal_emit(&policy_surface->events.unset_floating_mode, &event);
 }
 
 static void
@@ -1940,7 +1940,7 @@ policy_handle_set_stack_mode(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .mode = stack_mode,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_stack_mode, &event);
+    wl_signal_emit(&policy_surface->events.set_stack_mode, &event);
 }
 
 static void
@@ -1957,7 +1957,7 @@ policy_handle_activate_above_by_res_id(struct wl_client *wl_client,
         .universal_id = universal_id,
         .above_universal_id = above_universal_id,
     };
-    wl_signal_emit_mutable(&client->policy->events.activate_above_by_universal_id, &event);
+    wl_signal_emit(&client->policy->events.activate_above_by_universal_id, &event);
 }
 
 static void
@@ -1982,7 +1982,7 @@ _tizen_policy_subsurface_watcher_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_policy_subsurface_watcher_handle_destroy (subsurface_watcher:%p)",
         subsurface_watcher);
 
-    wl_signal_emit_mutable(&subsurface_watcher->events.destroy, subsurface_watcher);
+    wl_signal_emit(&subsurface_watcher->events.destroy, subsurface_watcher);
     free(subsurface_watcher);
 }
 
@@ -2030,7 +2030,7 @@ policy_handle_get_subsurface_watcher(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .subsurface_watcher = subsurface_watcher,
     };
-    wl_signal_emit_mutable(&policy_surface->events.new_subsurface_watcher, &event);
+    wl_signal_emit(&policy_surface->events.new_subsurface_watcher, &event);
 }
 
 static void
@@ -2054,7 +2054,7 @@ policy_handle_set_parent(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .parent_surface = parent_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_parent, &event);
+    wl_signal_emit(&policy_surface->events.set_parent, &event);
 }
 
 static void
@@ -2075,7 +2075,7 @@ policy_handle_ack_conformant_region(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .serial = serial,
     };
-    wl_signal_emit_mutable(&policy_surface->events.ack_conformant_region, &event);
+    wl_signal_emit(&policy_surface->events.ack_conformant_region, &event);
 }
 
 static void
@@ -2116,7 +2116,7 @@ policy_handle_has_video(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .video = has,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_video, &event);
+    wl_signal_emit(&policy_surface->events.set_video, &event);
 }
 
 static void
@@ -2132,7 +2132,7 @@ policy_handle_set_appid(struct wl_client *wl_client,
         .pid = pid,
         .appid = appid,
     };
-    wl_signal_emit_mutable(&client->policy->events.set_appid, &event);
+    wl_signal_emit(&client->policy->events.set_appid, &event);
 }
 
 static void
@@ -2151,7 +2151,7 @@ policy_handle_show(struct wl_client *wl_client, struct wl_resource *resource,
     struct ds_tizen_policy_surface_event_show event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.show, &event);
+    wl_signal_emit(&policy_surface->events.show, &event);
 }
 
 static void
@@ -2170,7 +2170,7 @@ policy_handle_hide(struct wl_client *wl_client, struct wl_resource *resource,
     struct ds_tizen_policy_surface_event_hide event = {
         .policy_surface = policy_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.hide, &event);
+    wl_signal_emit(&policy_surface->events.hide, &event);
 }
 
 static void
@@ -2187,7 +2187,7 @@ policy_handle_set_transient_for_below(struct wl_client *wl_client,
         .universal_id = universal_id,
         .parent_universal_id = parent_universal_id,
     };
-    wl_signal_emit_mutable(&client->policy->events.set_transient_for_below, &event);
+    wl_signal_emit(&client->policy->events.set_transient_for_below, &event);
 }
 
 static void
@@ -2211,7 +2211,7 @@ policy_handle_set_parent_with_below(struct wl_client *wl_client,
         .policy_surface = policy_surface,
         .parent_surface = parent_surface,
     };
-    wl_signal_emit_mutable(&policy_surface->events.set_parent_with_below, &event);
+    wl_signal_emit(&policy_surface->events.set_parent_with_below, &event);
 }
 
 static const struct tizen_policy_interface policy_impl =
@@ -2273,7 +2273,7 @@ _tizen_policy_client_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_policy_client_handle_destroy (client:%p)", client);
 
     wl_list_for_each_safe(policy_surface, tmp, &client->policy_surfaces, link) {
-        wl_signal_emit_mutable(&policy_surface->events.destroy, policy_surface);
+        wl_signal_emit(&policy_surface->events.destroy, policy_surface);
         wl_list_remove(&policy_surface->link);
         free(policy_surface);
     }

diff --git a/src/remote_surface/remote_surface.c b/src/remote_surface/remote_surface.c
index 20ebafe..337f397 100644 (file)
--- a/src/remote_surface/remote_surface.c
+++ b/src/remote_surface/remote_surface.c
@@ -42,10 +42,6 @@ struct ds_tizen_remote_surface_client
     struct {
         struct wl_listener surface_destroy;
     } listener;
-
-    struct {
-        struct wl_signal destroy;
-    } events;
 };
 
 struct ds_tizen_remote_surface_provider
@@ -201,7 +197,7 @@ remote_surface_provider_handle_set_offscreen(struct wl_client *wl_client,
 
     remote_provider->offscreen = offscreen;
 
-    wl_signal_emit_mutable(&remote_provider->events.set_offscreen, remote_provider);
+    wl_signal_emit(&remote_provider->events.set_offscreen, remote_provider);
 }
 
 static void
@@ -217,7 +213,7 @@ remote_surface_provider_handle_set_input_event_filter(struct wl_client *wl_clien
 
     remote_provider->input_event_filter = event_filter;
 
-    wl_signal_emit_mutable(&remote_provider->events.set_input_event_filter, remote_provider);
+    wl_signal_emit(&remote_provider->events.set_input_event_filter, remote_provider);
 }
 
 static const struct tizen_remote_surface_provider_interface remote_surface_provider_impl =
@@ -258,7 +254,7 @@ remote_surface_provider_handle_resource_destroy(struct wl_resource *remote_provi
 
     wl_list_remove(&remote_provider->link);
 
-    wl_signal_emit_mutable(&remote_provider->events.destroy, remote_provider);
+    wl_signal_emit(&remote_provider->events.destroy, remote_provider);
 
     free(remote_provider);
 }
@@ -303,7 +299,7 @@ remote_surface_manager_handle_create_provider(struct wl_client *wl_client,
     wl_signal_init(&remote_provider->events.set_offscreen);
     wl_signal_init(&remote_provider->events.set_input_event_filter);
 
-    wl_signal_emit_mutable(&remote_client->remote_manager->events.new_provider, remote_provider);
+    wl_signal_emit(&remote_client->remote_manager->events.new_provider, remote_provider);
 
     remote_provider->resource_id = global_resource_id++;
 
@@ -329,7 +325,7 @@ remote_surface_handle_redirect(struct wl_client *wl_client,
 
     remote_surface->redirect = true;
 
-    wl_signal_emit_mutable(&remote_surface->events.set_redirect, remote_surface);
+    wl_signal_emit(&remote_surface->events.set_redirect, remote_surface);
 }
 
 static void
@@ -342,7 +338,7 @@ remote_surface_handle_unredirect(struct wl_client *wl_client,
 
     remote_surface->redirect = false;
 
-    wl_signal_emit_mutable(&remote_surface->events.set_redirect, remote_surface);
+    wl_signal_emit(&remote_surface->events.set_redirect, remote_surface);
 }
 
 static void
@@ -373,7 +369,7 @@ remote_surface_handle_transfer_mouse_event(struct wl_client *wl_client,
     event.identifier = identifier;
     event.time = time;
 
-    wl_signal_emit_mutable(&remote_surface->events.transfer_mouse_event, &event);
+    wl_signal_emit(&remote_surface->events.transfer_mouse_event, &event);
 }
 
 static void
@@ -395,7 +391,7 @@ remote_surface_handle_transfer_mouse_wheel(struct wl_client *wl_client,
     event.identifier = identifier;
     event.time = time;
 
-    wl_signal_emit_mutable(&remote_surface->events.transfer_mouse_wheel_event, &event);
+    wl_signal_emit(&remote_surface->events.transfer_mouse_wheel_event, &event);
 }
 
 static void
@@ -425,7 +421,7 @@ remote_surface_handle_transfer_touch_event(struct wl_client *wl_client,
     event.identifier = identifier;
     event.time = time;
 
-    wl_signal_emit_mutable(&remote_surface->events.transfer_touch_event, &event);
+    wl_signal_emit(&remote_surface->events.transfer_touch_event, &event);
 }
 
 static void
@@ -439,7 +435,7 @@ remote_surface_handle_transfer_touch_cancel(struct wl_client *wl_client,
 
     event.remote_surface = remote_surface;
 
-    wl_signal_emit_mutable(&remote_surface->events.transfer_touch_cancel_event, &event);
+    wl_signal_emit(&remote_surface->events.transfer_touch_cancel_event, &event);
 }
 
 static void
@@ -461,7 +457,7 @@ remote_surface_handle_transfer_key_event(struct wl_client *wl_client,
     event.identifier = identifier;
     event.time = time;
 
-    wl_signal_emit_mutable(&remote_surface->events.transfer_key_event, &event);
+    wl_signal_emit(&remote_surface->events.transfer_key_event, &event);
 }
 
 static void
@@ -477,7 +473,7 @@ remote_surface_handle_transfer_visibility(struct wl_client *wl_client,
     event.remote_surface = remote_surface;
     event.visibility = visibility_type;
 
-    wl_signal_emit_mutable(&remote_surface->events.transfer_visibility_event, &event);
+    wl_signal_emit(&remote_surface->events.transfer_visibility_event, &event);
 }
 
 static void
@@ -510,7 +506,7 @@ remote_surface_handle_set_owner(struct wl_client *wl_client,
     ds_surface_add_destroy_listener(surface, &remote_surface->listener.owner_surface_destroy);
     remote_surface->owner_surface = surface;
 
-    wl_signal_emit_mutable(&remote_surface->events.set_owner, remote_surface);
+    wl_signal_emit(&remote_surface->events.set_owner, remote_surface);
 }
 
 static void
@@ -534,7 +530,7 @@ remote_region_handle_set_geometry(struct wl_client *wl_client,
     remote_region->w = w;
     remote_region->h = h;
 
-    wl_signal_emit_mutable(&remote_region->events.set_geometry, remote_region);
+    wl_signal_emit(&remote_region->events.set_geometry, remote_region);
 }
 
 static const struct tizen_remote_surface_region_interface remote_surface_region_impl =
@@ -552,7 +548,7 @@ remote_surface_region_handle_resource_destroy(struct wl_resource *remote_region_
 
     ds_inf("remote_region:%p destroy", remote_region);
 
-    wl_signal_emit_mutable(&remote_region->events.destroy, remote_region);
+    wl_signal_emit(&remote_region->events.destroy, remote_region);
 
     free(remote_region);
 }
@@ -589,7 +585,7 @@ remote_surface_handle_create_region(struct wl_client *wl_client,
     wl_signal_init(&remote_region->events.destroy);
     wl_signal_init(&remote_region->events.set_geometry);
 
-    wl_signal_emit_mutable(&remote_surface->events.new_region, remote_region);
+    wl_signal_emit(&remote_surface->events.new_region, remote_region);
 }
 
 static void
@@ -607,7 +603,7 @@ remote_surface_handle_release(struct wl_client *wl_client,
     event.remote_surface = remote_surface;
     event.buffer = buffer;
 
-    wl_signal_emit_mutable(&remote_surface->events.buffer_release, &event);
+    wl_signal_emit(&remote_surface->events.buffer_release, &event);
 }
 
 static void
@@ -624,7 +620,7 @@ remote_surface_handle_set_remote_render(struct wl_client *wl_client,
     else
         remote_surface->remote_render = false;
 
-    wl_signal_emit_mutable(&remote_surface->events.set_remote_render, remote_surface);
+    wl_signal_emit(&remote_surface->events.set_remote_render, remote_surface);
 }
 
 static void
@@ -638,7 +634,7 @@ remote_surface_handle_set_changed_buffer_event_filter(struct wl_client *wl_clien
 
     remote_surface->changed_buffer_event_filter = filter;
 
-    wl_signal_emit_mutable(&remote_surface->events.set_changed_buffer_event_filter, remote_surface);
+    wl_signal_emit(&remote_surface->events.set_changed_buffer_event_filter, remote_surface);
 }
 
 static void
@@ -656,7 +652,7 @@ remote_surface_handle_get_current_buffer(struct wl_client *wl_client,
     event.buffer_type = buff_type;
     event.request_serial = req_serial;
 
-    wl_signal_emit_mutable(&remote_surface->events.get_current_buffer, &event);
+    wl_signal_emit(&remote_surface->events.get_current_buffer, &event);
 }
 
 static const struct tizen_remote_surface_interface remote_surface_impl =
@@ -729,7 +725,7 @@ remote_surface_handle_resource_destroy(struct wl_resource *remote_surface_resour
 
     wl_list_remove(&remote_surface->link);
 
-    wl_signal_emit_mutable(&remote_surface->events.destroy, remote_surface);
+    wl_signal_emit(&remote_surface->events.destroy, remote_surface);
 
     free(remote_surface);
 }
@@ -804,7 +800,7 @@ remote_surface_manager_handle_create_surface(struct wl_client *wl_client,
 
     wl_list_insert(&remote_client->remote_manager->remote_surfaces, &remote_surface->link);
 
-    wl_signal_emit_mutable(&remote_client->remote_manager->events.new_surface, remote_surface);
+    wl_signal_emit(&remote_client->remote_manager->events.new_surface, remote_surface);
 }
 
 static void
@@ -825,7 +821,7 @@ remote_surface_manager_handle_bind_surface(struct wl_client *wl_client,
     event.remote_surface = remote_surface;
     event.surface = surface;
 
-    wl_signal_emit_mutable(&remote_client->remote_manager->events.bind_surface, &event);
+    wl_signal_emit(&remote_client->remote_manager->events.bind_surface, &event);
 }
 
 static void
@@ -911,8 +907,8 @@ remote_surface_manager_handle_create_surface_with_wl_surface(struct wl_client *w
 
     wl_list_insert(&remote_client->remote_manager->remote_surfaces, &remote_surface->link);
 
-    wl_signal_emit_mutable(&remote_client->remote_manager->events.new_surface, remote_surface);
-    wl_signal_emit_mutable(&remote_surface->events.set_owner, remote_surface);
+    wl_signal_emit(&remote_client->remote_manager->events.new_surface, remote_surface);
+    wl_signal_emit(&remote_surface->events.set_owner, remote_surface);
 }
 
 static const struct tizen_remote_surface_manager_interface remote_surface_manager_impl =
@@ -966,8 +962,6 @@ remote_surface_manager_bind(struct wl_client *wl_client, void *data, uint32_t ve
 
     wl_resource_set_implementation(remote_client->resource, &remote_surface_manager_impl,
             remote_client, tizen_remote_surface_client_handle_resource_destroy);
-
-    wl_signal_init(&remote_client->events.destroy);
 }
 
 static void
@@ -979,7 +973,7 @@ remote_surface_manager_handle_display_destroy(struct wl_listener *listener, void
 
     ds_inf("Global destroy: remote_surface_manager(%p)", remote_manager);
 
-    wl_signal_emit_mutable(&remote_manager->events.destroy, remote_manager);
+    wl_signal_emit(&remote_manager->events.destroy, remote_manager);
     wl_list_remove(&remote_manager->destroy.link);
     wl_global_destroy(remote_manager->global);
     free(remote_manager);

diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c
index 3595f2c..f98e36e 100644 (file)
--- a/src/renderer/renderer.c
+++ b/src/renderer/renderer.c
@@ -33,10 +33,6 @@ struct ds_tizen_renderer_client
 
     struct wl_list infos;
 
-    struct {
-        struct wl_signal destroy;
-    } events;
-
     struct wl_list link; // ds_tizen_renderer::clients
 };
 
@@ -48,6 +44,10 @@ struct ds_tizen_renderer_info
 
     struct ds_surface *surface;
 
+    struct {
+        struct wl_signal destroy;
+    } events;
+
     struct wl_list link; // ds_tizen_renderer_client::infos
 };
 
@@ -57,14 +57,6 @@ static void renderer_handle_display_destroy(struct wl_listener *listener,
 static void renderer_bind(struct wl_client *wl_client, void *data,
         uint32_t version, uint32_t id);
 
-static struct ds_tizen_renderer_info *tizen_renderer_client_find_info(
-    struct ds_tizen_renderer_client *client,
-    struct ds_surface *surface);
-
-static struct ds_tizen_renderer_info *tizen_renderer_client_get_info(
-        struct ds_tizen_renderer_client *client,
-        struct ds_surface *surface);
-
 WL_EXPORT struct ds_tizen_renderer *
 ds_tizen_renderer_create(struct wl_display *display)
 {
@@ -118,7 +110,7 @@ ds_tizen_renderer_info_add_destroy_listener(
         struct ds_tizen_renderer_info *info,
         struct wl_listener *listener)
 {
-    wl_signal_add(&info->client->events.destroy, listener);
+    wl_signal_add(&info->events.destroy, listener);
 }
 
 WL_EXPORT struct ds_surface *
@@ -135,44 +127,6 @@ ds_tizen_renderer_info_send_redraw(
     tizen_renderer_surface_send_redraw_request(info->resource);
 }
 
-static struct ds_tizen_renderer_info *
-tizen_renderer_client_find_info(struct ds_tizen_renderer_client *client,
-    struct ds_surface *surface)
-{
-    struct ds_tizen_renderer_info *info;
-
-    wl_list_for_each(info, &client->infos, link) {
-        if (surface == info->surface)
-            return info;
-    }
-
-    return NULL;
-}
-
-static struct ds_tizen_renderer_info *
-tizen_renderer_client_get_info(struct ds_tizen_renderer_client *client,
-    struct ds_surface *surface)
-{
-    struct ds_tizen_renderer_info *info;
-
-    info = tizen_renderer_client_find_info(client, surface);
-    if (info)
-        return info;
-
-    info = calloc(1, sizeof *info);
-    if (info == NULL) {
-        ds_err("calloc() failed. tizen_renderer");
-        return NULL;
-    }
-
-    info->client = client;
-    info->surface = surface;
-
-    wl_list_insert(&client->infos, &info->link);
-
-    return info;
-}
-
 static void
 renderer_handle_display_destroy(struct wl_listener *listener, void *data)
 {
@@ -182,7 +136,7 @@ renderer_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: renderer(%p)", renderer);
 
-    wl_signal_emit_mutable(&renderer->events.destroy, renderer);
+    wl_signal_emit(&renderer->events.destroy, renderer);
     wl_list_remove(&renderer->destroy.link);
     wl_global_destroy(renderer->global);
     free(renderer);
@@ -209,8 +163,9 @@ _tizen_renderer_info_handle_destroy(struct wl_resource *resource)
 
     ds_inf("_tizen_renderer_info_handle_destroy (info:%p)", info);
 
-    wl_signal_emit_mutable(&info->client->events.destroy, info);
-    wl_list_remove(&info->link);
+    wl_signal_emit(&info->events.destroy, info);
+    if (info->client)
+        wl_list_remove(&info->link);
     free(info);
 }
 
@@ -228,28 +183,33 @@ renderer_handle_get_renderer_surface(struct wl_client *wl_client,
     client = wl_resource_get_user_data(resource);
     surface = ds_surface_from_resource(surface_resource);
 
-    info = tizen_renderer_client_get_info(client, surface);
+    info = calloc(1, sizeof *info);
     if (info == NULL) {
-        ds_err("tizen_renderer_client_get_info() failed.");
+        ds_err("tizen_renderer_surface: calloc() failed.");
         wl_client_post_no_memory(wl_client);
         return;
     }
 
+    info->client = client;
+    info->surface = surface;
     info->resource = wl_resource_create(wl_client,
         &tizen_renderer_surface_interface, wl_resource_get_version(resource),
         id);
     if (info->resource == NULL) {
         ds_err("tizen_renderer : wl_resource_create() failed.");
-        wl_list_remove(&info->link);
         free(info);
         wl_client_post_no_memory(wl_client);
         return;
     }
 
+    wl_list_insert(&client->infos, &info->link);
+
+    wl_signal_init(&info->events.destroy);
+
     wl_resource_set_implementation(info->resource, &renderer_surface_impl, info,
         _tizen_renderer_info_handle_destroy);
 
-    wl_signal_emit_mutable(&client->renderer->events.get_renderer_surface, info);
+    wl_signal_emit(&client->renderer->events.get_renderer_surface, info);
 }
 
 static void
@@ -285,9 +245,8 @@ _tizen_renderer_client_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_renderer_client_handle_destroy (client:%p)", client);
 
     wl_list_for_each_safe(info, tmp, &client->infos, link) {
-        wl_signal_emit_mutable(&client->events.destroy, info);
+        info->client = NULL;
         wl_list_remove(&info->link);
-        free(info);
     }
 
     wl_list_remove(&client->link);
@@ -328,7 +287,5 @@ renderer_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &renderer_impl, client,
             _tizen_renderer_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&renderer->clients, &client->link);
 }

diff --git a/src/screen/screen.c b/src/screen/screen.c
index c5c9916..cca5127 100644 (file)
--- a/src/screen/screen.c
+++ b/src/screen/screen.c
@@ -37,10 +37,6 @@ struct ds_tizen_screen_client
     struct wl_resource *resource;
     struct wl_client *client;
 
-    struct {
-        struct wl_signal destroy;
-    } events;
-
     struct wl_list link; // ds_tizen_screen::clients
 };
 
@@ -87,7 +83,7 @@ splitscreen_handle_activate(struct wl_client *client,
 
     ds_inf("screen_splitscreen:%p activate", splitscreen);
 
-    wl_signal_emit_mutable(&splitscreen->events.activate, splitscreen);
+    wl_signal_emit(&splitscreen->events.activate, splitscreen);
 }
 
 static void
@@ -100,7 +96,7 @@ splitscreen_handle_deactivate(struct wl_client *client,
 
     ds_inf("screen_splitscreen:%p deactivate", splitscreen);
 
-    wl_signal_emit_mutable(&splitscreen->events.deactivate, splitscreen);
+    wl_signal_emit(&splitscreen->events.deactivate, splitscreen);
 }
 
 static const struct wtz_splitscreen_interface splitscreen_impl =
@@ -120,7 +116,7 @@ _tizen_screen_splitscreen_handle_resource_destroy(struct wl_resource *splitscree
 
     ds_inf("screen_splitscreen:%p destroy", splitscreen);
 
-    wl_signal_emit_mutable(&splitscreen->events.destroy, splitscreen);
+    wl_signal_emit(&splitscreen->events.destroy, splitscreen);
 
     screen = splitscreen->screen;
     screen->splitscreen_enabled = false; // unset splitscreen resource on a screen
@@ -183,7 +179,7 @@ screen_handle_get_splitscreen(struct wl_client *client,
 
     screen->splitscreen_enabled = true; // set splitscreen resource on a screen
 
-    wl_signal_emit_mutable(&screen_client->screen->events.get_splitscreen, splitscreen);
+    wl_signal_emit(&screen_client->screen->events.get_splitscreen, splitscreen);
 }
 
 static void
@@ -246,8 +242,6 @@ screen_bind(struct wl_client *wl_client, void *data, uint32_t version,
    // send the capabilities of the screen
     wtz_screen_send_capabilities(screen_client->resource, &screen->capabilities);
 
-    wl_signal_init(&screen_client->events.destroy);
-
     wl_list_insert(&screen->clients, &screen_client->link);
 }
 
@@ -260,7 +254,7 @@ screen_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: screen(%p)", screen);
 
-    wl_signal_emit_mutable(&screen->events.destroy, screen);
+    wl_signal_emit(&screen->events.destroy, screen);
     wl_list_remove(&screen->destroy.link);
     wl_global_destroy(screen->global);
     free(screen);
@@ -389,7 +383,7 @@ splitscreen_region_handle_assign_appid(struct wl_client *client,
 
     splitscreen_region->appid = appid;
 
-    wl_signal_emit_mutable(&splitscreen_region->events.assign_appid, (void *)appid);
+    wl_signal_emit(&splitscreen_region->events.assign_appid, (void *)appid);
 }
 
 static const struct wtz_splitscreen_region_interface splitscreen_region_impl =
@@ -408,7 +402,7 @@ _tizen_screen_splitscreen_region_handle_resource_destroy(
 
     ds_inf("screen_splitscreen_region:%p destroy", splitscreen_region);
 
-    wl_signal_emit_mutable(&splitscreen_region->events.destroy,
+    wl_signal_emit(&splitscreen_region->events.destroy,
             splitscreen_region);
 
     free(splitscreen_region);

diff --git a/src/screen_rotation/screen_rotation.c b/src/screen_rotation/screen_rotation.c
index fc00936..656347e 100644 (file)
--- a/src/screen_rotation/screen_rotation.c
+++ b/src/screen_rotation/screen_rotation.c
@@ -33,10 +33,6 @@ struct ds_tizen_screen_rotation_client
 
     struct wl_list infos;
 
-    struct {
-        struct wl_signal destroy;
-    } events;
-
     struct wl_list link; // ds_tizen_screen_rotation::clients
 };
 
@@ -46,6 +42,10 @@ struct ds_tizen_screen_rotation_info
 
     struct ds_surface *surface;
 
+    struct {
+        struct wl_signal destroy;
+    } events;
+
     struct wl_list link; // ds_tizen_screen_rotation_client::infos
 };
 
@@ -118,7 +118,7 @@ ds_tizen_screen_rotation_info_add_destroy_listener(
         struct ds_tizen_screen_rotation_info *info,
         struct wl_listener *listener)
 {
-    wl_signal_add(&info->client->events.destroy, listener);
+    wl_signal_add(&info->events.destroy, listener);
 }
 
 WL_EXPORT struct ds_surface *
@@ -169,6 +169,8 @@ tizen_screen_rotation_client_get_info(struct ds_tizen_screen_rotation_client *cl
     info->client = client;
     info->surface = surface;
 
+    wl_signal_init(&info->events.destroy);
+
     wl_list_insert(&client->infos, &info->link);
 
     return info;
@@ -183,7 +185,7 @@ screen_rotation_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: screen_rotation(%p)", screen_rotation);
 
-    wl_signal_emit_mutable(&screen_rotation->events.destroy, screen_rotation);
+    wl_signal_emit(&screen_rotation->events.destroy, screen_rotation);
     wl_list_remove(&screen_rotation->destroy.link);
     wl_global_destroy(screen_rotation->global);
     free(screen_rotation);
@@ -225,7 +227,7 @@ screen_rotation_handle_get_ignore_output_transfrom(struct wl_client *wl_client,
         return;
     }
 
-    wl_signal_emit_mutable(&client->screen_rotation->events.get_ignore_output_transfrom, info);
+    wl_signal_emit(&client->screen_rotation->events.get_ignore_output_transfrom, info);
 }
 
 static const struct tizen_screen_rotation_interface screen_rotation_impl =
@@ -245,7 +247,7 @@ _tizen_screen_rotation_client_handle_destroy(struct wl_resource *resource)
     ds_inf("_tizen_screen_rotation_client_handle_destroy (client:%p)", client);
 
     wl_list_for_each_safe(info, tmp, &client->infos, link) {
-        wl_signal_emit_mutable(&client->events.destroy, info);
+        wl_signal_emit(&info->events.destroy, info);
         wl_list_remove(&info->link);
         free(info);
     }
@@ -288,7 +290,5 @@ screen_rotation_bind(struct wl_client *wl_client, void *data, uint32_t version,
     wl_resource_set_implementation(client->resource, &screen_rotation_impl, client,
             _tizen_screen_rotation_client_handle_destroy);
 
-    wl_signal_init(&client->events.destroy);
-
     wl_list_insert(&screen_rotation->clients, &client->link);
 }

diff --git a/src/screenshooter/screenmirror.c b/src/screenshooter/screenmirror.c
index 7a1d580..0675a37 100644 (file)
--- a/src/screenshooter/screenmirror.c
+++ b/src/screenshooter/screenmirror.c
@@ -92,7 +92,7 @@ ds_tizen_screenmirror_destroy(struct ds_tizen_screenmirror *mirror)
     if (mirror->resource)
         wl_resource_set_destructor(mirror->resource, NULL);
 
-    wl_signal_emit_mutable(&mirror->events.destroy, NULL);
+    wl_signal_emit(&mirror->events.destroy, NULL);
     //should be called buffer_dequeued from server(ds_tizen_screenmirror_send_dequeued)
 
     free(mirror);
@@ -123,7 +123,7 @@ ds_tizen_screenmirror_create(struct ds_tizen_screenshooter_client *client,
         ds_err("screenmirror create fail : memory alloc failed");
         return NULL;
     }
- 
+
     mirror->resource = wl_resource_create(client->client, &tizen_screenmirror_interface,
                                           version, id);
     if (mirror->resource == NULL) {
@@ -174,7 +174,7 @@ _tizen_screenmirror_handle_set_stretch(struct wl_client *client, struct wl_resou
     else
         ds_stretch = DS_TIZEN_SCREENMIRROR_STRETCH_FULLY;
 
-    wl_signal_emit_mutable(&mirror->events.set_stretch, &ds_stretch);
+    wl_signal_emit(&mirror->events.set_stretch, &ds_stretch);
 }
 
 static void
@@ -190,7 +190,7 @@ _tizen_screenmirror_handle_queue(struct wl_client *client, struct wl_resource *r
         return;
     }
 
-    wl_signal_emit_mutable(&mirror->events.queue, &buffer);
+    wl_signal_emit(&mirror->events.queue, &buffer);
 }
 
 static void
@@ -206,7 +206,7 @@ _tizen_screenmirror_handle_dequeue(struct wl_client *client, struct wl_resource
         return;
     }
 
-    wl_signal_emit_mutable(&mirror->events.dequeue, &buffer);
+    wl_signal_emit(&mirror->events.dequeue, &buffer);
 }
 
 static void
@@ -215,7 +215,7 @@ _tizen_screenmirror_handle_start(struct wl_client *client, struct wl_resource *r
     struct ds_tizen_screenmirror *mirror;
 
     mirror = wl_resource_get_user_data(resource);
-    wl_signal_emit_mutable(&mirror->events.start, NULL);
+    wl_signal_emit(&mirror->events.start, NULL);
 }
 
 static void
@@ -224,7 +224,7 @@ _tizen_screenmirror_handle_stop(struct wl_client *client, struct wl_resource *re
     struct ds_tizen_screenmirror *mirror;
 
     mirror = wl_resource_get_user_data(resource);
-    wl_signal_emit_mutable(&mirror->events.stop, NULL);
+    wl_signal_emit(&mirror->events.stop, NULL);
 }
 
 static void
@@ -233,7 +233,7 @@ _tizen_screenmirror_handle_set_auto_rotation(struct wl_client *client, struct wl
     struct ds_tizen_screenmirror *mirror;
 
     mirror = wl_resource_get_user_data(resource);
-    wl_signal_emit_mutable(&mirror->events.set_auto_rotation, &set);
+    wl_signal_emit(&mirror->events.set_auto_rotation, &set);
 }
 
 static const struct tizen_screenmirror_interface _screenmirror_interface = {

diff --git a/src/screenshooter/screenshooter.c b/src/screenshooter/screenshooter.c
index 7b478e2..3c8e623 100644 (file)
--- a/src/screenshooter/screenshooter.c
+++ b/src/screenshooter/screenshooter.c
@@ -80,7 +80,7 @@ screenshooter_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("global destroy : tizen_screenshooter(%p)", shot);
 
-    wl_signal_emit_mutable(&shot->events.destroy, shot);
+    wl_signal_emit(&shot->events.destroy, shot);
     wl_list_remove(&shot->destroy.link);
     wl_global_destroy(shot->global);
     free(shot);
@@ -106,7 +106,7 @@ _tizen_screenshooter_handle_get_screenmirror(struct wl_client *client,
     if (shot_client->mirror == NULL)
         wl_client_post_no_memory(client);
     else
-        wl_signal_emit_mutable(&shot->events.get_screenmirror, shot_client->mirror);
+        wl_signal_emit(&shot->events.get_screenmirror, shot_client->mirror);
 }
 
 static void
@@ -158,7 +158,7 @@ _tizen_screenshooter_handle_shoot(struct wl_client *client,
         .auto_rotation = shot->auto_rotation,
     };
 
-    wl_signal_emit_mutable(&shot->events.shoot, &event);
+    wl_signal_emit(&shot->events.shoot, &event);
 }
 
 static const struct tizen_screenshooter_interface _tizen_screenshooter_interface =

diff --git a/src/tbm_server/tbm_server.c b/src/tbm_server/tbm_server.c
index 3e3499b..24ccbb5 100644 (file)
--- a/src/tbm_server/tbm_server.c
+++ b/src/tbm_server/tbm_server.c
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 
 #include <tbm_bufmgr.h>
+#include <tbm_bufmgr_internal.h>
 
 #include <libds/log.h>
 #include "shared/pixel_format.h"
@@ -85,7 +86,7 @@ tbm_server_handle_display_destroy(struct wl_listener *listener, void *data)
 
     tbm = wl_container_of(listener, tbm, display_destroy);
 
-    wl_signal_emit_mutable(&tbm->events.destroy, tbm);
+    wl_signal_emit(&tbm->events.destroy, tbm);
 
     wayland_tbm_server_deinit(tbm->wl_tbm);
     free(tbm);

diff --git a/src/text_input/text_input.c b/src/text_input/text_input.c
index 8711ab6..709cadb 100644 (file)
--- a/src/text_input/text_input.c
+++ b/src/text_input/text_input.c
@@ -241,7 +241,7 @@ text_input_handle_activate(struct wl_client *client,
     if (seat_client)
         ds_event.seat = ds_seat_client_get_seat(seat_client);
     ds_event.surface = ds_surf;
-    wl_signal_emit_mutable(&text_input->events.activate, &ds_event);
+    wl_signal_emit(&text_input->events.activate, &ds_event);
 
     ds_tizen_text_input_send_enter(text_input, ds_surf);
 }
@@ -259,7 +259,7 @@ text_input_handle_deactivate(struct wl_client *client,
     seat_client = ds_seat_client_from_resource(seat);
     if (seat_client)
         ds_event.seat = ds_seat_client_get_seat(seat_client);
-    wl_signal_emit_mutable(&text_input->events.deactivate, &ds_event);
+    wl_signal_emit(&text_input->events.deactivate, &ds_event);
 
     ds_tizen_text_input_send_leave(text_input);
 }
@@ -284,7 +284,7 @@ text_input_handle_reset(struct wl_client *client, struct wl_resource *resource)
     struct ds_tizen_text_input *text_input = wl_resource_get_user_data(resource);
 
     ds_inf("text_input_handle_reset");
-    wl_signal_emit_mutable(&text_input->events.reset, text_input);
+    wl_signal_emit(&text_input->events.reset, text_input);
 }
 
 static void
@@ -299,7 +299,7 @@ text_input_handle_set_content_type(struct wl_client *client,
     ds_event.purpose = purpose;
     ds_event.text_input = text_input;
 
-    wl_signal_emit_mutable(&text_input->events.set_content_type, &ds_event);
+    wl_signal_emit(&text_input->events.set_content_type, &ds_event);
 }
 
 static void
@@ -321,7 +321,7 @@ text_input_handle_set_preferred_language(struct wl_client *client,
     ds_event.language = language;
     ds_event.text_input = text_input;
 
-    wl_signal_emit_mutable(&text_input->events.set_preferred_language, &ds_event);
+    wl_signal_emit(&text_input->events.set_preferred_language, &ds_event);
 }
 
 static void
@@ -335,7 +335,7 @@ text_input_handle_commit_state(struct wl_client *client,
     ds_event.serial = serial;
     ds_event.text_input = text_input;
 
-    wl_signal_emit_mutable(&text_input->events.commit_state, &ds_event);
+    wl_signal_emit(&text_input->events.commit_state, &ds_event);
 }
 
 static void
@@ -351,7 +351,7 @@ text_input_handle_invoke_action(struct wl_client *client,
     ds_event.index = index;
     ds_event.text_input = text_input;
 
-    wl_signal_emit_mutable(&text_input->events.invoke_action, &ds_event);
+    wl_signal_emit(&text_input->events.invoke_action, &ds_event);
 }
 
 static void
@@ -512,7 +512,7 @@ static const struct wl_text_input_interface text_input_impl = {
 static void
 text_input_destroy(struct ds_tizen_text_input *text_input)
 {
-    wl_signal_emit_mutable(&text_input->events.destroy, text_input);
+    wl_signal_emit(&text_input->events.destroy, text_input);
     wl_list_remove(&text_input->link);
 
     free(text_input);
@@ -528,7 +528,7 @@ text_input_mgr_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Global destroy: text_input_mgr(%p)", text_input_mgr);
 
-    wl_signal_emit_mutable(&text_input_mgr->events.destroy, text_input_mgr);
+    wl_signal_emit(&text_input_mgr->events.destroy, text_input_mgr);
     wl_list_remove(&text_input_mgr->destroy.link);
 
     wl_list_for_each_safe(text_input, tmp, &text_input_mgr->text_inputs, link) {
@@ -589,7 +589,7 @@ text_input_manager_handle_create_text_input(struct wl_client *wl_client,
     wl_signal_init(&text_input->events.destroy);
 
     wl_list_insert(&text_input_mgr->text_inputs, &text_input->link);
-    wl_signal_emit_mutable(&text_input_mgr->events.new_text_input, text_input);
+    wl_signal_emit(&text_input_mgr->events.new_text_input, text_input);
 }
 
 static const struct wl_text_input_manager_interface text_input_mgr_impl =

diff --git a/src/video/video.c b/src/video/video.c
index d2b8230..56f62f1 100644 (file)
--- a/src/video/video.c
+++ b/src/video/video.c
@@ -257,7 +257,7 @@ video_handle_display_destroy(struct wl_listener *listener, void *data)
 
     ds_inf("Destroy ds_tizen_video(%p)", video);
 
-    wl_signal_emit_mutable(&video->events.destroy, video);
+    wl_signal_emit(&video->events.destroy, video);
 
     wl_array_release(&video->formats);
     wl_array_release(&video->properties);
@@ -296,7 +296,7 @@ video_handle_get_object(struct wl_client *client, struct wl_resource *resource,
                 prop->name, prop->value);
     }
 
-    wl_signal_emit_mutable(&video->events.new_object, object);
+    wl_signal_emit(&video->events.new_object, object);
 }
 
 static void
@@ -312,7 +312,7 @@ video_handle_get_viewport(struct wl_client *client,
         return;
 
     video = wl_resource_get_user_data(resource);
-    wl_signal_emit_mutable(&video->events.new_viewport, viewport);
+    wl_signal_emit(&video->events.new_viewport, viewport);
 }
 
 static void
@@ -429,7 +429,7 @@ video_object_handle_set_attribute(struct wl_client *client,
         .name = name,
         .value = value,
     };
-    wl_signal_emit_mutable(&object->events.request_set_property, &event);
+    wl_signal_emit(&object->events.request_set_property, &event);
 }
 
 static void
@@ -442,7 +442,7 @@ video_object_handle_follow_topmost_visibility(struct wl_client *client,
     if (!object)
         return;
 
-    wl_signal_emit_mutable(&object->events.request_follow_topmost_visibility, object);
+    wl_signal_emit(&object->events.request_follow_topmost_visibility, object);
 }
 
 static void
@@ -455,7 +455,7 @@ video_object_handle_unfollow_topmost_visibility(struct wl_client *client,
     if (!object)
         return;
 
-    wl_signal_emit_mutable(&object->events.request_unfollow_topmost_visibility, object);
+    wl_signal_emit(&object->events.request_unfollow_topmost_visibility, object);
 }
 
 static void
@@ -468,7 +468,7 @@ video_object_handle_allowed_attribute(struct wl_client *client,
     if (!object)
         return;
 
-    wl_signal_emit_mutable(&object->events.request_attribute_allowed, object);
+    wl_signal_emit(&object->events.request_attribute_allowed, object);
 }
 
 static void
@@ -481,7 +481,7 @@ video_object_handle_disallowed_attribute(struct wl_client *client,
     if (!object)
         return;
 
-    wl_signal_emit_mutable(&object->events.request_attribute_disallowed, object);
+    wl_signal_emit(&object->events.request_attribute_disallowed, object);
 }
 
 static const struct tizen_video_object_interface video_object_impl = {
@@ -554,7 +554,7 @@ video_object_destroy(struct ds_tizen_video_object *object)
 {
     ds_inf("Destroy ds_tizen_video_object(%p)", object);
 
-    wl_signal_emit_mutable(&object->events.destroy, object);
+    wl_signal_emit(&object->events.destroy, object);
 
     wl_resource_set_user_data(object->resource, NULL);
 

diff --git a/src/video/viewport.c b/src/video/viewport.c
index 20b4ef0..321ee6a 100644 (file)
--- a/src/video/viewport.c
+++ b/src/video/viewport.c
@@ -177,7 +177,7 @@ viewport_handle_set_source(struct wl_client *client,
 }
 
 static void
-viewport_handle_set_destination(struct wl_client *client, 
+viewport_handle_set_destination(struct wl_client *client,
         struct wl_resource *resource,
         int32_t x, int32_t y, uint32_t width, uint32_t height)
 {
@@ -291,7 +291,7 @@ viewport_handle_query_parent_size(struct wl_client *client,
 
     viewport = wl_resource_get_user_data(resource);
     viewport->query_parent_size = true;
-    wl_signal_emit_mutable(&viewport->events.query_parent_size, viewport);
+    wl_signal_emit(&viewport->events.query_parent_size, viewport);
 }
 
 static void
@@ -357,13 +357,13 @@ viewport_handle_surface_commit(struct wl_listener *listener, void *data)
     viewport->current = viewport->pending;
     viewport->pending.committed = DS_TIZEN_VIEWPORT_STATE_NONE;
 
-    wl_signal_emit_mutable(&viewport->events.commit, &viewport->current);
+    wl_signal_emit(&viewport->events.commit, &viewport->current);
 }
 
 static void
 viewport_destroy(struct ds_tizen_viewport *viewport)
 {
-    wl_signal_emit_mutable(&viewport->events.destroy, viewport);
+    wl_signal_emit(&viewport->events.destroy, viewport);
 
     ds_surface_viewport_release(viewport->surface_viewport);