keyrouter: Rename keyrouter_client to client for shorter name

Change-Id: Ic4e1397f3fee212d4dff9e3d433384b964e0a47a

diff --git a/src/keyrouter/keyrouter.c b/src/keyrouter/keyrouter.c
index 4ab3734..199af6b 100644 (file)
--- a/src/keyrouter/keyrouter.c
+++ b/src/keyrouter/keyrouter.c
@@ -14,11 +14,11 @@
 #define TIZEN_KEYROUTER_PRIVILEGE "http://tizen.org/privilege/keygrab"
 
 static void
-keyrouter_bind(struct wl_client *client, void *data, uint32_t version,
+keyrouter_bind(struct wl_client *wl_client, void *data, uint32_t version,
         uint32_t id);
 static bool
-keyrouter_check_privilege(struct ds_tizen_keyrouter_client *keyrouter_client,
-        struct wl_client *client, uint32_t mode, uint32_t keycode);
+keyrouter_check_privilege(struct ds_tizen_keyrouter_client *client,
+        struct wl_client *wl_client, uint32_t mode, uint32_t keycode);
 static void
 keyrouter_options_set(struct ds_tizen_keyrouter *keyrouter);
 
@@ -100,19 +100,19 @@ ds_tizen_keyrouter_add_destroy_listener(struct ds_tizen_keyrouter *keyrouter,
 }
 
 static void
-keyrouter_handle_keygrab_set(struct wl_client *client,
+keyrouter_handle_keygrab_set(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface,
         uint32_t key, uint32_t mode)
 {
-    struct ds_tizen_keyrouter_client *keyrouter_client;
+    struct ds_tizen_keyrouter_client *client;
     struct ds_tizen_keyrouter *keyrouter;
     int res = TIZEN_KEYROUTER_ERROR_NONE;
     bool ret;
 
-    keyrouter_client = wl_resource_get_user_data(resource);
-    keyrouter = keyrouter_client->keyrouter;
+    client = wl_resource_get_user_data(resource);
+    keyrouter = client->keyrouter;
 
-    ret = keyrouter_check_privilege(keyrouter_client, client, mode, key);
+    ret = keyrouter_check_privilege(client, wl_client, mode, key);
     if (ret == false) {
         tizen_keyrouter_send_keygrab_notify(resource, surface,
             key, mode, TIZEN_KEYROUTER_ERROR_NO_PERMISSION);
@@ -120,29 +120,29 @@ keyrouter_handle_keygrab_set(struct wl_client *client,
     }
 
     res = keyrouter_grab_grab_key(keyrouter->keyrouter_grab,
-        mode, key, (void *)client);
+        mode, key, (void *)wl_client);
 
     tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, res);
 }
 
 static void
-keyrouter_handle_keygrab_unset(struct wl_client *client,
+keyrouter_handle_keygrab_unset(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface,  uint32_t key)
 {
-    struct ds_tizen_keyrouter_client *keyrouter_client;
+    struct ds_tizen_keyrouter_client *client;
     struct ds_tizen_keyrouter *keyrouter;
     int res = TIZEN_KEYROUTER_ERROR_NONE;
     bool ret;
 
-    keyrouter_client = wl_resource_get_user_data(resource);
-    keyrouter = keyrouter_client->keyrouter;
+    client = wl_resource_get_user_data(resource);
+    keyrouter = client->keyrouter;
 
     /* ungrab TOP POSITION grab first, this grab mode is not check privilege */
     keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-        TIZEN_KEYROUTER_MODE_TOPMOST, key, (void *)client);
+        TIZEN_KEYROUTER_MODE_TOPMOST, key, (void *)wl_client);
 
-    ret = keyrouter_check_privilege(keyrouter_client,
-        client, TIZEN_KEYROUTER_MODE_NONE, key);
+    ret = keyrouter_check_privilege(client,
+        wl_client, TIZEN_KEYROUTER_MODE_NONE, key);
     if (ret == false) {
         tizen_keyrouter_send_keygrab_notify(resource, surface, key,
             TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_NO_PERMISSION);
@@ -150,19 +150,19 @@ keyrouter_handle_keygrab_unset(struct wl_client *client,
     }
 
     keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-        TIZEN_KEYROUTER_MODE_EXCLUSIVE, key, (void *)client);
+        TIZEN_KEYROUTER_MODE_EXCLUSIVE, key, (void *)wl_client);
     keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-        TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, key, (void *)client);
+        TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, key, (void *)wl_client);
     keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-        TIZEN_KEYROUTER_MODE_TOPMOST, key, (void *)client);
+        TIZEN_KEYROUTER_MODE_TOPMOST, key, (void *)wl_client);
     keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-        TIZEN_KEYROUTER_MODE_SHARED, key, (void *)client);
+        TIZEN_KEYROUTER_MODE_SHARED, key, (void *)wl_client);
 
     tizen_keyrouter_send_keygrab_notify(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, res);
 }
 
 static void
-keyrouter_handle_get_keygrab_status(struct wl_client *client,
+keyrouter_handle_get_keygrab_status(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface, uint32_t key)
 {
     tizen_keyrouter_send_keygrab_notify(resource, surface, key,
@@ -183,18 +183,18 @@ keyrouter_get_array_length(const struct wl_array *array)
 }
 
 static void
-keyrouter_handle_keygrab_set_list(struct wl_client *client,
+keyrouter_handle_keygrab_set_list(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface, struct wl_array *grab_list)
 {
-    struct ds_tizen_keyrouter_client *keyrouter_client;
+    struct ds_tizen_keyrouter_client *client;
     struct ds_tizen_keyrouter *keyrouter;
     struct wl_array *return_list;
     struct ds_tizen_grab_data *grab_data = NULL;
     int res = TIZEN_KEYROUTER_ERROR_NONE;
     bool ret;
 
-    keyrouter_client = wl_resource_get_user_data(resource);
-    keyrouter = keyrouter_client->keyrouter;
+    client = wl_resource_get_user_data(resource);
+    keyrouter = client->keyrouter;
 
     if ((keyrouter_get_array_length(grab_list) % 3) != 0) {
         ds_err("Invalid keycode and grab mode pair. Check arguments in a list.");
@@ -203,12 +203,12 @@ keyrouter_handle_keygrab_set_list(struct wl_client *client,
     }
 
     wl_array_for_each(grab_data, grab_list) {
-        ret = keyrouter_check_privilege(keyrouter_client, client, grab_data->mode, grab_data->key);
+        ret = keyrouter_check_privilege(client, wl_client, grab_data->mode, grab_data->key);
         if (ret == false) {
             grab_data->err = TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
         } else {
             res = keyrouter_grab_grab_key(keyrouter->keyrouter_grab,
-                grab_data->mode, grab_data->key, (void *)client);
+                grab_data->mode, grab_data->key, (void *)wl_client);
 
             grab_data->err = res;
         }
@@ -220,18 +220,18 @@ keyrouter_handle_keygrab_set_list(struct wl_client *client,
 }
 
 static void
-keyrouter_handle_keygrab_unset_list(struct wl_client *client,
+keyrouter_handle_keygrab_unset_list(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface,
         struct wl_array *ungrab_list)
 {
-    struct ds_tizen_keyrouter_client *keyrouter_client;
+    struct ds_tizen_keyrouter_client *client;
     struct ds_tizen_keyrouter *keyrouter;
     struct wl_array *return_list = NULL;
     struct ds_tizen_ungrab_data *ungrab_data = NULL;
     bool ret;
 
-    keyrouter_client = wl_resource_get_user_data(resource);
-    keyrouter = keyrouter_client->keyrouter;
+    client = wl_resource_get_user_data(resource);
+    keyrouter = client->keyrouter;
 
     if ((keyrouter_get_array_length(ungrab_list) % 3) != 0) {
         ds_err("Invalid keycode and grab mode pair. Check arguments in a list.");
@@ -241,24 +241,24 @@ keyrouter_handle_keygrab_unset_list(struct wl_client *client,
 
     wl_array_for_each(ungrab_data, ungrab_list) {
         keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-            TIZEN_KEYROUTER_MODE_TOPMOST, ungrab_data->key, (void *)client);
+            TIZEN_KEYROUTER_MODE_TOPMOST, ungrab_data->key, (void *)wl_client);
 
-        ret = keyrouter_check_privilege(keyrouter_client, client,
+        ret = keyrouter_check_privilege(client, wl_client,
             TIZEN_KEYROUTER_MODE_TOPMOST, ungrab_data->key);
         if (!ret) {
             ungrab_data->err = TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
         } else {
             keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-                TIZEN_KEYROUTER_MODE_EXCLUSIVE, ungrab_data->key, (void *)client);
+                TIZEN_KEYROUTER_MODE_EXCLUSIVE, ungrab_data->key, (void *)wl_client);
 
             keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-                TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, ungrab_data->key, (void *)client);
+                TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, ungrab_data->key, (void *)wl_client);
 
             keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-                TIZEN_KEYROUTER_MODE_TOPMOST, ungrab_data->key, (void *)client);
+                TIZEN_KEYROUTER_MODE_TOPMOST, ungrab_data->key, (void *)wl_client);
 
             keyrouter_grab_ungrab_key(keyrouter->keyrouter_grab,
-                TIZEN_KEYROUTER_MODE_SHARED, ungrab_data->key, (void *)client);
+                TIZEN_KEYROUTER_MODE_SHARED, ungrab_data->key, (void *)wl_client);
 
             ungrab_data->err = TIZEN_KEYROUTER_ERROR_NONE;
         }
@@ -270,14 +270,14 @@ keyrouter_handle_keygrab_unset_list(struct wl_client *client,
 }
 
 static void
-keyrouter_handle_get_keygrab_list(struct wl_client *client,
+keyrouter_handle_get_keygrab_list(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface)
 {
     tizen_keyrouter_send_getgrab_notify_list(resource, surface, NULL);
 }
 
 static void
-keyrouter_handle_set_register_none_key(struct wl_client *client,
+keyrouter_handle_set_register_none_key(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface,
         uint32_t data)
 {
@@ -285,14 +285,14 @@ keyrouter_handle_set_register_none_key(struct wl_client *client,
 }
 
 static void
-keyrouter_handle_get_keyregister_status(struct wl_client *client,
+keyrouter_handle_get_keyregister_status(struct wl_client *wl_client,
         struct wl_resource *resource, uint32_t key)
 {
     tizen_keyrouter_send_keyregister_notify(resource, (int)false);
 }
 
 static void
-keyrouter_handle_set_input_config(struct wl_client *client,
+keyrouter_handle_set_input_config(struct wl_client *wl_client,
         struct wl_resource *resource, struct wl_resource *surface,
         uint32_t config_mode, uint32_t value)
 {
@@ -300,7 +300,7 @@ keyrouter_handle_set_input_config(struct wl_client *client,
 }
 
 static void
-keyrouter_handle_destory(struct wl_client *client,
+keyrouter_handle_destory(struct wl_client *wl_client,
         struct wl_resource *resource)
 {
     wl_resource_destroy(resource);
@@ -322,47 +322,47 @@ static const struct tizen_keyrouter_interface tizen_keyrouter_impl = {
 static void
 keyrouter_handle_resource_destory(struct wl_resource *resource)
 {
-    struct ds_tizen_keyrouter_client *keyrouter_client = wl_resource_get_user_data(resource);
+    struct ds_tizen_keyrouter_client *client = wl_resource_get_user_data(resource);
 
-    wl_list_remove(&keyrouter_client->link);
-    free(keyrouter_client);
+    wl_list_remove(&client->link);
+    free(client);
 }
 
 static void
-keyrouter_bind(struct wl_client *client, void *data, uint32_t version,
+keyrouter_bind(struct wl_client *wl_client, void *data, uint32_t version,
         uint32_t id)
 {
     struct ds_tizen_keyrouter *keyrouter = data;
-    struct ds_tizen_keyrouter_client *keyrouter_client;
+    struct ds_tizen_keyrouter_client *client;
 
-    keyrouter_client = calloc(1, sizeof *keyrouter_client);
-    if (keyrouter_client == NULL) {
-        wl_client_post_no_memory(client);
+    client = calloc(1, sizeof *client);
+    if (client == NULL) {
+        wl_client_post_no_memory(wl_client);
         return;
     }
 
-    keyrouter_client->keyrouter = keyrouter;
-    keyrouter_client->resource =
-        wl_resource_create(client, &tizen_keyrouter_interface,
+    client->keyrouter = keyrouter;
+    client->resource =
+        wl_resource_create(wl_client, &tizen_keyrouter_interface,
                 MIN(version, TIZEN_KEYROUTER_VERSION), id);
-    if (keyrouter_client->resource == NULL) {
+    if (client->resource == NULL) {
         ds_err("wl_resource_create() failed.(version :%d, id:%d)", version, id);
-        free(keyrouter_client);
-        wl_client_post_no_memory(client);
+        free(client);
+        wl_client_post_no_memory(wl_client);
         return;
     }
 
-    wl_resource_set_implementation(keyrouter_client->resource, &tizen_keyrouter_impl,
-        keyrouter_client, keyrouter_handle_resource_destory);
+    wl_resource_set_implementation(client->resource, &tizen_keyrouter_impl,
+        client, keyrouter_handle_resource_destory);
 
-    wl_list_insert(&keyrouter->clients, &keyrouter_client->link);
+    wl_list_insert(&keyrouter->clients, &client->link);
 }
 
 static bool
-keyrouter_check_privilege(struct ds_tizen_keyrouter_client *keyrouter_client,
-        struct wl_client *client, uint32_t mode, uint32_t keycode)
+keyrouter_check_privilege(struct ds_tizen_keyrouter_client *client,
+        struct wl_client *wl_client, uint32_t mode, uint32_t keycode)
 {
-    struct ds_tizen_keyrouter *keyrouter = keyrouter_client->keyrouter;
+    struct ds_tizen_keyrouter *keyrouter = client->keyrouter;
 
     pid_t pid = 0;
     uid_t uid = 0;
@@ -379,15 +379,15 @@ keyrouter_check_privilege(struct ds_tizen_keyrouter_client *keyrouter_client,
     }
 
     // already checked the privilege before.
-    if (keyrouter_client->privileged)
+    if (client->privileged)
         return true;
 
-    wl_client_get_credentials(client, &pid, &uid, &gid);
+    wl_client_get_credentials(wl_client, &pid, &uid, &gid);
 
-    keyrouter_client->privileged = tizen_security_check_privilege(pid, uid,
+    client->privileged = tizen_security_check_privilege(pid, uid,
             TIZEN_KEYROUTER_PRIVILEGE);
 
-    return keyrouter_client->privileged;
+    return client->privileged;
 }
 
 static void