e_input: remove kbd.focused, resources, and keys mutex

Change-Id: I4f50f18c94cda6e813c534e542689028d6f1c0d1
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

diff --git a/src/bin/e_comp_wl.c b/src/bin/e_comp_wl.c
index dfea164..71f354e 100644 (file)
--- a/src/bin/e_comp_wl.c
+++ b/src/bin/e_comp_wl.c
@@ -2003,33 +2003,23 @@ _e_comp_wl_client_priority_normal(E_Client *ec)
                                      EINA_FALSE, EINA_TRUE, EINA_FALSE);
 }
 
-static Eina_Bool
-_e_comp_wl_evas_cb_focus_in_timer(E_Client *ec)
+static void
+_e_comp_wl_input_thread_send_keys()
 {
    uint32_t serial;
-   E_Comp_Wl_Key_Data *k;
-   struct wl_resource *res;
-   Eina_List *l;
    double t;
+   Eina_List *l;
+   struct wl_resource *res;
+   E_Comp_Wl_Key_Data *k;
 
-   if (!ec) return EINA_FALSE;
-   if (e_object_is_del(E_OBJECT(ec))) return EINA_FALSE;
-   if (!ec->comp_data) return EINA_FALSE;
-
-   ec->comp_data->on_focus_timer = NULL;
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
    if (!e_comp_wl->kbd.focused)
      {
-        g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
-        return EINA_FALSE;
+        return;
      }
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
 
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
    t = ecore_time_unix_get();
 
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
      {
         wl_array_for_each(k, &e_comp_wl->kbd.keys)
@@ -2039,62 +2029,78 @@ _e_comp_wl_evas_cb_focus_in_timer(E_Client *ec)
                                   k->key, WL_KEYBOARD_KEY_STATE_PRESSED);
           }
      }
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
+}
+
+static Eina_Bool
+_e_comp_wl_evas_cb_focus_in_timer(E_Client *ec)
+{
+   if (!ec) return EINA_FALSE;
+   if (e_object_is_del(E_OBJECT(ec))) return EINA_FALSE;
+   if (!ec->comp_data) return EINA_FALSE;
+
+   ec->comp_data->on_focus_timer = NULL;
+
+   e_input_thread_safe_call(_e_comp_wl_input_thread_send_keys, NULL, 0);
+
    return EINA_FALSE;
 }
 
-/* It is called in the following cases:
- *  When a normal ec->frame has focus.
- *  Or launching image ec is replaced to the real ec.
- */
-EINTERN void
-e_comp_wl_feed_focus_in(E_Client *ec)
+static void
+_e_comp_wl_input_thread_focus_in(void *data)
 {
-   E_Client *focused;
+   struct wl_resource *surface = NULL;
+   memcpy(&surface, data, sizeof(struct wl_resource *));
    struct wl_resource *res;
    struct wl_client *wc;
    Eina_List *l;
 
-   if (!ec) return;
-   if (e_object_is_del(E_OBJECT(ec))) return;
-   if (ec->iconic) return;
-
-   /* block spurious focus events */
-   focused = e_client_focused_get();
-   if ((focused) && (ec != focused)) return;
-
-   /* raise client priority */
-   _e_comp_wl_client_priority_raise(ec);
-   struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
-   if (!surface) return;
-
    wc = wl_resource_get_client(surface);
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
      {
         if (wl_resource_get_client(res) == wc)
           {
-             g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
              if (!eina_list_data_find(e_comp_wl->kbd.focused, res))
                e_comp_wl->kbd.focused = eina_list_append(e_comp_wl->kbd.focused, res);
-             g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
           }
      }
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
 
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
    if (!e_comp_wl->kbd.focused)
      {
-        g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
         return;
      }
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
 
    e_comp_wl->kbd.focus = surface;
-   e_comp_wl_input_keyboard_enter_send(ec);
+   e_comp_wl_input_keyboard_enter_send(surface);
    e_comp_wl_data_device_keyboard_focus_set();
+}
+
+/* It is called in the following cases:
+ *  When a normal ec->frame has focus.
+ *  Or launching image ec is replaced to the real ec.
+ */
+EINTERN void
+e_comp_wl_feed_focus_in(E_Client *ec)
+{
+   E_Client *focused;
+
+   if (!ec) return;
+   if (e_object_is_del(E_OBJECT(ec))) return;
+   if (ec->iconic) return;
+
+   /* block spurious focus events */
+   focused = e_client_focused_get();
+   if ((focused) && (ec != focused)) return;
+
+   /* raise client priority */
+   _e_comp_wl_client_priority_raise(ec);
+
+   struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
+   if (!surface) return;
+
+   INF("send focus in request to input thread. resource %p\n", surface);
+   e_input_thread_safe_call(_e_comp_wl_input_thread_focus_in, (void *)&surface, sizeof(struct wl_resource *));
+
    ec->comp_data->on_focus_timer =
       ecore_timer_add(((e_config->xkb.delay_held_key_input_to_focus)/1000.0),
                       (Ecore_Task_Cb)_e_comp_wl_evas_cb_focus_in_timer, ec);
@@ -2111,51 +2117,32 @@ _e_comp_wl_evas_cb_focus_in(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj
 }
 
 static void
-_e_comp_wl_evas_cb_focus_out(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+_e_comp_wl_input_thread_focus_out(void *data)
 {
-   E_Client *ec;
+   struct wl_resource *surface = NULL;
    struct wl_resource *res;
    uint32_t serial;
    E_Comp_Wl_Key_Data *k;
    Eina_List *l, *ll;
    double t;
 
-   if (!(ec = data)) return;
-
-   if (!ec->comp_data) return;
-
-   E_FREE_FUNC(ec->comp_data->on_focus_timer, ecore_timer_del);
-
-   /* lower client priority */
-   if (!e_object_is_del(data))
-     _e_comp_wl_client_priority_normal(ec);
-
+   memcpy(&surface, data, sizeof(struct wl_resource *));
 
    /* update keyboard modifier state */
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
    wl_array_for_each(k, &e_comp_wl->kbd.keys)
       e_comp_wl_input_keyboard_state_update(k->key, EINA_FALSE);
 
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-
-   struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
    if (!surface) return;
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    if (!eina_list_count(e_comp_wl->kbd.resources))
      {
-        g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
         return;
      }
 
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
-
    /* send keyboard_leave to all keyboard resources */
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
    t = ecore_time_unix_get();
 
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
    EINA_LIST_FOREACH_SAFE(e_comp_wl->kbd.focused, l, ll, res)
      {
         wl_array_for_each(k, &e_comp_wl->kbd.keys)
@@ -2168,8 +2155,25 @@ _e_comp_wl_evas_cb_focus_out(void *data, Evas *evas EINA_UNUSED, Evas_Object *ob
         e_comp_wl->kbd.focused =
            eina_list_remove_list(e_comp_wl->kbd.focused, l);
      }
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
+}
+
+static void
+_e_comp_wl_evas_cb_focus_out(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+{
+   E_Client *ec;
+   if (!(ec = data)) return;
+
+   if (!ec->comp_data) return;
+
+   E_FREE_FUNC(ec->comp_data->on_focus_timer, ecore_timer_del);
+
+   /* lower client priority */
+   if (!e_object_is_del(data))
+     _e_comp_wl_client_priority_normal(ec);
+
+   struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
+   INF("send focus out request to input thread. resource %p\n", surface);
+   e_input_thread_safe_call(_e_comp_wl_input_thread_focus_out, (void *)&surface, sizeof(struct wl_resource *));
 }
 
 static void
@@ -3268,17 +3272,13 @@ e_comp_wl_client_surface_finish(E_Client *ec)
    if (surface_client &&
        (ec == e_client_focused_get()))
      {
-        g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
         EINA_LIST_FOREACH_SAFE(e_comp_wl->kbd.focused, l, ll, res)
           {
              if (wl_resource_get_client(res) ==
                  surface_client)
                e_comp_wl->kbd.focused =
                   eina_list_remove_list(e_comp_wl->kbd.focused, l);
-
           }
-
-        g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
      }
 
    e_comp_wl_client_surface_set(ec, NULL);
@@ -4317,8 +4317,6 @@ e_comp_wl_key_down(Ecore_Event_Key *ev, E_Device *dev)
      }
 #endif
 
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
-
    end = (E_Comp_Wl_Key_Data *)e_comp_wl->kbd.keys.data + (e_comp_wl->kbd.keys.size / sizeof(*k));
 
    for (k = e_comp_wl->kbd.keys.data; k < end; k++)
@@ -4326,40 +4324,31 @@ e_comp_wl_key_down(Ecore_Event_Key *ev, E_Device *dev)
         /* ignore server-generated key repeats */
         if (k->key == keycode)
           {
-             g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
              return EINA_FALSE;
           }
      }
 
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-
    if ((!e_client_action_get()) && (!e_comp->input_key_grabs))
      {
         ec = e_client_focused_get();
         struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
         if (ec && ec->comp_data && surface)
           {
-             g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
              if (e_comp_wl->kbd.focused)
                {
                   _e_comp_wl_key_send(ev, dev, WL_KEYBOARD_KEY_STATE_PRESSED, e_comp_wl->kbd.focused, ec);
 
                   /* A key only sent to clients is added to the list */
-                  g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
                   e_comp_wl->kbd.keys.size = (const char *)end - (const char *)e_comp_wl->kbd.keys.data;
 
                   if (!(k = wl_array_add(&e_comp_wl->kbd.keys, sizeof(*k))))
                     {
                        DBG("wl_array_add: Out of memory\n");
-                       g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-                       g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
                        return EINA_FALSE;
                     }
-                  g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
                   k->key = keycode;
                   k->dev = ev->dev;
                }
-             g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
           }
      }
 
@@ -4388,8 +4377,6 @@ e_comp_wl_key_up(Ecore_Event_Key *ev, E_Device *dev)
         return EINA_FALSE;
      }
 
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
-
    end = (E_Comp_Wl_Key_Data *)e_comp_wl->kbd.keys.data + (e_comp_wl->kbd.keys.size / sizeof(*k));
    for (k = e_comp_wl->kbd.keys.data; k < end; k++)
      {
@@ -4403,20 +4390,16 @@ e_comp_wl_key_up(Ecore_Event_Key *ev, E_Device *dev)
    e_comp_wl->kbd.keys.size =
      (const char *)end - (const char *)e_comp_wl->kbd.keys.data;
 
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-
    /* If a key down event have been sent to clients, send a key up event to client for garantee key event sequence pair. (down/up) */
    if ((delivered_key) ||
        ((!e_client_action_get()) && (!e_comp->input_key_grabs)))
      {
         ec = e_client_focused_get();
 
-        g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
         if (e_comp_wl->kbd.focused)
           {
              _e_comp_wl_key_send(ev, dev, WL_KEYBOARD_KEY_STATE_RELEASED, e_comp_wl->kbd.focused, ec);
           }
-        g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
      }
 
    /* update modifier state */
@@ -4677,7 +4660,6 @@ e_comp_wl_key_send(E_Client *ec, int keycode, Eina_Bool pressed, void *dev, uint
         ELOGF("INPUT", "wl_keyboard_send_key:%s:%d|B|", NULL, (state ? "PRESS" : "RELEASE"), keycode);
      }
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
      {
         if (wl_resource_get_client(res) != wc) continue;
@@ -4709,7 +4691,6 @@ e_comp_wl_key_send(E_Client *ec, int keycode, Eina_Bool pressed, void *dev, uint
         wl_keyboard_send_key(res, serial, time,
                              wl_keycode, state);
      }
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
 
    if (e_config->key_input_ttrace_enable)
      {
@@ -4761,7 +4742,6 @@ e_comp_wl_key_cancel(E_Client *ec, int keycode, Ecore_Device *dev, uint32_t time
    comp_conf = e_comp_config_get();
    e_keyrouter_event_surface_send(ec, keycode);
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
      {
         if (wl_resource_get_client(res) != wc) continue;
@@ -4777,7 +4757,6 @@ e_comp_wl_key_cancel(E_Client *ec, int keycode, Ecore_Device *dev, uint32_t time
         wl_keyboard_send_key(res, serial, time,
                              cancel_keycode, WL_KEYBOARD_KEY_STATE_RELEASED);
      }
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
 
    return EINA_TRUE;
 }

diff --git a/src/bin/e_comp_wl_input.c b/src/bin/e_comp_wl_input.c
index 9d91a0f..2e83ac8 100644 (file)
--- a/src/bin/e_comp_wl_input.c
+++ b/src/bin/e_comp_wl_input.c
@@ -310,30 +310,32 @@ _e_comp_wl_input_cb_pointer_get(struct wl_client *client, struct wl_resource *re
 }
 
 static void
-_e_comp_wl_input_cb_keyboard_unbind(struct wl_resource *resource)
+_e_comp_wl_input_thread_cb_keyboard_unbind(void *data)
 {
    Eina_List *l, *ll;
    struct wl_resource *res;
+   struct wl_resource *resource;
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
+   memcpy(&resource, data, sizeof(struct wl_resource *));
 
    e_comp_wl->kbd.resources =
      eina_list_remove(e_comp_wl->kbd.resources, resource);
 
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
-
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
-
    EINA_LIST_FOREACH_SAFE(e_comp_wl->kbd.focused, l, ll, res)
      if (res == resource)
        e_comp_wl->kbd.focused =
          eina_list_remove_list(e_comp_wl->kbd.focused, l);
+}
 
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
+static void
+_e_comp_wl_input_cb_keyboard_unbind(struct wl_resource *resource)
+{
+   INF("process keyboard unbind. resource %p\n", resource);
+   e_input_thread_safe_call(_e_comp_wl_input_thread_cb_keyboard_unbind, &resource, sizeof(struct wl_resource *));
 }
 
 void
-e_comp_wl_input_keyboard_enter_send(E_Client *ec)
+e_comp_wl_input_keyboard_enter_send(struct wl_resource *surface)
 {
    struct wl_resource *res;
    Eina_List *l;
@@ -341,26 +343,15 @@ e_comp_wl_input_keyboard_enter_send(E_Client *ec)
    xkb_mod_mask_t mod_depressed, mod_latched, mod_locked;
    xkb_layout_index_t mod_group;
 
-   struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
-   if (!surface) return;
-
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
-
    if (!e_comp_wl->kbd.focused)
      {
-        g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
         return;
      }
 
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
-
    e_comp_wl_input_keyboard_modifiers_serialize();
 
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
 
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
-
    mod_depressed = atomic_load(&e_comp_wl->kbd.mod_depressed);
    mod_latched = atomic_load(&e_comp_wl->kbd.mod_latched);
    mod_locked = atomic_load(&e_comp_wl->kbd.mod_locked);
@@ -378,31 +369,31 @@ e_comp_wl_input_keyboard_enter_send(E_Client *ec)
                                    mod_locked,
                                    mod_group);
      }
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
 }
 
 static void
-_e_comp_wl_input_cb_keyboard_get(struct wl_client *client, struct wl_resource *resource, uint32_t id)
+_e_comp_wl_input_thread_cb_keyboard_get(void *data)
 {
    E_Client *focused;
    struct wl_resource *res;
 
+   E_Input_Thread_Request_Keyboard_Get_Data keyboard_get_data;
+   memcpy(&keyboard_get_data, data, sizeof(E_Input_Thread_Request_Keyboard_Get_Data));
+
    /* try to create keyboard resource */
-   res = wl_resource_create(client, &wl_keyboard_interface,
-                            wl_resource_get_version(resource), id);
+   res = wl_resource_create(keyboard_get_data.client, &wl_keyboard_interface,
+                            keyboard_get_data.resource_version, keyboard_get_data.id);
    if (!res)
      {
         ERR("Could not create keyboard on seat %s: %m",
             e_comp_wl->seat.name);
-        wl_client_post_no_memory(client);
+        wl_client_post_no_memory(keyboard_get_data.client);
         return;
      }
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    e_comp_wl->kbd.resources =
      eina_list_append(e_comp_wl->kbd.resources, res);
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
+
    wl_resource_set_implementation(res, &_e_keyboard_interface,
                                   e_comp->wl_comp_data,
                                   _e_comp_wl_input_cb_keyboard_unbind);
@@ -428,12 +419,23 @@ _e_comp_wl_input_cb_keyboard_get(struct wl_client *client, struct wl_resource *r
    struct wl_resource *surface = e_comp_wl_client_surface_get(focused);
    if (!surface) return;
 
-   if (client != wl_resource_get_client(surface)) return;
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
+   if (keyboard_get_data.client != wl_resource_get_client(surface)) return;
    e_comp_wl->kbd.focused = eina_list_append(e_comp_wl->kbd.focused, res);
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
 
-   e_comp_wl_input_keyboard_enter_send(focused);
+   e_comp_wl_input_keyboard_enter_send(e_comp_wl_client_surface_get(focused));
+}
+
+static void
+_e_comp_wl_input_cb_keyboard_get(struct wl_client *client, struct wl_resource *resource, uint32_t id)
+{
+   E_Input_Thread_Request_Keyboard_Get_Data keyboard_get_data;
+
+   keyboard_get_data.resource_version = wl_resource_get_version(resource);
+   keyboard_get_data.client = client;
+   keyboard_get_data.id = id;
+
+   INF("resource version : %d, client : %p, id : %d\n", keyboard_get_data.resource_version, keyboard_get_data.client, keyboard_get_data.id);
+   e_input_thread_safe_call(_e_comp_wl_input_thread_cb_keyboard_get, &keyboard_get_data, sizeof(E_Input_Thread_Request_Keyboard_Get_Data));
 }
 
 static void
@@ -1476,12 +1478,10 @@ _e_comp_wl_input_keymap_update(struct xkb_keymap *keymap, const char *keymap_pat
 
    /* send updated keymap */
    TRACE_INPUT_BEGIN(wl_keyboard_send_keymap_update);
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
      wl_keyboard_send_keymap(res, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
                              e_comp_input_key->xkb.fd,
                              e_comp_input_key->xkb.size);
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
    TRACE_INPUT_END();
 
    /* update modifiers */
@@ -1502,7 +1502,6 @@ e_comp_wl_input_init(void)
 
    g_mutex_init(&e_comp_wl->kbd.resource_mutex);
    g_mutex_init(&e_comp_wl->kbd.focused_mutex);
-   g_mutex_init(&e_comp_wl->kbd.keys_mutex);
    g_mutex_init(&e_comp_wl->kbd.repeat_delay_mutex);
    g_mutex_init(&e_comp_wl->kbd.repeat_rate_mutex);
 
@@ -1568,10 +1567,7 @@ e_comp_wl_input_init(void)
                                              _e_comp_wl_input_cb_surface_commit,
                                              NULL);
 
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
    wl_array_init(&e_comp_wl->kbd.keys);
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
-
    wl_array_init(&e_comp_wl->kbd.routed_keys);
 
    E_EVENT_TEXT_INPUT_PANEL_VISIBILITY_CHANGE = ecore_event_type_new();
@@ -1622,11 +1618,9 @@ e_comp_wl_input_shutdown(void)
      wl_resource_destroy(res);
 
    /* destroy keyboard resources */
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    EINA_LIST_FREE(e_comp_wl->kbd.resources, res)
      wl_resource_destroy(res);
    e_comp_wl->kbd.resources = eina_list_free(e_comp_wl->kbd.resources);
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
 
    g_mutex_clear(&e_comp_wl->kbd.resource_mutex);
    g_mutex_clear(&e_comp_wl->kbd.focused_mutex);
@@ -1636,9 +1630,7 @@ e_comp_wl_input_shutdown(void)
      wl_resource_destroy(res);
 
    /* destroy e_comp_wl->kbd.keys array */
-   g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
    wl_array_release(&e_comp_wl->kbd.keys);
-   g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
 
    wl_array_release(&e_comp_wl->kbd.routed_keys);
 
@@ -1754,24 +1746,18 @@ e_comp_wl_input_keyboard_modifiers_update(void)
    Eina_List *l;
 
    if (!e_comp_wl_input_keyboard_modifiers_serialize()) return;
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
    if (!e_comp_wl->kbd.focused)
      {
-       g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
        return;
      }
 
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
-
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
-   g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
      wl_keyboard_send_modifiers(res, serial,
                                 e_comp_wl->kbd.mod_depressed,
                                 e_comp_wl->kbd.mod_latched,
                                 e_comp_wl->kbd.mod_locked,
                                 e_comp_wl->kbd.mod_group);
-   g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
 }
 
 EINTERN void
@@ -2104,15 +2090,12 @@ e_comp_wl_input_keyboard_repeat_set(int delay, int rate)
    atomic_store(&e_comp_wl->kbd.repeat_delay, delay);
    atomic_store(&e_comp_wl->kbd.repeat_rate, rate);
 
-   g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
    EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
      {
         if (wl_resource_get_version(res) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
           wl_keyboard_send_repeat_info(res, e_comp_wl->kbd.repeat_rate,
                                        e_comp_wl->kbd.repeat_delay);
      }
-
-   g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
 }
 
 typedef struct _keycode_map{

diff --git a/src/bin/e_comp_wl_input_intern.h b/src/bin/e_comp_wl_input_intern.h
index 2449594..ec1fbe0 100644 (file)
--- a/src/bin/e_comp_wl_input_intern.h
+++ b/src/bin/e_comp_wl_input_intern.h
@@ -20,7 +20,7 @@ EINTERN Eina_Bool e_comp_wl_input_keyboard_check(struct wl_resource *res);
 EINTERN Eina_Bool e_comp_wl_input_keyboard_modifiers_serialize(void);
 EINTERN void      e_comp_wl_input_keyboard_modifiers_update(void);
 EINTERN void      e_comp_wl_input_keyboard_state_update(uint32_t keycode, Eina_Bool pressed);
-EINTERN void      e_comp_wl_input_keyboard_enter_send(E_Client *client);
+EINTERN void      e_comp_wl_input_keyboard_enter_send(struct wl_resource *surface);
 EINTERN void      e_comp_wl_input_keyboard_enabled_set(Eina_Bool enabled);
 
 EINTERN struct xkb_keymap *e_comp_wl_input_keymap_compile(struct xkb_context *ctx, struct xkb_rule_names names, char **keymap_path);

diff --git a/src/bin/e_input_intern.h b/src/bin/e_input_intern.h
index 8b8039b..51dca4b 100644 (file)
--- a/src/bin/e_input_intern.h
+++ b/src/bin/e_input_intern.h
@@ -40,6 +40,13 @@ typedef struct
   uint32_t mode;
 } E_Input_Thread_Request_Keygrab_Data;
 
+typedef struct
+{
+  int resource_version;
+  struct wl_client *client;
+  uint32_t id;
+} E_Input_Thread_Request_Keyboard_Get_Data;
+
 struct _E_Input_Seat
 {
    const char *name;

diff --git a/src/bin/e_keyrouter_wl.c b/src/bin/e_keyrouter_wl.c
index 0045bef..d99becc 100644 (file)
--- a/src/bin/e_keyrouter_wl.c
+++ b/src/bin/e_keyrouter_wl.c
@@ -69,11 +69,6 @@ _e_keyrouter_wl_key_send(Ecore_Event_Key *ev, E_Device *dev, enum wl_keyboard_ke
         ELOGF("INPUT", "wl_keyboard_send_key:%s:%s|B|", NULL, (state ? "PRESS" : "RELEASE"), ev->keyname);
      }
 
-   if (focused)
-     g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
-   else
-     g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
-
    EINA_LIST_FOREACH(key_list, l, res)
      {
         wc = wl_resource_get_client(res);
@@ -97,11 +92,6 @@ _e_keyrouter_wl_key_send(Ecore_Event_Key *ev, E_Device *dev, enum wl_keyboard_ke
         TRACE_INPUT_END();
      }
 
-   if (focused)
-     g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
-   else
-     g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
-
    if (e_config->key_input_ttrace_enable)
      {
         TRACE_INPUT_END();

diff --git a/src/include/e_comp_wl.h b/src/include/e_comp_wl.h
index e09f85c..2ef548b 100644 (file)
--- a/src/include/e_comp_wl.h
+++ b/src/include/e_comp_wl.h
@@ -237,7 +237,7 @@ struct _E_Comp_Wl_Data
         unsigned int num_devices;
         GMutex resource_mutex; /* for resources variable */
         GMutex focused_mutex; /* for focused variable */
-        GMutex keys_mutex; /* for keys variable */
+        EINA_DEPRECATED GMutex keys_mutex; /* for keys variable */
         GMutex repeat_delay_mutex; /* for repeat_delay variable */
         GMutex repeat_rate_mutex; /* for repeat_rate variable */
      } kbd;