e_keyrouter_wl: remove the unused function

[platform/upstream/enlightenment.git] / src / bin / server / e_keyrouter_wl.c

diff --git a/src/bin/server/e_keyrouter_wl.c b/src/bin/server/e_keyrouter_wl.c
index edcf594..1949c42 100644 (file)
--- a/src/bin/server/e_keyrouter_wl.c
+++ b/src/bin/server/e_keyrouter_wl.c
@@ -177,45 +177,61 @@ e_keyrouter_wl_key_send(Ecore_Event_Key *ev, E_Device *dev, Eina_Bool pressed, s
 }
 
 EINTERN void
-e_keyrouter_keycancel_send(struct wl_client *client, struct wl_resource *surface, unsigned int key)
+e_keyrouter_surface_keycancel_send(struct wl_resource *surface, unsigned int key)
 {
    Eina_List *l;
-   struct wl_resource *resource = NULL;
-   struct wl_client *wc = NULL;
+   Eina_List *press_ptr_list;
    E_Keyrouter_Key_List_NodePtr data;
-   Eina_List *press_ptr_list = NULL;
+   struct wl_resource *resource;
+   struct wl_client *client;
 
-   if (surface) wc = wl_resource_get_client(surface);
-   else wc = client;
+   EINA_SAFETY_ON_NULL_RETURN(surface);
 
-   EINA_SAFETY_ON_NULL_RETURN(wc);
+   client = wl_resource_get_client(surface);
 
    g_rec_mutex_lock(&krt->grab_key_mutex);
+
    press_ptr_list = krt->HardKeys[key].press_ptr;
    EINA_LIST_FOREACH(press_ptr_list, l, data)
      {
-        if (surface)
+        if (surface != data->surface) continue;
+
+        EINA_LIST_FOREACH(g_tizen_keyrouter->resources, l, resource)
           {
-             if (surface == data->surface)
-               {
-                  EINA_LIST_FOREACH(g_tizen_keyrouter->resources, l, resource)
-                    {
-                       if (wl_resource_get_client(resource) != wc) continue;
+             if (wl_resource_get_client(resource) != client) continue;
 
-                       tizen_keyrouter_send_key_cancel(resource, key-8);
-                    }
-               }
+             tizen_keyrouter_send_key_cancel(resource, key-8);
           }
-        else if (client == data->wc)
+     }
+
+   g_rec_mutex_unlock(&krt->grab_key_mutex);
+}
+
+EINTERN void
+e_keyrouter_client_keycancel_send(struct wl_client *client, unsigned int key)
+{
+   Eina_List *l;
+   E_Keyrouter_Key_List_NodePtr data;
+   Eina_List *press_ptr_list;
+   struct wl_resource *resource;
+
+   EINA_SAFETY_ON_NULL_RETURN(client);
+
+   g_rec_mutex_lock(&krt->grab_key_mutex);
+
+   press_ptr_list = krt->HardKeys[key].press_ptr;
+   EINA_LIST_FOREACH(press_ptr_list, l, data)
+     {
+        if (client != data->wc) continue;
+
+        EINA_LIST_FOREACH(g_tizen_keyrouter->resources, l, resource)
           {
-             EINA_LIST_FOREACH(g_tizen_keyrouter->resources, l, resource)
-               {
-                  if (wl_resource_get_client(resource) != wc) continue;
+             if (wl_resource_get_client(resource) != client) continue;
 
-                  tizen_keyrouter_send_key_cancel(resource, key-8);
-               }
+             tizen_keyrouter_send_key_cancel(resource, key-8);
           }
      }
+
    g_rec_mutex_unlock(&krt->grab_key_mutex);
 }
 
@@ -242,6 +258,19 @@ _e_keyrouter_keygrab_set_available_check(struct wl_client *client, struct wl_res
          (mode == TIZEN_KEYROUTER_MODE_SHARED)))
      return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
 
+   /* Regarding topmost mode, a client must request to grab a key with a valid surface. */
+   if (!surface && mode == TIZEN_KEYROUTER_MODE_TOPMOST)
+     {
+        KLWRN("Invalid surface for %d grab mode ! (key=%d)", mode, key);
+        return TIZEN_KEYROUTER_ERROR_INVALID_SURFACE;
+     }
+
+   return TIZEN_KEYROUTER_ERROR_NONE;
+}
+
+static int
+_e_keyrouter_keygrab_privilege_available_check(struct wl_client *client, int key, int mode)
+{
 #ifdef HAVE_CYNARA
    if (!e_keyrouter_wl_util_do_privilege_check(client, mode, key))
      {
@@ -250,13 +279,6 @@ _e_keyrouter_keygrab_set_available_check(struct wl_client *client, struct wl_res
      }
 #endif
 
-   /* Regarding topmost mode, a client must request to grab a key with a valid surface. */
-   if (!surface && mode == TIZEN_KEYROUTER_MODE_TOPMOST)
-     {
-        KLWRN("Invalid surface for %d grab mode ! (key=%d)", mode, key);
-        return TIZEN_KEYROUTER_ERROR_INVALID_SURFACE;
-     }
-
    return TIZEN_KEYROUTER_ERROR_NONE;
 }
 
@@ -285,13 +307,18 @@ static void
 _e_keyrouter_input_thread_keygrab_set(void *data)
 {
    E_Input_Thread_Request_Keygrab_Data *keygrab_data = data;
-   int res = 0;
+   int res = TIZEN_KEYROUTER_ERROR_NONE;
 
    res = _e_keyrouter_keygrab_set_available_check(keygrab_data->client,
             keygrab_data->surface, keygrab_data->key, keygrab_data->mode);
    if (res != TIZEN_KEYROUTER_ERROR_NONE)
       goto failed;
 
+   res = _e_keyrouter_keygrab_privilege_available_check(keygrab_data->client,
+            keygrab_data->key, keygrab_data->mode);
+   if (res != TIZEN_KEYROUTER_ERROR_NONE)
+      goto failed;
+
    res = _e_keyrouter_keygrab_key_available_check(keygrab_data->key);
    if (res != TIZEN_KEYROUTER_ERROR_NONE)
       goto failed;
@@ -345,22 +372,46 @@ _e_keyrouter_cb_keygrab_set(struct wl_client *client, struct wl_resource *resour
 static void
 _e_keyrouter_input_thread_keygrab_unset(void *data)
 {
-   int res = 0;
    E_Input_Thread_Request_Keygrab_Data *keygrab_data = data;
-   EINA_SAFETY_ON_NULL_RETURN(keygrab_data);
+   int res = TIZEN_KEYROUTER_ERROR_NONE;
 
-   res = e_keyrouter_keygrab_unset(keygrab_data->client, keygrab_data->surface, keygrab_data->key);
+   res = _e_keyrouter_keygrab_key_available_check(keygrab_data->key);
+   if (res != TIZEN_KEYROUTER_ERROR_NONE)
+      goto failed;
 
-   TRACE_INPUT_END();
+   res = _e_keyrouter_keygrab_privilege_available_check(keygrab_data->client,
+         keygrab_data->key, TIZEN_KEYROUTER_MODE_NONE);
+   if (res != TIZEN_KEYROUTER_ERROR_NONE)
+      goto cancel;
 
-   if (res == TIZEN_KEYROUTER_ERROR_NONE)
-     KLDBG("Success to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d)", keygrab_data->key, keygrab_data->client, keygrab_data->surface,
-           e_keyrouter_util_get_pid(keygrab_data->client, keygrab_data->surface));
+   if (keygrab_data->surface)
+     e_keyrouter_surface_keygrab_unset(keygrab_data->surface, keygrab_data->key);
    else
-     KLINF("Failed to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d): res: %d", keygrab_data->key, keygrab_data->client, keygrab_data->surface,
-           e_keyrouter_util_get_pid(keygrab_data->client, keygrab_data->surface), res);
+     e_keyrouter_client_keygrab_unset(keygrab_data->client, keygrab_data->key);
+
+   KLDBG("Success to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d)",
+         keygrab_data->key, keygrab_data->client, keygrab_data->surface,
+         e_keyrouter_util_get_pid(keygrab_data->client, keygrab_data->surface));
+
+   tizen_keyrouter_send_keygrab_notify(keygrab_data->resource,
+      keygrab_data->surface, keygrab_data->key, TIZEN_KEYROUTER_MODE_NONE, res);
+
+   return;
 
-   tizen_keyrouter_send_keygrab_notify(keygrab_data->resource, keygrab_data->surface, keygrab_data->key, TIZEN_KEYROUTER_MODE_NONE, res);
+cancel:
+   if (keygrab_data->surface)
+     e_keyrouter_surface_keycancel_send(keygrab_data->surface, keygrab_data->key);
+   else
+     e_keyrouter_client_keycancel_send(keygrab_data->client, keygrab_data->key);
+
+failed:
+   KLINF("Failed to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d): res: %d",
+         keygrab_data->key, keygrab_data->client, keygrab_data->surface,
+         e_keyrouter_util_get_pid(keygrab_data->client, keygrab_data->surface),
+         res);
+
+   tizen_keyrouter_send_keygrab_notify(keygrab_data->resource,
+      keygrab_data->surface, keygrab_data->key, TIZEN_KEYROUTER_MODE_NONE, res);
 }
 
 /* tizen_keyrouter unset_keygrab request handler */
@@ -377,8 +428,12 @@ _e_keyrouter_cb_keygrab_unset(struct wl_client *client, struct wl_resource *reso
    keygrab_data.key = key;
    keygrab_data.mode = TIZEN_KEYROUTER_MODE_NONE; /* UNUSED */
 
-   INF("client: %p, surface: %p, key: %d\n", keygrab_data.client, keygrab_data.surface, keygrab_data.key);
+   INF("client: %p, surface: %p, key: %d\n", keygrab_data.client,
+       keygrab_data.surface, keygrab_data.key);
+
    _e_keyrouter_input_thread_keygrab_unset(&keygrab_data);
+
+   TRACE_INPUT_END();
 }
 
 /* tizen_keyrouter get_keygrab_status request handler */
@@ -425,6 +480,11 @@ _e_keyrouter_cb_keygrab_set_list(struct wl_client *client, struct wl_resource *r
         if (res != TIZEN_KEYROUTER_ERROR_NONE)
           goto done;
 
+        res = _e_keyrouter_keygrab_privilege_available_check(client,
+                  grab_request->key, grab_request->mode);
+        if (res != TIZEN_KEYROUTER_ERROR_NONE)
+          goto done;
+
         res = _e_keyrouter_keygrab_key_available_check(grab_request->key);
         if (res != TIZEN_KEYROUTER_ERROR_NONE)
           goto done;
@@ -477,20 +537,37 @@ _e_keyrouter_cb_keygrab_unset_list(struct wl_client *client, struct wl_resource
         if (res != TIZEN_KEYROUTER_ERROR_NONE)
           goto done;
 
-        res = e_keyrouter_keygrab_unset(client, surface, ungrab_request->key);
+        res = _e_keyrouter_keygrab_privilege_available_check(client,
+                  ungrab_request->key, TIZEN_KEYROUTER_MODE_NONE);
+        if (res != TIZEN_KEYROUTER_ERROR_NONE)
+          goto cancel;
+
+        if (surface)
+          e_keyrouter_client_keygrab_unset(client, ungrab_request->key);
+        else
+          e_keyrouter_surface_keygrab_unset(surface, ungrab_request->key);
+
+cancel:
+        if (surface)
+          e_keyrouter_surface_keycancel_send(surface, ungrab_request->key);
+        else
+          e_keyrouter_client_keycancel_send(client, ungrab_request->key);
 
 done:
         ungrab_request->err = res;
 
         if (res == TIZEN_KEYROUTER_ERROR_NONE)
           KLDBG("Success to ungrab using list: %d key (wl_client: %p, wl_surface: %p, pid: %d)",
-                ungrab_request->key, client, surface, e_keyrouter_util_get_pid(client, surface));
+                ungrab_request->key, client, surface,
+                e_keyrouter_util_get_pid(client, surface));
         else
           KLINF("Failed to ungrab using list: %d key (wl_client: %p, wl_surface: %p, pid: %d): res: %d",
-                ungrab_request->key, client, surface, e_keyrouter_util_get_pid(client, surface), ungrab_request->err);
+                ungrab_request->key, client, surface,
+                e_keyrouter_util_get_pid(client, surface), ungrab_request->err);
      }
 
    TRACE_INPUT_END();
+
    tizen_keyrouter_send_keygrab_notify_list(resource, surface, ungrab_list);
 }
 
@@ -673,7 +750,7 @@ e_keyrouter_wl_add_surface_destroy_listener(struct wl_resource *surface)
 }
 
 #ifdef HAVE_CYNARA
-EINTERN EINTERN Eina_Bool
+EINTERN Eina_Bool
 e_keyrouter_wl_util_do_privilege_check(struct wl_client *client, uint32_t mode, uint32_t keycode)
 {
    Eina_Bool res = EINA_FALSE;