Revert "e_keyrouter: process keygrab_list_set/unset in input thread"

This reverts commit 9fb93ea72e1e8a79602dfbeee59b8ff0197ea413.

Change-Id: I15dd6c6e71f49e5630136753686926e25099cf81

diff --git a/src/bin/inputmgr/e_input_thread_client_intern.h b/src/bin/inputmgr/e_input_thread_client_intern.h
index ff74b075a4f8b580eb6f9a4b6de5bfe597792aa8..e7b81632c8560126a3b568362af89f7a85defb9f 100644 (file)
--- a/src/bin/inputmgr/e_input_thread_client_intern.h
+++ b/src/bin/inputmgr/e_input_thread_client_intern.h
@@ -33,7 +33,6 @@ typedef struct
   struct wl_resource *surface;
   uint32_t key;
   uint32_t mode;
-  Eina_Bool priv_result;
 } E_Input_Thread_Request_Keygrab_Data;
 
 typedef struct

diff --git a/src/bin/inputmgr/e_keyrouter_intern.h b/src/bin/inputmgr/e_keyrouter_intern.h
index 7f284634769eba146df11285c0af7cf51c86b834..bfbb85539dc45c3bb7f1e29dce0003fcf175e1a9 100644 (file)
--- a/src/bin/inputmgr/e_keyrouter_intern.h
+++ b/src/bin/inputmgr/e_keyrouter_intern.h
@@ -174,7 +174,7 @@ EINTERN void e_keyrouter_conf_deinit(E_Keyrouter_Config_Data *kconfig);
 EINTERN int e_keyrouter_cb_picture_off(const int option, void *data);
 
 EINTERN int e_keyrouter_keygrab_set(struct wl_client *client, struct wl_resource *surface, int key, int mode);
-EINTERN int e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key, Eina_Bool privilege_result);
+EINTERN int e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key);
 
 EINTERN Eina_Bool e_keyrouter_event_process(void *event, E_Device *dev, int type);
 

diff --git a/src/bin/inputmgr/e_keyrouter_list.c b/src/bin/inputmgr/e_keyrouter_list.c
index 3044006d246dff83fb5a88c040edaba8912b1da6..699d726355dfd2681f693e331ab1cf7957995020 100644 (file)
--- a/src/bin/inputmgr/e_keyrouter_list.c
+++ b/src/bin/inputmgr/e_keyrouter_list.c
@@ -497,6 +497,14 @@ e_keyrouter_keygrab_set(struct wl_client *client, struct wl_resource *surface, i
 {
    int res=0;
 
+#ifdef HAVE_CYNARA
+   if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, mode, key))
+     {
+        KLINF("No permission for %d grab mode ! (key=%d)", mode, key);
+        return TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
+     }
+#endif
+
    if (!surface)
      {
         /* Regarding topmost mode, a client must request to grab a key with a valid surface. */
@@ -530,8 +538,9 @@ e_keyrouter_keygrab_set(struct wl_client *client, struct wl_resource *surface, i
 }
 
 int
-e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key, Eina_Bool privilege_result)
+e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key)
 {
+
    /* Check the given key range */
    if (krt->max_tizen_hwkeys < key)
      {
@@ -554,7 +563,7 @@ e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface,
      e_keyrouter_find_and_remove_client_from_list(surface, client, key, TIZEN_KEYROUTER_MODE_TOPMOST);
 
 #ifdef HAVE_CYNARA
-   if (EINA_FALSE == privilege_result)
+   if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, TIZEN_KEYROUTER_MODE_NONE, key))
      {
         goto finish;
      }

diff --git a/src/bin/server/e_keyrouter_wl.c b/src/bin/server/e_keyrouter_wl.c
index 5c3efc95f931f564e10ffe2c5cd0e2faa19d40e0..42ff97fb7469252856c9c2588a67a3af5859d4f7 100644 (file)
--- a/src/bin/server/e_keyrouter_wl.c
+++ b/src/bin/server/e_keyrouter_wl.c
@@ -264,15 +264,6 @@ _e_keyrouter_cb_keygrab_set(struct wl_client *client, struct wl_resource *resour
 {
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_set);
 
-#ifdef HAVE_CYNARA
-   if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, mode, key))
-     {
-        KLINF("No permission for %d grab mode ! (key=%d)", mode, key);
-        tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_NO_PERMISSION);
-        return;
-     }
-#endif
-
    E_Input_Thread_Request_Keygrab_Data keygrab_data;
 
    keygrab_data.resource = resource;
@@ -292,7 +283,7 @@ _e_keyrouter_input_thread_keygrab_unset(void *data)
    E_Input_Thread_Request_Keygrab_Data *keygrab_data = data;
    EINA_SAFETY_ON_NULL_RETURN(keygrab_data);
 
-   res = e_keyrouter_keygrab_unset(keygrab_data->client, keygrab_data->surface, keygrab_data->key, keygrab_data->priv_result);
+   res = e_keyrouter_keygrab_unset(keygrab_data->client, keygrab_data->surface, keygrab_data->key);
 
    TRACE_INPUT_END();
 
@@ -321,7 +312,6 @@ _e_keyrouter_cb_keygrab_unset(struct wl_client *client, struct wl_resource *reso
    keygrab_data.client = client;
    keygrab_data.key = key;
    keygrab_data.mode = TIZEN_KEYROUTER_MODE_NONE; /* UNUSED */
-   keygrab_data.priv_result = e_keyrouter_wl_util_do_privilege_check(client, TIZEN_KEYROUTER_MODE_NONE, key);
 
    INF("client: %p, surface: %p, key: %d\n", keygrab_data.client, keygrab_data.surface, keygrab_data.key);
    e_input_backend_thread_safe_call(_e_keyrouter_input_thread_keygrab_unset, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
@@ -344,71 +334,12 @@ _e_keyrouter_cb_get_keygrab_status(struct wl_client *client, struct wl_resource
    tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_NONE);
 }
 
-static void
-_e_keyrouter_input_thread_keygrab_set_list(void *data)
-{
-   unsigned int len = 0;
-   unsigned int pos = 0;
-   E_Keyrouter_Grab_Request grab_request;
-   struct wl_array grab_list;
-   int *grab_data = NULL;
-   int res;
-   E_Input_Thread_Request_Keygrab_Data keygrab_data;
-
-   memcpy(&keygrab_data, data, sizeof(E_Input_Thread_Request_Keygrab_Data));
-   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
-
-   memcpy(&len, data+pos, sizeof(unsigned int));
-   pos += sizeof(unsigned int);
-
-   INF("client(%p), resource(%p), surface(%p), len(%d)", keygrab_data.client, keygrab_data.resource, keygrab_data.surface, len);
-
-   wl_array_init(&grab_list);
-
-   for (unsigned int i = 0; i < len; i++)
-     {
-        memcpy(&grab_request, data+pos, sizeof(E_Keyrouter_Grab_Request));
-        pos += sizeof(E_Keyrouter_Grab_Request);
-
-        INF("[%s] mode: %d, key : %d, err: %d", __func__, grab_request.mode, grab_request.key, grab_request.err);
-
-        if (grab_request.err == TIZEN_KEYROUTER_ERROR_NONE)
-          {
-             res = e_keyrouter_keygrab_set(keygrab_data.client, keygrab_data.surface, grab_request.key, grab_request.mode);
-             grab_request.err = res;
-
-             if (res == TIZEN_KEYROUTER_ERROR_NONE)
-               KLDBG("Success to %d key %s grab using list(wl_client: %p, wl_surface: %p, pid: %d)",
-                     grab_request.key, e_keyrouter_mode_to_string(grab_request.mode),
-                     keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface));
-             else
-               KLINF("Failed to %d key %s grab using list(wl_client: %p, wl_surface: %p, pid: %d): res: %d",
-                     grab_request.key, e_keyrouter_mode_to_string(grab_request.mode),
-                     keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface), grab_request.err);
-          }
-
-        grab_data = wl_array_add(&grab_list, sizeof(int));
-        *grab_data = grab_request.key;
-        grab_data = wl_array_add(&grab_list, sizeof(int));
-        *grab_data = grab_request.mode;
-        grab_data = wl_array_add(&grab_list, sizeof(int));
-        *grab_data = grab_request.err;
-     }
-
-   tizen_keyrouter_send_keygrab_notify_list(keygrab_data.resource, keygrab_data.surface, &grab_list);
-
-   e_input_wl_events_flush();
-
-   wl_array_release(&grab_list);
-}
-
 static void
 _e_keyrouter_cb_keygrab_set_list(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, struct wl_array *grab_list)
 {
    E_Keyrouter_Grab_Request *grab_request = NULL;
-   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+   int res = TIZEN_KEYROUTER_ERROR_NONE;
    int array_len = 0;
-   unsigned pos = 0;
 
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_set_list);
 
@@ -423,109 +354,30 @@ _e_keyrouter_cb_keygrab_set_list(struct wl_client *client, struct wl_resource *r
         return;
      }
 
-   unsigned int list_count = array_len / 3;
-   unsigned int data_size = sizeof(E_Input_Thread_Request_Keygrab_Data)+sizeof(unsigned int)+sizeof(E_Keyrouter_Grab_Request)*list_count;
-   void *data = calloc(1, data_size);
-   if (!data)
-     {
-        KLWRN("Failed to allocate memory");
-        TRACE_INPUT_END();
-        return;
-     }
-
-   memset(&keygrab_data, 0, sizeof(E_Input_Thread_Request_Keygrab_Data));
-   keygrab_data.client = client;
-   keygrab_data.resource = resource;
-   keygrab_data.surface = surface;
-
-   memcpy(data, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
-   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
-
-   memcpy(data+pos, &list_count, sizeof(unsigned int));
-   pos += sizeof(unsigned int);
-
-   INF("[%s] client(%p), resource(%p), surface(%p), len(%u), data_size(%u)", __func__, client, resource, surface, list_count, data_size);
-
    wl_array_for_each(grab_request, grab_list)
      {
-#ifdef HAVE_CYNARA
-        if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, grab_request->mode, grab_request->key))
-          {
-             KLINF("No permission for %d grab mode ! (key=%d)", grab_request->mode, grab_request->key);
-             grab_request->err = TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
-          }
-#endif
-        INF("[%s] mode: %d, key : %d, err: %d", __func__, grab_request->mode, grab_request->key, grab_request->err);
-        memcpy(data+pos, grab_request, sizeof(E_Keyrouter_Grab_Request));
-        pos += sizeof(E_Keyrouter_Grab_Request);
-     }
-
-   e_input_backend_thread_safe_call(_e_keyrouter_input_thread_keygrab_set_list, data, data_size);
-
-   free(data);
-
-   TRACE_INPUT_END();
-}
-
-static void
-_e_keyrouter_input_thread_keygrab_unset_list(void *data)
-{
-   unsigned int len = 0;
-   unsigned int pos = 0;
-   struct wl_array ungrab_list;
-   int *ungrab_data = NULL;
-   int res = TIZEN_KEYROUTER_ERROR_NONE;
-
-   E_Input_Thread_Request_Keygrab_Data keygrab_data;
-   E_Keyrouter_Ungrab_Request ungrab_request;
-
-   memcpy(&keygrab_data, data, sizeof(E_Input_Thread_Request_Keygrab_Data));
-   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
-
-   memcpy(&len, data+pos, sizeof(unsigned int));
-   pos += sizeof(unsigned int);
-
-   INF("client(%p), resource(%p), surface(%p), len(%d)", keygrab_data.client, keygrab_data.resource, keygrab_data.surface, len);
-
-   wl_array_init(&ungrab_list);
-
-   for (unsigned int i = 0; i < len; i++)
-     {
-        memcpy(&ungrab_request, data+pos, sizeof(E_Keyrouter_Ungrab_Request));
-        pos += sizeof(E_Keyrouter_Ungrab_Request);
-
-        INF("key : %d, err: %d", ungrab_request.key, ungrab_request.err);
-
-        res = e_keyrouter_keygrab_unset(keygrab_data.client, keygrab_data.surface, ungrab_request.key, ungrab_request.err == TIZEN_KEYROUTER_ERROR_NO_PERMISSION ? EINA_FALSE : EINA_TRUE);
-        ungrab_request.err = res;
+        res = e_keyrouter_keygrab_set(client, surface, grab_request->key, grab_request->mode);
+        grab_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, keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface));
+          KLDBG("Success to %d key %s grab using list(wl_client: %p, wl_surface: %p, pid: %d)",
+                grab_request->key, e_keyrouter_mode_to_string(grab_request->mode),
+                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, keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface), ungrab_request.err);
-
-        ungrab_data = wl_array_add(&ungrab_list, sizeof(int));
-        *ungrab_data = ungrab_request.key;
-        ungrab_data = wl_array_add(&ungrab_list, sizeof(int));
-        *ungrab_data = ungrab_request.err;
+          KLINF("Failed to %d key %s grab using list(wl_client: %p, wl_surface: %p, pid: %d): res: %d",
+                grab_request->key, e_keyrouter_mode_to_string(grab_request->mode),
+                client, surface, e_keyrouter_util_get_pid(client, surface), grab_request->err);
      }
 
-   tizen_keyrouter_send_keygrab_notify_list(keygrab_data.resource, keygrab_data.surface, &ungrab_list);
-
-   e_input_wl_events_flush();
-
-   wl_array_release(&ungrab_list);
+   TRACE_INPUT_END();
+   tizen_keyrouter_send_keygrab_notify_list(resource, surface, grab_list);
 }
 
 static void
 _e_keyrouter_cb_keygrab_unset_list(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, struct wl_array *ungrab_list)
 {
    E_Keyrouter_Ungrab_Request *ungrab_request = NULL;
-   E_Input_Thread_Request_Keygrab_Data keygrab_data;
-
+   int res = TIZEN_KEYROUTER_ERROR_NONE;
    int array_len = 0;
-   unsigned int pos = 0;
 
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_unset_list);
 
@@ -540,49 +392,20 @@ _e_keyrouter_cb_keygrab_unset_list(struct wl_client *client, struct wl_resource
         return;
      }
 
-   unsigned int list_count = array_len / 2;
-   unsigned int data_size = sizeof(E_Input_Thread_Request_Keygrab_Data)+sizeof(unsigned int)+sizeof(E_Keyrouter_Ungrab_Request)*list_count;
-   void *data = calloc(1, data_size);
-   if (!data)
-     {
-        KLWRN("Failed to allocate memory");
-        TRACE_INPUT_END();
-        return;
-     }
-
-   memset(&keygrab_data, 0, sizeof(E_Input_Thread_Request_Keygrab_Data));
-   keygrab_data.client = client;
-   keygrab_data.resource = resource;
-   keygrab_data.surface = surface;
-
-   memcpy(data, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
-   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
-
-   memcpy(data+pos, &list_count, sizeof(unsigned int));
-   pos += sizeof(unsigned int);
-
-   INF("[%s] client(%p), resource(%p), surface(%p), len(%u), data_size(%u)", __func__, client, resource, surface, list_count, data_size);
-
    wl_array_for_each(ungrab_request, ungrab_list)
      {
-#ifdef HAVE_CYNARA
-       if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, TIZEN_KEYROUTER_MODE_NONE, ungrab_request->key))
-          {
-             KLINF("No permission for %d grab mode ! (key=%d)", TIZEN_KEYROUTER_MODE_NONE, ungrab_request->key);
-             ungrab_request->err = TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
-          }
-#endif
-
-        INF("key : %d, err: %d", ungrab_request->key, ungrab_request->err);
-        memcpy(data+pos, ungrab_request, sizeof(E_Keyrouter_Ungrab_Request));
-        pos += sizeof(E_Keyrouter_Ungrab_Request);
+        res = e_keyrouter_keygrab_unset(client, surface, ungrab_request->key);
+        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));
+        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);
      }
 
-   e_input_backend_thread_safe_call(_e_keyrouter_input_thread_keygrab_unset_list, data, data_size);
-
-   free(data);
-
    TRACE_INPUT_END();
+   tizen_keyrouter_send_keygrab_notify_list(resource, surface, ungrab_list);
 }
 
 static void