Fix formatting

Change-Id: Ibd617c295dbf2b3e6058999efa6e14a265dfbb3b

diff --git a/src/debug/debug.c b/src/debug/debug.c
index fb39328..2f97da7 100644 (file)
--- a/src/debug/debug.c
+++ b/src/debug/debug.c
@@ -129,7 +129,9 @@ _client_get_resource_itr(struct wl_resource *resource, void *data)
 {
        int *n_resources = (int *)data;
 
-       ds_inf("\t\t [resource][%d] class=%s, id=%u\n", ++(*n_resources), wl_resource_get_class(resource), wl_resource_get_id(resource));
+       ds_inf("\t\t [resource][%d] class=%s, id=%u\n",
+                       ++(*n_resources), wl_resource_get_class(resource),
+                       wl_resource_get_id(resource));
 
        return WL_ITERATOR_CONTINUE;
 }
@@ -158,14 +160,16 @@ _headless_debug_connected_clients(headless_debug_t *hdebug, void *data)
 
        /* get client list which bound wl_compositor global */
        clist = wl_display_get_client_list(hdebug->server->display);
-       HEADLESS_CHECK(clist, return, "Failed to get client list from compositor->display.\n");
+       HS_CHECK(clist, return,
+                       "Failed to get client list from compositor->display.\n");
 
        ds_inf("========= [Connected clients information] =========\n");
        wl_client_for_each(client_itr, clist) {
                n_clients++;
                client_fd = wl_client_get_fd(client_itr);
                wl_client_get_credentials(client_itr, &pid, &uid, &gid);
-               ds_inf("\t client[%d]: pid=%d, user=%d, group=%d, socket_fd=%d", n_clients, pid, uid, gid, client_fd);
+               ds_inf("\t client[%d]: pid=%d, user=%d, group=%d, socket_fd=%d",
+                               n_clients, pid, uid, gid, client_fd);
 
                if (false == need_reslist) {
                        ds_inf("\n");
@@ -173,7 +177,8 @@ _headless_debug_connected_clients(headless_debug_t *hdebug, void *data)
                }
 
                ds_inf("\n");
-               wl_client_for_each_resource(client_itr, _client_get_resource_itr, &n_resources);
+               wl_client_for_each_resource(client_itr, _client_get_resource_itr,
+                               &n_resources);
                ds_inf("\t\t number of resources = %d\n", n_resources);
 
                n_resources = 0;
@@ -192,18 +197,19 @@ _headless_debug_redir_stdout(headless_debug_t *hdebug, void *data)
        int fd = -1;
        int ret = 0;
 
-       fd = open("/run/headless_server/stdout.txt", O_CREAT | O_WRONLY | O_APPEND, S_IWUSR | S_IWGRP);
+       fd = open("/run/headless_server/stdout.txt", O_CREAT | O_WRONLY | O_APPEND,
+                       S_IWUSR | S_IWGRP);
 
        if (fd < 0) {
-               HEADLESS_TRACE("Failed to open stdout.txt (errno=%m)\n");
+               HS_TRACE("Failed to open stdout.txt (errno=%m)\n");
                return;
        }
 
        ret = dup2(fd, 1);
        close(fd);
-       HEADLESS_CHECK(ret >= 0, return, "Failed to redirect STDOUT.\n");
+       HS_CHECK(ret >= 0, return, "Failed to redirect STDOUT.\n");
 
-       HEADLESS_TRACE("STDOUT has been redirected to stdout.txt.\n");
+       HS_TRACE("STDOUT has been redirected to stdout.txt.\n");
 }
 
 static void
@@ -215,18 +221,19 @@ _headless_debug_redir_stderr(headless_debug_t *hdebug, void *data)
        int fd = -1;
        int ret = 0;
 
-       fd = open("/run/headless_server/stderr.txt", O_CREAT | O_WRONLY | O_APPEND, S_IWUSR | S_IWGRP);
+       fd = open("/run/headless_server/stderr.txt", O_CREAT | O_WRONLY | O_APPEND,
+                       S_IWUSR | S_IWGRP);
 
        if (fd < 0) {
-               HEADLESS_TRACE("Failed to open stderr.txt (errno=%m)\n");
+               HS_TRACE("Failed to open stderr.txt (errno=%m)\n");
                return;
        }
 
        ret = dup2(fd, 2);
        close(fd);
-       HEADLESS_CHECK(ret >= 0, return, "Failed to redirect STDERR.\n");
+       HS_CHECK(ret >= 0, return, "Failed to redirect STDERR.\n");
 
-       HEADLESS_TRACE("STDERR has been redirected to stderr.txt.\n");
+       HS_TRACE("STDERR has been redirected to stderr.txt.\n");
 
 }
 
@@ -290,14 +297,14 @@ _headless_debug_keymap(headless_debug_t *hdebug, void *data)
        char keyname[256] = {0, };
 
        xkb = headless_input_get_xkb(hdebug->compositor);
-       HEADLESS_CHECK(xkb, return, "xkb is not set\n");
+       HS_CHECK(xkb, return, "xkb is not set\n");
 
        context = pepper_xkb_get_context(xkb);
-       HEADLESS_CHECK(context, return, "Current pepper_xkb has no context.\n");
+       HS_CHECK(context, return, "Current pepper_xkb has no context.\n");
        keymap = pepper_xkb_get_keymap(xkb);
-       HEADLESS_CHECK(keymap, return, "Current pepper_xkb has no keymap.\n");
+       HS_CHECK(keymap, return, "Current pepper_xkb has no keymap.\n");
        state = pepper_xkb_get_state(xkb);
-       HEADLESS_CHECK(state, return, "Current pepper_xkb has no state.\n");
+       HS_CHECK(state, return, "Current pepper_xkb has no state.\n");
 
        min_keycode = xkb_keymap_min_keycode(keymap);
        max_keycode = xkb_keymap_max_keycode(keymap);
@@ -334,7 +341,8 @@ static const headless_debug_action_t debug_actions[] =
 {
        { STDOUT_REDIR,  _headless_debug_redir_stdout, NULL },
        { STDERR_REDIR,  _headless_debug_redir_stderr, NULL },
-       { PROTOCOL_TRACE_ON,  _headless_debug_protocol_trace_on, _headless_debug_protocol_trace_off },
+       { PROTOCOL_TRACE_ON,  _headless_debug_protocol_trace_on,
+               _headless_debug_protocol_trace_off },
        { PROTOCOL_TRACE_OFF, _headless_debug_protocol_trace_off, NULL },
        { KEYGRAB_STATUS, _headless_debug_keygrab_status, NULL },
        { TOPVWINS, _headless_debug_topvwins, NULL },
@@ -351,7 +359,7 @@ _headless_debug_enable_action(headless_debug_t *hdebug, char *cmds)
 
        for(int n=0 ; n < n_actions ; n++) {
                if (!strncmp(cmds, debug_actions[n].cmds, MAX_CMDS)) {
-                       HEADLESS_TRACE("[%s : %s]\n", __FUNCTION__, debug_actions[n].cmds);
+                       HS_TRACE("[%s : %s]\n", __FUNCTION__, debug_actions[n].cmds);
                        debug_actions[n].cb(hdebug, (void *)debug_actions[n].cmds);
 
                        break;
@@ -367,8 +375,9 @@ _headless_debug_disable_action(headless_debug_t *hdebug, char *cmds)
        for(int n=0 ; n < n_actions ; n++) {
                if (!strncmp(cmds, debug_actions[n].cmds, MAX_CMDS)) {
                        if (debug_actions[n].disable_cb) {
-                               HEADLESS_TRACE("[%s : %s]\n", __FUNCTION__, debug_actions[n].cmds);
-                               debug_actions[n].disable_cb(hdebug, (void *)debug_actions[n].cmds);
+                               HS_TRACE("[%s : %s]\n", __FUNCTION__, debug_actions[n].cmds);
+                               debug_actions[n].disable_cb(hdebug,
+                                               (void *)debug_actions[n].cmds);
                        }
 
                        break;
@@ -391,15 +400,16 @@ headless_debug_create(headless_server_t *server)
        bool res = false;
 
        hdebug = (headless_debug_t*)calloc(1, sizeof(headless_debug_t));
-       HEADLESS_CHECK(hdebug, return NULL, "Failed to alloc for headless debug\n");
+       HS_CHECK(hdebug, return NULL, "Failed to alloc for headless debug\n");
        hdebug->server = server;
 
        res = _headless_debug_inotify_init(hdebug);
-       HEADLESS_CHECK(res, goto err_inotify, "Failed to initialize inotify");
+       HS_CHECK(res, goto err_inotify, "Failed to initialize inotify");
 
        n_actions = sizeof(debug_actions)/sizeof(debug_actions[0]);
 
-       HEADLESS_TRACE("[%s] Done (%d actions have been defined.)\n", __FUNCTION__, n_actions);
+       HS_TRACE("[%s] Done (%d actions have been defined.)\n", __FUNCTION__,
+                       n_actions);
 
        return hdebug;
 
@@ -433,9 +443,9 @@ _headless_debug_handle_inotify_fd(int fd, uint32_t mask, void *data)
        int nread;
 
        if ((mask & WL_EVENT_HANGUP) || (mask & WL_EVENT_ERROR)) {
-               HEADLESS_ERROR("With the given fd(%d, mask:0x%x), there is an error "
+               HS_ERROR("With the given fd(%d, mask:0x%x), there is an error "
                                "or it's been hung-up. (error: %m)", fd, mask);
-               HEADLESS_ERROR("The event source will be disabled and the fd will be "
+               HS_ERROR("The event source will be disabled and the fd will be "
                                "closed.");
 
                if (hdebug->inotify.event_source) {
@@ -451,7 +461,7 @@ _headless_debug_handle_inotify_fd(int fd, uint32_t mask, void *data)
                return 0;
 
        nread = read(fd, &ev, sizeof(ev));
-       HEADLESS_CHECK(nread >= 0, return 0,
+       HS_CHECK(nread >= 0, return 0,
                        "Failed on reading given fd. (error msg : %m, fd: %d)", fd);
 
        for (i = 0; i < (nread / sizeof(ev[0])); i++) {
@@ -469,19 +479,19 @@ _headless_debug_inotify_init(headless_debug_t *hdebug)
        int fd, wd;
 
        fd = inotify_init();
-       HEADLESS_CHECK(fd >= 0, return false, "Failed to init inotify");
+       HS_CHECK(fd >= 0, return false, "Failed to init inotify");
 
        wd = inotify_add_watch(fd, path,
                        IN_MODIFY | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO |
                        IN_MOVE_SELF);
-       HEADLESS_CHECK(wd >= 0, goto err_wd,
+       HS_CHECK(wd >= 0, goto err_wd,
                        "Failed to add watch for %s (error msg:%m)", path);
 
        hdebug->inotify.event_source = wl_event_loop_add_fd(
                        wl_display_get_event_loop(hdebug->server->display),
                        fd, WL_EVENT_READABLE, _headless_debug_handle_inotify_fd,
                        hdebug);
-       HEADLESS_CHECK(hdebug->inotify.event_source, goto err_ev,
+       HS_CHECK(hdebug->inotify.event_source, goto err_ev,
                        "Failed to add fd as an event source.");
 
        hdebug->inotify.fd = fd;

diff --git a/src/headless_server.c b/src/headless_server.c
index 55d0365..3a4c6d8 100644 (file)
--- a/src/headless_server.c
+++ b/src/headless_server.c
@@ -32,16 +32,23 @@
 #include <dlog.h>
 #include <tbm_bufmgr.h>
 
-#include <headless_server.h>
+#include "headless_server.h"
 
 int use_output = 1;
 
-static void server_handle_new_shell_surface(struct wl_listener *listener, void *data);
+static void server_handle_new_shell_surface(struct wl_listener *listener,
+               void *data);
+static void server_schedule_idle_task(headless_server_t *server);
+static void server_set_focus_view(headless_server_t *server,
+               headless_view_t *view);
+static void server_set_top_view(headless_server_t *server,
+               headless_view_t *view);
 
 static int
 handle_sigint(int signal_number, void *data)
 {
        struct wl_display *display = (struct wl_display *)data;
+
        wl_display_terminate(display);
 
        return 0;
@@ -82,7 +89,8 @@ handle_ds_log(enum ds_log_level level, const char *fmt, va_list args)
                        fmt, args);
 }
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
        headless_server_t server = { 0, };
        const char *socket_name = NULL;
@@ -94,7 +102,7 @@ int main(int argc, char *argv[])
        setvbuf(stderr, NULL, _IONBF, 0);
 
        if (getenv("HEADLESS_SERVER_DLOG_ENABLE")) {
-               HEADLESS_TRACE("ds log will be written to dlog !\n");
+               HS_TRACE("ds log will be written to dlog !\n");
                ds_log_init(DS_INF, handle_ds_log);
        }
 
@@ -107,9 +115,7 @@ int main(int argc, char *argv[])
                setenv("XDG_RUNTIME_DIR", "/run", 1);
 
        if(!getenv("RUN_WITH_SPEAKER"))
-       {
-               use_output = 0;
-       }
+        use_output = 0;
 
        server.display = wl_display_create();
        if (!server.display) {
@@ -123,47 +129,49 @@ int main(int argc, char *argv[])
        wl_signal_init(&server.events.top_change);
 
        server.compositor = ds_compositor_create(server.display);
-       HEADLESS_CHECK(server.compositor, goto end, "Failed to create ds_compositor");
+       HS_CHECK(server.compositor, goto end, "Failed to create ds_compositor");
 
        server.tbm_server = ds_tbm_server_create(server.display);
-       HEADLESS_CHECK(server.tbm_server, goto end, "Failed to create ds_tbm_server");
+       HS_CHECK(server.tbm_server, goto end, "Failed to create ds_tbm_server");
 
        /* Init event trace */
        server.debug = headless_debug_create(&server);
-       HEADLESS_CHECK(server.debug, goto end, "headless_debug_create() failed\n");
+       HS_CHECK(server.debug, goto end, "headless_debug_create() failed\n");
 
        /* Init input for headless */
        server.input = headless_input_create(&server);
-       HEADLESS_CHECK(server.input, goto end, "headless_input_create() failed\n");
+       HS_CHECK(server.input, goto end, "headless_input_create() failed\n");
 
        /* Init Output */
-       if(use_output)
+       if (use_output)
        {
                server.output = headless_output_create(server.display);
-               HEADLESS_CHECK(server.output, goto end, "headless_output_create() failed.");
+               HS_CHECK(server.output, goto end, "headless_output_create() failed.");
 
                headless_output_start_boot_ani(server.output);
                server.boot_animating = true;
        }
        else {
                bufmgr = tbm_bufmgr_server_init();
-               HEADLESS_CHECK(bufmgr, goto end, "Failed to init tbm buffer manager !\n");
+               HS_CHECK(bufmgr, goto end, "Failed to init tbm buffer manager !\n");
                ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)server.display);
-               HEADLESS_CHECK(ret, goto end, "Failed to bind native display with tbm buffer manager !\n");
+               HS_CHECK(ret, goto end,
+                "Failed to bind native display with tbm buffer manager !\n");
        }
 
        /* Init Shell */
        server.shell = headless_shell_create(server.display);
-       HEADLESS_CHECK(server.shell, goto end, "headless_shell_create() failed.\n");
+       HS_CHECK(server.shell, goto end, "headless_shell_create() failed.\n");
 
        server.new_shell_surface.notify = server_handle_new_shell_surface;
-       headless_shell_add_new_surface_listener(server.shell, &server.new_shell_surface);
+       headless_shell_add_new_surface_listener(server.shell,
+            &server.new_shell_surface);
 
        /* Init Signal for SIGINT */
        init_signal(server.display);
 
        server.name = wl_display_add_socket_auto(server.display);
-       HEADLESS_CHECK(server.name, goto end, "Could not add socket for wayland");
+       HS_CHECK(server.name, goto end, "Could not add socket for wayland");
 
        setenv("WAYLAND_DISPLAY", server.name, true);
 
@@ -179,8 +187,8 @@ end:
 
        if(use_output && server.output)
                headless_output_destroy(server.output);
-       if (bufmgr)
-       {
+
+       if (bufmgr) {
                tbm_bufmgr_deinit(bufmgr);
                bufmgr = NULL;
        }
@@ -198,13 +206,6 @@ end:
 }
 
 static void
-server_schedule_idle_task(headless_server_t *server);
-static void
-server_set_focus_view(headless_server_t *server, headless_view_t *view);
-static void
-server_set_top_view(headless_server_t *server, headless_view_t *view);
-
-static void
 destroy_view(headless_view_t *view)
 {
        ds_inf("view(%p) destroyed", view);
@@ -377,7 +378,7 @@ server_handle_new_shell_surface(struct wl_listener *listener, void *data)
                headless_output_stop_boot_ani(server->output);
        }
 
-       HEADLESS_CHECK(create_view(server, shell_surface), return,
+       HS_CHECK(create_view(server, shell_surface), return,
                        "Could not create headless_view");
 }
 

diff --git a/src/headless_server.h b/src/headless_server.h
index 6ca8378..4697281 100644 (file)
--- a/src/headless_server.h
+++ b/src/headless_server.h
@@ -37,22 +37,22 @@ extern "C" {
 #include <libds/surface.h>
 #include <libds-tizen/tbm_server.h>
 
-#define HEADLESS_ERROR(fmt, ...) \
+#define HS_ERROR(fmt, ...) \
        do { \
                ds_err("%s[%s]: " fmt, __FILE__, __FUNCTION__, ##__VA_ARGS__); \
        } while (0)
 
-#define HEADLESS_TRACE(fmt, ...) \
+#define HS_TRACE(fmt, ...) \
        do { \
                ds_dbg("TRACE: %s[%s]: " fmt, \
                                __FILE__, __FUNCTION__, ##__VA_ARGS__); \
        } while (0)
 
-#define HEADLESS_CHECK(exp, action, fmt, ...) \
+#define HS_CHECK(exp, action, fmt, ...) \
        do { \
                if (!(exp)) \
                { \
-                       HEADLESS_ERROR(fmt, ##__VA_ARGS__); \
+                       HS_ERROR(fmt, ##__VA_ARGS__); \
                        action; \
                } \
        } while (0)
@@ -174,4 +174,3 @@ void headless_input_destroy(headless_input_t *input);
 #endif
 
 #endif /* HEADLESS_SERVER_H */
-

diff --git a/src/input/input.c b/src/input/input.c
index d2786de..b3a7ca0 100644 (file)
--- a/src/input/input.c
+++ b/src/input/input.c
@@ -368,10 +368,14 @@ devicemgr_set_keymap(struct ds_tizen_input_devicemgr *devicemgr)
 
        wl_list_init(&keymap_list);
 
-       devicemgr_add_keymap_data(&keymap_list, KEYNAME_XF86_VOLUME_RAISE, KEYCODE_XF86_VOLUME_RAISE);
-       devicemgr_add_keymap_data(&keymap_list, KEYNAME_XF86_VOLUME_LOWER, KEYCODE_XF86_VOLUME_LOWER);
-       devicemgr_add_keymap_data(&keymap_list, KEYNAME_XF86_LIGHT_ON, KEYCODE_XF86_LIGHT_ON);
-       devicemgr_add_keymap_data(&keymap_list, KEYNAME_XF86_LIGHT_OFF, KEYCODE_XF86_LIGHT_OFF);
+       devicemgr_add_keymap_data(&keymap_list,
+            KEYNAME_XF86_VOLUME_RAISE, KEYCODE_XF86_VOLUME_RAISE);
+       devicemgr_add_keymap_data(&keymap_list,
+            KEYNAME_XF86_VOLUME_LOWER, KEYCODE_XF86_VOLUME_LOWER);
+       devicemgr_add_keymap_data(&keymap_list,
+            KEYNAME_XF86_LIGHT_ON, KEYCODE_XF86_LIGHT_ON);
+       devicemgr_add_keymap_data(&keymap_list,
+            KEYNAME_XF86_LIGHT_OFF, KEYCODE_XF86_LIGHT_OFF);
 
        res = ds_tizen_input_devicemgr_set_keymap_list(devicemgr, &keymap_list);
        if (!res)

diff --git a/src/output/boot_anim.c b/src/output/boot_anim.c
index c1e45c5..f58a2a8 100644 (file)
--- a/src/output/boot_anim.c
+++ b/src/output/boot_anim.c
@@ -74,19 +74,19 @@ void boot_ani_start(led_output_t *output)
        boot_ani_t *ani;
        int ret;
 
-       HEADLESS_TRACE("[OUTPUT] start boot-animation\n");
+       HS_TRACE("[OUTPUT] start boot-animation\n");
 
        loop = wl_display_get_event_loop(output->display);
-       HEADLESS_CHECK(loop, return, "failed to wl_display_get_event_loop()\n");
+       HS_CHECK(loop, return, "failed to wl_display_get_event_loop()\n");
 
        ani = (boot_ani_t *)calloc(sizeof(boot_ani_t), 1);
-       HEADLESS_CHECK(ani, return, "failed to alloc\n");
+       HS_CHECK(ani, return, "failed to alloc\n");
 
        ani->source = wl_event_loop_add_timer(loop, boot_ani_timer_cb, ani);
-       HEADLESS_CHECK(ani->source, goto err, "failed to wl_event_loop_add_timer()\n");
+       HS_CHECK(ani->source, goto err, "failed to wl_event_loop_add_timer()\n");
 
        ret = wl_event_source_timer_update(ani->source, ANI_INTERVAL);
-       HEADLESS_CHECK(!ret, goto err, "failed to wl_event_source_timer_update\n");
+       HS_CHECK(!ret, goto err, "failed to wl_event_source_timer_update\n");
 
        ani->led = output->ui_led;
        output->boot_ani = ani;

diff --git a/src/output/output_led.c b/src/output/output_led.c
index 81369df..4b314fa 100644 (file)
--- a/src/output/output_led.c
+++ b/src/output/output_led.c
@@ -36,10 +36,10 @@ headless_output_create(struct wl_display *display)
 {
        led_output_t *output = (led_output_t*)calloc(sizeof(led_output_t), 1);
 
-       HEADLESS_TRACE("Output Init\n");
+       HS_TRACE("Output Init\n");
 
        if (!output) {
-               HEADLESS_ERROR("Failed to allocate memory in %s\n", __FUNCTION__);
+               HS_ERROR("Failed to allocate memory in %s\n", __FUNCTION__);
                return false;
        }
 
@@ -52,7 +52,7 @@ headless_output_create(struct wl_display *display)
        if (output->ui_led) HL_UI_LED_Change_Brightness(output->ui_led, 0x1);
 
        if (!output->ui_led)
-               HEADLESS_ERROR("HL_UI_LED_Init() failed.\n");
+               HS_ERROR("HL_UI_LED_Init() failed.\n");
 
        return output;
 }
@@ -60,7 +60,7 @@ headless_output_create(struct wl_display *display)
 void
 headless_output_destroy(led_output_t *output)
 {
-       HEADLESS_TRACE("Output Destroy %p", output);
+       HS_TRACE("Output Destroy %p", output);
 
        if (output->boot_ani) {
                boot_ani_stop(output);
@@ -73,7 +73,7 @@ headless_output_destroy(led_output_t *output)
 
        free(output);
 
-       HEADLESS_TRACE("Output Destroy... DONE\n");
+       HS_TRACE("Output Destroy... DONE\n");
 }
 
 void
@@ -83,13 +83,14 @@ headless_output_update_led(led_output_t *output, unsigned char *data)
        uint8_t *ptr = (uint8_t *)data;
 
        if (data == NULL) {
-               HEADLESS_TRACE("[OUTPUT] update LED to empty\n");
+               HS_TRACE("[OUTPUT] update LED to empty\n");
                HL_UI_LED_Clear_All(output->ui_led);
                return;
        }
 
        for(i=0; i<output->num_led; i++) {
-               HL_UI_LED_Set_Pixel_RGB(output->ui_led, i, ptr[R_OFF_SET], ptr[G_OFF_SET], ptr[B_OFF_SET]);
+               HL_UI_LED_Set_Pixel_RGB(output->ui_led, i, ptr[R_OFF_SET],
+                ptr[G_OFF_SET], ptr[B_OFF_SET]);
                ptr += 4;
        }
 

diff --git a/src/shell/shell.c b/src/shell/shell.c
index 976501b..c74a264 100644 (file)
--- a/src/shell/shell.c
+++ b/src/shell/shell.c
@@ -42,10 +42,10 @@ typedef enum {
        HEADLESS_SURFACE_POPUP
 } headless_surface_type_t;
 
-typedef struct HEADLESS_SHELL headless_shell_t;
-typedef struct HEADLESS_SHELL_SURFACE headless_shell_surface_t;
+typedef struct headless_shell headless_shell_t;
+typedef struct headless_shell_surface headless_shell_surface_t;
 
-struct HEADLESS_SHELL{
+struct headless_shell {
        struct wl_display *display;
        struct wl_global *zxdg_shell;
        struct wl_global *tizen_policy;
@@ -56,7 +56,7 @@ struct HEADLESS_SHELL{
        } events;
 };
 
-struct HEADLESS_SHELL_SURFACE{
+struct headless_shell_surface {
        headless_shell_t *hs_shell;
        struct ds_surface *ds_surface;
        uint32_t        updates;
@@ -84,15 +84,17 @@ struct HEADLESS_SHELL_SURFACE{
 };
 
 static void reset_headless_shell_surface(headless_shell_surface_t *hs_surface);
-static void destroy_headless_shell_surface(headless_shell_surface_t *hs_surface);
+static void
+destroy_headless_shell_surface(headless_shell_surface_t *hs_surface);
 static void map_headless_shell_surface(headless_shell_surface_t *hs_surface);
 static void unmap_headless_shell_surface(headless_shell_surface_t *hs_surface);
 
 static void
 zxdg_toplevel_cb_resource_destroy(struct wl_resource *resource)
 {
-       headless_shell_surface_t *hs_surface = (headless_shell_surface_t *)wl_resource_get_user_data(resource);
+       headless_shell_surface_t *hs_surface;
 
+       hs_surface = wl_resource_get_user_data(resource);
        if (!hs_surface)
                return;
 
@@ -100,104 +102,108 @@ zxdg_toplevel_cb_resource_destroy(struct wl_resource *resource)
 }
 
 static void
-zxdg_toplevel_cb_destroy(struct wl_client *client, struct wl_resource *resource)
+zxdg_toplevel_cb_destroy(struct wl_client *client,
+               struct wl_resource *resource)
 {
        wl_resource_destroy(resource);
 }
 
 static void
 zxdg_toplevel_cb_parent_set(struct wl_client *client,
-                           struct wl_resource *resource,
-                           struct wl_resource *res_parent)
+               struct wl_resource *resource,
+               struct wl_resource *res_parent)
 {
 }
 
 static void
 zxdg_toplevel_cb_title_set(struct wl_client *client,
-                          struct wl_resource *resource,
-                          const char *title)
+               struct wl_resource *resource,
+               const char *title)
 {
 }
 
 static void
 zxdg_toplevel_cb_app_id_set(struct wl_client *client,
-                           struct wl_resource *resource,
-                           const char *app_id)
+               struct wl_resource *resource,
+               const char *app_id)
 {
 }
 
 static void
 zxdg_toplevel_cb_win_menu_show(struct wl_client *client,
-                              struct wl_resource *resource,
-                              struct wl_resource *res_seat,
-                              uint32_t serial,
-                              int32_t x,
-                              int32_t y)
+               struct wl_resource *resource,
+               struct wl_resource *res_seat,
+               uint32_t serial,
+               int32_t x,
+               int32_t y)
 {
 }
 
 static void
 zxdg_toplevel_cb_move(struct wl_client *client,
-                     struct wl_resource *resource,
-                     struct wl_resource *res_seat,
-                     uint32_t serial)
+               struct wl_resource *resource,
+               struct wl_resource *res_seat,
+               uint32_t serial)
 {
 }
 
 static void
 zxdg_toplevel_cb_resize(struct wl_client *client,
-                       struct wl_resource *resource,
-                       struct wl_resource *res_seat,
-                       uint32_t serial,
-                       uint32_t edges)
+               struct wl_resource *resource,
+               struct wl_resource *res_seat,
+               uint32_t serial,
+               uint32_t edges)
 {
 }
 
 static void
 zxdg_toplevel_cb_max_size_set(struct wl_client *client,
-                             struct wl_resource *resource,
-                             int32_t w,
-                             int32_t h)
+               struct wl_resource *resource,
+               int32_t w,
+               int32_t h)
 {
 }
 
 static void
 zxdg_toplevel_cb_min_size_set(struct wl_client *client,
-                             struct wl_resource *resource,
-                             int32_t w,
-                             int32_t h)
+               struct wl_resource *resource,
+               int32_t w,
+               int32_t h)
 {
 }
 
 static void
-zxdg_toplevel_cb_maximized_set(struct wl_client *client, struct wl_resource *resource)
+zxdg_toplevel_cb_maximized_set(struct wl_client *client,
+               struct wl_resource *resource)
 {
 }
 
 static void
-zxdg_toplevel_cb_maximized_unset(struct wl_client *client, struct wl_resource *resource)
+zxdg_toplevel_cb_maximized_unset(struct wl_client *client,
+               struct wl_resource *resource)
 {
 }
 
 static void
 zxdg_toplevel_cb_fullscreen_set(struct wl_client *client,
-                               struct wl_resource *resource,
-                               struct wl_resource *res_output)
+               struct wl_resource *resource,
+               struct wl_resource *res_output)
 {
 }
 
 static void
-zxdg_toplevel_cb_fullscreen_unset(struct wl_client *client, struct wl_resource *resource)
+zxdg_toplevel_cb_fullscreen_unset(struct wl_client *client,
+               struct wl_resource *resource)
 {
 }
 
 static void
-zxdg_toplevel_cb_minimized_set(struct wl_client *client, struct wl_resource *resource)
+zxdg_toplevel_cb_minimized_set(struct wl_client *client,
+               struct wl_resource *resource)
 {
 }
 
-static const struct zxdg_toplevel_v6_interface zxdg_toplevel_interface =
-{
+static const struct zxdg_toplevel_v6_interface zxdg_toplevel_interface = {
        zxdg_toplevel_cb_destroy,
        zxdg_toplevel_cb_parent_set,
        zxdg_toplevel_cb_title_set,
@@ -217,11 +223,14 @@ static const struct zxdg_toplevel_v6_interface zxdg_toplevel_interface =
 static void
 zxdg_popup_cb_resource_destroy(struct wl_resource *resource)
 {
-       headless_shell_surface_t *hs_surface = (headless_shell_surface_t *)wl_resource_get_user_data(resource);
+       headless_shell_surface_t *hs_surface;
 
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_surface.\n");
-       HEADLESS_CHECK((hs_surface->surface_type == HEADLESS_SURFACE_POPUP), return, "Invalid surface type.\n");
-       HEADLESS_CHECK((hs_surface->zxdg_surface == resource), return, "Invalid surface.");
+       hs_surface = wl_resource_get_user_data(resource);
+       HS_CHECK(hs_surface, return, "fail to get headless_surface.\n");
+       HS_CHECK((hs_surface->surface_type == HEADLESS_SURFACE_POPUP), return,
+                       "Invalid surface type.\n");
+       HS_CHECK((hs_surface->zxdg_surface == resource), return,
+                       "Invalid surface.");
 
        hs_surface->surface_type = HEADLESS_SURFACE_NONE;
        hs_surface->zxdg_surface = NULL;
@@ -236,14 +245,13 @@ zxdg_popup_cb_destroy(struct wl_client *client, struct wl_resource *resource)
 
 static void
 zxdg_popup_cb_grab(struct wl_client *client,
-                  struct wl_resource *resource,
-                  struct wl_resource *res_seat,
-                  uint32_t serial)
+               struct wl_resource *resource,
+               struct wl_resource *res_seat,
+               uint32_t serial)
 {
 }
 
-static const struct zxdg_popup_v6_interface zxdg_popup_interface =
-{
+static const struct zxdg_popup_v6_interface zxdg_popup_interface = {
        zxdg_popup_cb_destroy,
        zxdg_popup_cb_grab
 };
@@ -257,7 +265,8 @@ zxdg_surface_cb_resource_destroy(struct wl_resource *resource)
        if (!hs_surface)
                return;
 
-       HEADLESS_TRACE("[SHELL] zxdg_surface_cb_resource_destroy: hs_surface:%p", hs_surface);
+       HS_TRACE("[SHELL] zxdg_surface_cb_resource_destroy: hs_surface:%p",
+                       hs_surface);
 
        destroy_headless_shell_surface(hs_surface);
 }
@@ -292,19 +301,20 @@ headless_toplevel_handle_surface_commit(struct ds_surface *ds_surface)
        }
 }
 
-static const struct ds_surface_role xdg_toplevel_role =
-{
+static const struct ds_surface_role xdg_toplevel_role = {
        .name = "headless_shell_surface",
        .commit = headless_toplevel_handle_surface_commit,
 };
 
 static void
-zxdg_surface_cb_toplevel_get(struct wl_client *client, struct wl_resource *resource, uint32_t id)
+zxdg_surface_cb_toplevel_get(struct wl_client *client,
+               struct wl_resource *resource, uint32_t id)
 {
-       headless_shell_surface_t *hs_surface = (headless_shell_surface_t *)wl_resource_get_user_data(resource);
+       headless_shell_surface_t *hs_surface;
        struct wl_resource *new_res;
 
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_surface\n");
+       hs_surface = wl_resource_get_user_data(resource);
+       HS_CHECK(hs_surface, return, "fail to get headless_surface\n");
 
        if (!ds_surface_set_role(hs_surface->ds_surface, &xdg_toplevel_role,
                                hs_surface, resource, ZXDG_SHELL_V6_ERROR_ROLE))
@@ -319,7 +329,7 @@ zxdg_surface_cb_toplevel_get(struct wl_client *client, struct wl_resource *resou
 
        new_res = wl_resource_create(client, &zxdg_toplevel_v6_interface, 1, id);
        if (!new_res) {
-               HEADLESS_ERROR("fail to create zxdg_toplevel");
+               HS_ERROR("fail to create zxdg_toplevel");
                wl_resource_post_no_memory(resource);
                return;
        }
@@ -335,28 +345,31 @@ zxdg_surface_cb_toplevel_get(struct wl_client *client, struct wl_resource *resou
 
 static void
 zxdg_surface_cb_popup_get(struct wl_client *client,
-                                                                       struct wl_resource *resource,
-                                                                       uint32_t id,
-                                                                       struct wl_resource *res_parent,
-                                                                       struct wl_resource *res_pos)
+               struct wl_resource *resource,
+               uint32_t id,
+               struct wl_resource *res_parent,
+               struct wl_resource *res_pos)
 {
-       headless_shell_surface_t *hs_surface = (headless_shell_surface_t *)wl_resource_get_user_data(resource);
+       headless_shell_surface_t *hs_surface;
        struct wl_resource *new_res;
 
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_surface\n");
-       HEADLESS_CHECK((hs_surface->zxdg_surface == NULL), return, "alwreay assign zdg_surface:%p role:%d\n", hs_surface->zxdg_surface, hs_surface->surface_type);
+       hs_surface = wl_resource_get_user_data(resource);
+       HS_CHECK(hs_surface, return, "fail to get headless_surface\n");
+       HS_CHECK((hs_surface->zxdg_surface == NULL), return,
+                       "alwreay assign zdg_surface:%p role:%d\n",
+                       hs_surface->zxdg_surface, hs_surface->surface_type);
 
        new_res = wl_resource_create(client, &zxdg_popup_v6_interface, 1, id);
        if (!new_res) {
-               HEADLESS_ERROR("fail to create popup");
+               HS_ERROR("fail to create popup");
                wl_resource_post_no_memory(resource);
                return;
        }
 
        wl_resource_set_implementation(new_res,
-                                 &zxdg_popup_interface,
-                                 hs_surface,
-                                 zxdg_popup_cb_resource_destroy);
+                       &zxdg_popup_interface,
+                       hs_surface,
+                       zxdg_popup_cb_resource_destroy);
 
        hs_surface->surface_type = HEADLESS_SURFACE_POPUP;
        hs_surface->zxdg_surface = new_res;
@@ -366,27 +379,24 @@ zxdg_surface_cb_popup_get(struct wl_client *client,
 
 static void
 zxdg_surface_cb_win_geometry_set(struct wl_client *client,
-                                   struct wl_resource *resource,
-                                   int32_t x,
-                                   int32_t y,
-                                   int32_t w,
-                                   int32_t h)
+               struct wl_resource *resource,
+               int32_t x, int32_t y, int32_t w, int32_t h)
 {
 }
 
 static void
-zxdg_surface_cb_configure_ack(struct wl_client *client, struct wl_resource *resource, uint32_t serial)
+zxdg_surface_cb_configure_ack(struct wl_client *client,
+               struct wl_resource *resource, uint32_t serial)
 {
        headless_shell_surface_t *hs_surface;
 
        hs_surface = wl_resource_get_user_data(resource);
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
+       HS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
 
        hs_surface->last_ack_configure = serial;
 }
 
-static const struct zxdg_surface_v6_interface zxdg_surface_interface =
-{
+static const struct zxdg_surface_v6_interface zxdg_surface_interface = {
        zxdg_surface_cb_destroy,
        zxdg_surface_cb_toplevel_get,
        zxdg_surface_cb_popup_get,
@@ -395,55 +405,51 @@ static const struct zxdg_surface_v6_interface zxdg_surface_interface =
 };
 
 static void
-zxdg_positioner_cb_destroy(struct wl_client *client, struct wl_resource *resource)
+zxdg_positioner_cb_destroy(struct wl_client *client,
+               struct wl_resource *resource)
 {
        wl_resource_destroy(resource);
 }
 
 static void
 zxdg_positioner_cb_size_set(struct wl_client *client,
-                           struct wl_resource *resource,
-                           int32_t w, int32_t h)
+               struct wl_resource *resource, int32_t w, int32_t h)
 {
 }
 
 static void
 zxdg_positioner_cb_anchor_rect_set(struct wl_client *client,
-                                  struct wl_resource *resource,
-                                  int32_t x, int32_t y, int32_t w, int32_t h)
+               struct wl_resource *resource,
+               int32_t x, int32_t y, int32_t w, int32_t h)
 {
 }
 
 static void
 zxdg_positioner_cb_anchor_set(struct wl_client *client,
-                             struct wl_resource *resource,
-                             enum zxdg_positioner_v6_anchor anchor)
+               struct wl_resource *resource, enum zxdg_positioner_v6_anchor anchor)
 {
 }
 
 static void
 zxdg_positioner_cb_gravity_set(struct wl_client *client,
-                              struct wl_resource *resource,
-                              enum zxdg_positioner_v6_gravity gravity)
+               struct wl_resource *resource, enum zxdg_positioner_v6_gravity gravity)
 {
 }
 
 static void
 zxdg_positioner_cb_constraint_adjustment_set(struct wl_client *client,
-                                            struct wl_resource *resource,
-                                            enum zxdg_positioner_v6_constraint_adjustment constraint_adjustment)
+               struct wl_resource *resource,
+               enum zxdg_positioner_v6_constraint_adjustment constraint_adjustment)
 {
 }
 
 static void
 zxdg_positioner_cb_offset_set(struct wl_client *client,
-                             struct wl_resource *resource,
-                             int32_t x, int32_t y)
+               struct wl_resource *resource, int32_t x, int32_t y)
 {
 }
 
-static const struct zxdg_positioner_v6_interface zxdg_positioner_interface =
-{
+static const struct zxdg_positioner_v6_interface zxdg_positioner_interface = {
        zxdg_positioner_cb_destroy,
        zxdg_positioner_cb_size_set,
        zxdg_positioner_cb_anchor_rect_set,
@@ -456,27 +462,28 @@ static const struct zxdg_positioner_v6_interface zxdg_positioner_interface =
 static void
 zxdg_shell_cb_destroy(struct wl_client *client, struct wl_resource *resource)
 {
-       HEADLESS_TRACE("Destroy zxdg_shell\n");
+       HS_TRACE("Destroy zxdg_shell\n");
 
        wl_resource_destroy(resource);
 }
 
 static void
-zxdg_shell_cb_positioner_create(struct wl_client *client, struct wl_resource *resource, uint32_t id)
+zxdg_shell_cb_positioner_create(struct wl_client *client,
+               struct wl_resource *resource, uint32_t id)
 {
        struct wl_resource *new_res;
 
-       HEADLESS_TRACE("Create zxdg_positoiner\n");
+       HS_TRACE("Create zxdg_positoiner\n");
 
        new_res = wl_resource_create(client, &zxdg_positioner_v6_interface, 1, id);
-       if (!new_res)
-       {
-               HEADLESS_ERROR("fail to create zxdg_positioner\n");
+       if (!new_res) {
+               HS_ERROR("fail to create zxdg_positioner\n");
                wl_resource_post_no_memory(resource);
                return;
        }
 
-       wl_resource_set_implementation(new_res, &zxdg_positioner_interface, NULL, NULL);
+       wl_resource_set_implementation(new_res, &zxdg_positioner_interface,
+                       NULL, NULL);
 }
 
 static void
@@ -521,7 +528,7 @@ reset_headless_shell_surface(headless_shell_surface_t *hs_surface)
 static void
 destroy_headless_shell_surface(headless_shell_surface_t *hs_surface)
 {
-       HEADLESS_TRACE("[SHELL] hs_surface free ds_surface:%p, "
+       HS_TRACE("[SHELL] hs_surface free ds_surface:%p, "
                        "zxdg_shell_surface:%p, zxdg_surface:%p", 
                        hs_surface->ds_surface, hs_surface->zxdg_shell_surface,
                        hs_surface->zxdg_surface);
@@ -551,7 +558,9 @@ headless_shell_surface_cb_surface_destroy(struct wl_listener *listener,
 }
 
 static void
-zxdg_shell_cb_surface_get(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *wsurface)
+zxdg_shell_cb_surface_get(struct wl_client *client,
+               struct wl_resource *resource, uint32_t id,
+               struct wl_resource *wsurface)
 {
        headless_shell_t *hs;
        headless_shell_surface_t *hs_surface = NULL;
@@ -559,14 +568,14 @@ zxdg_shell_cb_surface_get(struct wl_client *client, struct wl_resource *resource
 
        hs = wl_resource_get_user_data(resource);
        if (!hs) {
-               HEADLESS_ERROR("fail to get headless_shell\n");
+               HS_ERROR("fail to get headless_shell\n");
                wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
                                "failed to get headless shell");
                return;
        }
 
        ds_surface = ds_surface_from_resource(wsurface);
-       HEADLESS_CHECK(ds_surface, goto error, "faile to get ds_surface\n");
+       HS_CHECK(ds_surface, goto error, "faile to get ds_surface\n");
 
        hs_surface = calloc(1, sizeof *hs_surface);
        if (!hs_surface) {
@@ -585,9 +594,10 @@ zxdg_shell_cb_surface_get(struct wl_client *client, struct wl_resource *resource
        wl_signal_init(&hs_surface->events.set_skip_focus);
        wl_signal_init(&hs_surface->events.unset_skip_focus);
 
-       hs_surface->zxdg_shell_surface = wl_resource_create(client, &zxdg_surface_v6_interface, 1, id);
+       hs_surface->zxdg_shell_surface = wl_resource_create(client,
+                       &zxdg_surface_v6_interface, 1, id);
        if (!hs_surface->zxdg_shell_surface) {
-               HEADLESS_ERROR("fail to create the zxdg_surface\n");
+               HS_ERROR("fail to create the zxdg_surface\n");
                wl_resource_post_no_memory(resource);
                goto error;
        }
@@ -601,7 +611,7 @@ zxdg_shell_cb_surface_get(struct wl_client *client, struct wl_resource *resource
                headless_shell_surface_cb_surface_destroy;
        ds_surface_add_destroy_listener(ds_surface, &hs_surface->surface_destroy);
 
-       HEADLESS_TRACE("[SHELL] create zxdg_surface:%p, ds_surface:%p\n",
+       HS_TRACE("[SHELL] create zxdg_surface:%p, ds_surface:%p\n",
                        hs_surface->zxdg_shell_surface,
                        hs_surface->ds_surface);
 
@@ -618,13 +628,13 @@ error:
 }
 
 static void
-zxdg_shell_cb_pong(struct wl_client *client, struct wl_resource *resource, uint32_t serial)
+zxdg_shell_cb_pong(struct wl_client *client, struct wl_resource *resource,
+               uint32_t serial)
 {
 
 }
 
-static const struct zxdg_shell_v6_interface zxdg_shell_interface =
-{
+static const struct zxdg_shell_v6_interface zxdg_shell_interface = {
        zxdg_shell_cb_destroy,
        zxdg_shell_cb_positioner_create,
        zxdg_shell_cb_surface_get,
@@ -632,19 +642,18 @@ static const struct zxdg_shell_v6_interface zxdg_shell_interface =
 };
 
 static void
-zxdg_shell_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
+zxdg_shell_cb_bind(struct wl_client *client, void *data, uint32_t version,
+               uint32_t id)
 {
        struct wl_resource *resource;
        headless_shell_t *hs = (headless_shell_t *)data;
 
-       HEADLESS_TRACE("Bind zxdg_shell\n");
+       HS_TRACE("Bind zxdg_shell\n");
 
        /* Create resource for zxdg_shell_v6 */
-       resource = wl_resource_create(client,
-                       &zxdg_shell_v6_interface,
-                       version,
-                       id);
-       HEADLESS_CHECK(resource, goto err_shell, "fail to create the zxdg_shell_v6\n");
+       resource = wl_resource_create(client, &zxdg_shell_v6_interface,
+                       version, id);
+       HS_CHECK(resource, goto err_shell, "fail to create the zxdg_shell_v6\n");
 
        wl_resource_set_implementation(resource, &zxdg_shell_interface, hs, NULL);
 
@@ -656,8 +665,9 @@ err_shell:
 static bool
 zxdg_init(headless_shell_t *shell)
 {
-       shell->zxdg_shell = wl_global_create(shell->display, &zxdg_shell_v6_interface, 1, shell, zxdg_shell_cb_bind);
-       HEADLESS_CHECK(shell->zxdg_shell, return false, "fail to create zxdg_shell\n");
+       shell->zxdg_shell = wl_global_create(shell->display,
+                       &zxdg_shell_v6_interface, 1, shell, zxdg_shell_cb_bind);
+       HS_CHECK(shell->zxdg_shell, return false, "fail to create zxdg_shell\n");
 
        return true;
 }
@@ -670,7 +680,8 @@ zxdg_deinit(headless_shell_t *shell)
 }
 
 static void
-tizen_visibility_cb_destroy(struct wl_client *client, struct wl_resource *res_tzvis)
+tizen_visibility_cb_destroy(struct wl_client *client,
+               struct wl_resource *res_tzvis)
 {
        wl_resource_destroy(res_tzvis);
 }
@@ -683,8 +694,9 @@ static const struct tizen_visibility_interface tizen_visibility =
 static void
 tizen_visibility_cb_vis_destroy(struct wl_resource *res_tzvis)
 {
-       headless_shell_surface_t *hs_surface = (headless_shell_surface_t *)wl_resource_get_user_data(res_tzvis);
+       headless_shell_surface_t *hs_surface;
 
+       hs_surface = wl_resource_get_user_data(res_tzvis);
        if (!hs_surface)
                return;
 
@@ -692,18 +704,19 @@ tizen_visibility_cb_vis_destroy(struct wl_resource *res_tzvis)
 }
 
 static void
-tizen_position_cb_destroy(struct wl_client *client, struct wl_resource *res_tzpos)
+tizen_position_cb_destroy(struct wl_client *client,
+               struct wl_resource *res_tzpos)
 {
    wl_resource_destroy(res_tzpos);
 }
 
 static void
-tizen_position_cb_set(struct wl_client *client, struct wl_resource *res_tzpos, int32_t x, int32_t y)
+tizen_position_cb_set(struct wl_client *client, struct wl_resource *res_tzpos,
+               int32_t x, int32_t y)
 {
 }
 
-static const struct tizen_position_interface tizen_position =
-{
+static const struct tizen_position_interface tizen_position = {
    tizen_position_cb_destroy,
    tizen_position_cb_set,
 };
@@ -722,21 +735,22 @@ headless_shell_surface_from_ds_surface(struct ds_surface *ds_surface)
 }
 
 static void
-tizen_policy_cb_vis_get(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surf)
+tizen_policy_cb_vis_get(struct wl_client *client, struct wl_resource *resource,
+               uint32_t id, struct wl_resource *surf)
 {
        struct ds_surface *ds_surface;
        headless_shell_surface_t *hs_surface;
        struct wl_resource *new_res;
 
        ds_surface = ds_surface_from_resource(surf);
-       HEADLESS_CHECK(ds_surface, return, "fail to get ds_surface_t\n");
+       HS_CHECK(ds_surface, return, "fail to get ds_surface_t\n");
 
        hs_surface = headless_shell_surface_from_ds_surface(ds_surface);
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
+       HS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
 
        new_res = wl_resource_create(client, &tizen_visibility_interface, 5, id);
        if (!new_res) {
-               HEADLESS_ERROR("fail to create tizen_visibility");
+               HS_ERROR("fail to create tizen_visibility");
                wl_resource_post_no_memory(resource);
                return;
        }
@@ -748,236 +762,281 @@ tizen_policy_cb_vis_get(struct wl_client *client, struct wl_resource *resource,
 
        hs_surface->tizen_visibility = new_res;
 
-       if (hs_surface->visibility != TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED)
-               tizen_visibility_send_notify(hs_surface->tizen_visibility, hs_surface->visibility);
+       if (hs_surface->visibility != TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED) {
+               tizen_visibility_send_notify(hs_surface->tizen_visibility,
+                               hs_surface->visibility);
+       }
 }
 
 static void
-tizen_policy_cb_pos_get(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surf)
+tizen_policy_cb_pos_get(struct wl_client *client, struct wl_resource *resource,
+               uint32_t id, struct wl_resource *surf)
 {
        struct wl_resource *new_res;
 
        new_res = wl_resource_create(client, &tizen_position_interface, 1, id);
        if (!new_res) {
-               HEADLESS_ERROR("fail to create tizen_visibility");
+               HS_ERROR("fail to create tizen_visibility");
                wl_resource_post_no_memory(resource);
                return;
        }
 
-       wl_resource_set_implementation(new_res,
-                       &tizen_position,
-                       NULL,
+       wl_resource_set_implementation(new_res, &tizen_position, NULL,
                        tizen_position_cb_pos_destroy);
 }
 
 static void
-tizen_policy_cb_activate(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_activate(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
        struct ds_surface *ds_surface;
        headless_shell_surface_t *hs_surface;
 
        ds_surface = ds_surface_from_resource(surf);
-       HEADLESS_CHECK(ds_surface, return, "fail to get ds_surface\n");
+       HS_CHECK(ds_surface, return, "fail to get ds_surface\n");
 
        hs_surface = headless_shell_surface_from_ds_surface(ds_surface);
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
+       HS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
 
        wl_signal_emit(&hs_surface->events.request_activate, hs_surface);
 }
 
 static void
-tizen_policy_cb_activate_below_by_res_id(struct wl_client *client, struct wl_resource *resource,  uint32_t res_id, uint32_t below_res_id)
+tizen_policy_cb_activate_below_by_res_id(struct wl_client *client,
+               struct wl_resource *resource,  uint32_t res_id, uint32_t below_res_id)
 {
 }
 
 static void
-tizen_policy_cb_raise(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_raise(struct wl_client *client, struct wl_resource *resource,
+               struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_lower(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_lower(struct wl_client *client, struct wl_resource *resource,
+               struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_lower_by_res_id(struct wl_client *client, struct wl_resource *resource,  uint32_t res_id)
+tizen_policy_cb_lower_by_res_id(struct wl_client *client,
+               struct wl_resource *resource,  uint32_t res_id)
 {
 }
 
 static void
-tizen_policy_cb_focus_skip_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_focus_skip_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
        struct ds_surface *ds_surface;
        headless_shell_surface_t *hs_surface;
 
        ds_surface = ds_surface_from_resource(surf);
-       HEADLESS_CHECK(ds_surface, return, "fail to get ds_surface\n");
+       HS_CHECK(ds_surface, return, "fail to get ds_surface\n");
 
        hs_surface = headless_shell_surface_from_ds_surface(ds_surface);
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
+       HS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
 
        wl_signal_emit(&hs_surface->events.set_skip_focus, hs_surface);
 }
 
 static void
-tizen_policy_cb_focus_skip_unset(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_focus_skip_unset(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
        struct ds_surface *ds_surface;
        headless_shell_surface_t *hs_surface;
 
        ds_surface = ds_surface_from_resource(surf);
-       HEADLESS_CHECK(ds_surface, return, "fail to get ds_surface\n");
+       HS_CHECK(ds_surface, return, "fail to get ds_surface\n");
 
        hs_surface = headless_shell_surface_from_ds_surface(ds_surface);
-       HEADLESS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
+       HS_CHECK(hs_surface, return, "fail to get headless_shell_surface\n");
 
        wl_signal_emit(&hs_surface->events.unset_skip_focus, hs_surface);
 }
 
 static void
-tizen_policy_cb_role_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, const char *role)
+tizen_policy_cb_role_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf,
+               const char *role)
 {
 }
 
 static void
-tizen_policy_cb_type_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, uint32_t type)
+tizen_policy_cb_type_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, uint32_t type)
 {
 }
 
 static void
-tizen_policy_cb_conformant_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_conformant_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_conformant_unset(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_conformant_unset(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_conformant_get(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_conformant_get(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
    tizen_policy_send_conformant(resource, surf, 0);
 }
 
 static void
-tizen_policy_cb_notilv_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, int32_t lv)
+tizen_policy_cb_notilv_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, int32_t lv)
 {
 }
 
 static void
-tizen_policy_cb_transient_for_set(struct wl_client *client, struct wl_resource *resource, uint32_t child_id, uint32_t parent_id)
+tizen_policy_cb_transient_for_set(struct wl_client *client,
+               struct wl_resource *resource, uint32_t child_id, uint32_t parent_id)
 {
 }
 
 static void
-tizen_policy_cb_transient_for_unset(struct wl_client *client, struct wl_resource *resource, uint32_t child_id)
+tizen_policy_cb_transient_for_unset(struct wl_client *client,
+               struct wl_resource *resource, uint32_t child_id)
 {
    tizen_policy_send_transient_for_done(resource, child_id);
 }
 
 static void
-tizen_policy_cb_win_scrmode_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, uint32_t mode)
+tizen_policy_cb_win_scrmode_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, uint32_t mode)
 {
    tizen_policy_send_window_screen_mode_done
      (resource, surf, mode, TIZEN_POLICY_ERROR_STATE_NONE);
 }
 
 static void
-tizen_policy_cb_subsurf_place_below_parent(struct wl_client *client, struct wl_resource *resource, struct wl_resource *subsurf)
+tizen_policy_cb_subsurf_place_below_parent(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *subsurf)
 {
 }
 
 static void
-tizen_policy_cb_subsurf_stand_alone_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *subsurf)
+tizen_policy_cb_subsurf_stand_alone_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *subsurf)
 {
 }
 
 static void
-tizen_policy_cb_subsurface_get(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surface, uint32_t parent_id)
+tizen_policy_cb_subsurface_get(struct wl_client *client,
+               struct wl_resource *resource, uint32_t id, struct wl_resource *surface,
+               uint32_t parent_id)
 {
-       wl_client_post_implementation_error(client, "Headless server not support tizen_subsurface\n");
+       wl_client_post_implementation_error(client,
+                       "Headless server not support tizen_subsurface\n");
 }
 
 static void
-tizen_policy_cb_opaque_state_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, int32_t state)
+tizen_policy_cb_opaque_state_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surface,
+               int32_t state)
 {
 }
 
 static void
-tizen_policy_cb_iconify(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_iconify(struct wl_client *client, struct wl_resource *resource,
+               struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_uniconify(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_uniconify(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_aux_hint_add(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, int32_t id, const char *name, const char *value)
+tizen_policy_cb_aux_hint_add(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, int32_t id,
+               const char *name, const char *value)
 {
 }
 
 static void
-tizen_policy_cb_aux_hint_change(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, int32_t id, const char *value)
+tizen_policy_cb_aux_hint_change(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, int32_t id,
+               const char *value)
 {
 }
 
 static void
-tizen_policy_cb_aux_hint_del(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, int32_t id)
+tizen_policy_cb_aux_hint_del(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, int32_t id)
 {
 }
 
 static void
-tizen_policy_cb_supported_aux_hints_get(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_supported_aux_hints_get(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_background_state_set(struct wl_client *client, struct wl_resource *resource, uint32_t pid)
+tizen_policy_cb_background_state_set(struct wl_client *client,
+               struct wl_resource *resource, uint32_t pid)
 {
 }
 
 static void
-tizen_policy_cb_background_state_unset(struct wl_client *client, struct wl_resource *resource, uint32_t pid)
+tizen_policy_cb_background_state_unset(struct wl_client *client,
+               struct wl_resource *resource, uint32_t pid)
 {
 }
 
 static void
-tizen_policy_cb_floating_mode_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_floating_mode_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_floating_mode_unset(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf)
+tizen_policy_cb_floating_mode_unset(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf)
 {
 }
 
 static void
-tizen_policy_cb_stack_mode_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surf, uint32_t mode)
+tizen_policy_cb_stack_mode_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surf, uint32_t mode)
 {
 }
 
 static void
-tizen_policy_cb_activate_above_by_res_id(struct wl_client *client, struct wl_resource *resource,  uint32_t res_id, uint32_t above_res_id)
+tizen_policy_cb_activate_above_by_res_id(struct wl_client *client,
+               struct wl_resource *resource,  uint32_t res_id, uint32_t above_res_id)
 {
 }
 
 static void
-tizen_policy_cb_subsurf_watcher_get(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surface)
+tizen_policy_cb_subsurf_watcher_get(struct wl_client *client,
+               struct wl_resource *resource, uint32_t id, struct wl_resource *surface)
 {
-       wl_client_post_implementation_error(client, "Headless server not support tizen_subsurface\n");
+       wl_client_post_implementation_error(client,
+                       "Headless server not support tizen_subsurface\n");
 }
 
 static void
-tizen_policy_cb_parent_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *child, struct wl_resource *parent)
+tizen_policy_cb_parent_set(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *child,
+               struct wl_resource *parent)
 {
 }
 
 static void
-tizen_policy_cb_ack_conformant_region(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t serial)
+tizen_policy_cb_ack_conformant_region(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surface,
+               uint32_t serial)
 {
 }
 
@@ -988,12 +1047,13 @@ tizen_policy_cb_destroy(struct wl_client *client, struct wl_resource *resource)
 }
 
 static void
-tizen_policy_cb_has_video(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t has)
+tizen_policy_cb_has_video(struct wl_client *client,
+               struct wl_resource *resource, struct wl_resource *surface,
+               uint32_t has)
 {
 }
 
-static const struct tizen_policy_interface tizen_policy_iface =
-{
+static const struct tizen_policy_interface tizen_policy_iface = {
    tizen_policy_cb_vis_get,
    tizen_policy_cb_pos_get,
    tizen_policy_cb_activate,
@@ -1038,30 +1098,27 @@ static const struct tizen_policy_interface tizen_policy_iface =
 static void
 tizen_policy_cb_unbind(struct wl_resource *resource)
 {
-       headless_shell_t *shell = (headless_shell_t *)wl_resource_get_user_data(resource);
+       headless_shell_t *shell;
 
+       shell = wl_resource_get_user_data(resource);
        if (shell)
                shell->tizen_policy = NULL;
 }
 
 static void
-tizen_policy_cb_bind(struct wl_client *client, void *data, uint32_t ver, uint32_t id)
+tizen_policy_cb_bind(struct wl_client *client, void *data, uint32_t ver,
+               uint32_t id)
 {
        headless_shell_t *shell = (headless_shell_t *)data;
        struct wl_resource *resource;
 
-       HEADLESS_CHECK(shell, goto err, "data is NULL\n");
+       HS_CHECK(shell, goto err, "data is NULL\n");
 
-       resource = wl_resource_create(client,
-                                                                       &tizen_policy_interface,
-                                                                       ver,
-                                                                       id);
-       HEADLESS_CHECK(resource, goto err, "fail to create tizen_policy\n");
+       resource = wl_resource_create(client, &tizen_policy_interface, ver, id);
+       HS_CHECK(resource, goto err, "fail to create tizen_policy\n");
 
-       wl_resource_set_implementation(resource,
-                                                                       &tizen_policy_iface,
-                                                                       shell,
-                                                                       tizen_policy_cb_unbind);
+       wl_resource_set_implementation(resource, &tizen_policy_iface, shell,
+                       tizen_policy_cb_unbind);
        return;
 
 err:
@@ -1071,8 +1128,10 @@ err:
 static bool
 tizen_policy_init(headless_shell_t *shell)
 {
-       shell->tizen_policy = wl_global_create(shell->display, &tizen_policy_interface, 7, shell, tizen_policy_cb_bind);
-       HEADLESS_CHECK(shell->tizen_policy, return false, "faile to create tizen_policy\n");
+       shell->tizen_policy = wl_global_create(shell->display,
+                       &tizen_policy_interface, 7, shell, tizen_policy_cb_bind);
+       HS_CHECK(shell->tizen_policy, return false,
+                       "faile to create tizen_policy\n");
 
        return true;
 }
@@ -1101,14 +1160,15 @@ headless_shell_create(struct wl_display *display)
        headless_shell_t *shell;
 
        shell = (headless_shell_t*)calloc(sizeof(headless_shell_t), 1);
-       HEADLESS_CHECK(shell, goto error, "fail to alloc for shell\n");
+       HS_CHECK(shell, goto error, "fail to alloc for shell\n");
 
        shell->display = display;
 
        wl_signal_init(&shell->events.new_surface);
 
-       HEADLESS_CHECK(zxdg_init(shell), goto error, "zxdg_init() failed\n");
-       HEADLESS_CHECK(tizen_policy_init(shell), goto error, "tizen_policy_init() failed\n");
+       HS_CHECK(zxdg_init(shell), goto error, "zxdg_init() failed\n");
+       HS_CHECK(tizen_policy_init(shell), goto error,
+                       "tizen_policy_init() failed\n");
 
        return shell;
 
@@ -1178,7 +1238,8 @@ headless_shell_send_visibility(headless_shell_surface_t *hs_surface,
                uint8_t visibility)
 {
        if (hs_surface->visibility == visibility) {
-               HEADLESS_TRACE("[SHELL] Same Visibility hs_surface:%p, visibility:%d\n", hs_surface, visibility);
+               HS_TRACE("[SHELL] Same Visibility hs_surface:%p, visibility:%d\n",
+                               hs_surface, visibility);
                return;
        }
 
@@ -1186,7 +1247,8 @@ headless_shell_send_visibility(headless_shell_surface_t *hs_surface,
                tizen_visibility_send_notify(hs_surface->tizen_visibility, visibility);
 
        hs_surface->visibility = visibility;
-       HEADLESS_TRACE("[SHELL] Set Visibility hs_surface:%p, visibility:%d\n", hs_surface, visibility);
+       HS_TRACE("[SHELL] Set Visibility hs_surface:%p, visibility:%d\n",
+                       hs_surface, visibility);
 }
 
 struct wl_resource *