Move alarm and xids management to MetaX11Display

https://bugzilla.gnome.org/show_bug.cgi?id=759538

src/x11/events.c

@@ -856,7 +856,9 @@ handle_input_xevent (MetaDisplay  *display,
     }
 
   modified = xievent_get_modified_window (display, input_event);
-  window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
+  window = modified != None ?
+           meta_x11_display_lookup_x_window (display->x11_display, modified) :
+           NULL;
 
   /* If this is an event for a GTK+ widget, let GTK+ handle it. */
   if (meta_ui_window_is_widget (display->screen->ui, modified))
@@ -1173,7 +1175,8 @@ notify_bell (MetaDisplay *display,
   XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
   MetaWindow *window;
 
-  window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+  window = meta_x11_display_lookup_x_window (display->x11_display,
+                                             xkb_bell_event->window);
   if (!window && display->focus_window && display->focus_window->frame)
     window = display->focus_window;
 
@@ -1202,7 +1205,7 @@ handle_other_xevent (MetaDisplay *display,
   gboolean bypass_gtk = FALSE;
 
   modified = event_get_modified_window (display, event);
-  window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
+  window = modified != None ? meta_x11_display_lookup_x_window (x11_display, modified) : NULL;
   frame_was_receiver = (window && window->frame && modified == window->frame->xwindow);
 
   /* We only want to respond to _NET_WM_USER_TIME property notify
@@ -1219,8 +1222,8 @@ handle_other_xevent (MetaDisplay *display,
   if (META_X11_DISPLAY_HAS_XSYNC (x11_display) &&
       event->type == (x11_display->xsync_event_base + XSyncAlarmNotify))
     {
-      MetaWindow *alarm_window = meta_display_lookup_sync_alarm (display,
-                                                                 ((XSyncAlarmNotifyEvent*)event)->alarm);
+      MetaWindow *alarm_window = meta_x11_display_lookup_sync_alarm (x11_display,
+                                                                     ((XSyncAlarmNotifyEvent*)event)->alarm);
 
       if (alarm_window != NULL)
         {
@@ -1232,10 +1235,10 @@ handle_other_xevent (MetaDisplay *display,
         }
       else
         {
-          if (display->alarm_filter &&
-              display->alarm_filter (display,
-                                     (XSyncAlarmNotifyEvent*)event,
-                                     display->alarm_filter_data))
+          if (x11_display->alarm_filter &&
+              x11_display->alarm_filter (x11_display,
+                                         (XSyncAlarmNotifyEvent*)event,
+                                          x11_display->alarm_filter_data))
             bypass_gtk = TRUE;
         }
 
@@ -1748,7 +1751,8 @@ meta_display_handle_xevent (MetaDisplay *display,
       meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                   display->focus_window->desc);
       meta_display_update_focus_window (display,
-                                        meta_display_lookup_x_window (display, display->server_focus_window),
+                                        meta_x11_display_lookup_x_window (display->x11_display,
+                                                                          display->server_focus_window),
                                         display->server_focus_window,
                                         display->server_focus_serial,
                                         FALSE);
@@ -1780,7 +1784,7 @@ meta_display_handle_xevent (MetaDisplay *display,
     }
 
 #ifdef HAVE_XI23
-  if (meta_display_process_barrier_xevent (display, input_event))
+  if (meta_x11_display_process_barrier_xevent (display->x11_display, input_event))
     {
       bypass_gtk = bypass_compositor = TRUE;
       goto out;
@@ -1814,7 +1818,9 @@ meta_display_handle_xevent (MetaDisplay *display,
  out:
   if (!bypass_compositor)
     {
-      MetaWindow *window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
+      MetaWindow *window = modified != None ?
+                           meta_x11_display_lookup_x_window (display->x11_display, modified) :
+                           NULL;
 
       if (meta_compositor_process_event (display->compositor, event, window))
         bypass_gtk = TRUE;

src/x11/meta-x11-display-private.h

@@ -33,6 +33,10 @@
 #include "meta/types.h"
 #include "meta/meta-x11-display.h"
 
+typedef gboolean (*MetaAlarmFilter) (MetaX11Display        *x11_display,
+                                     XSyncAlarmNotifyEvent *event,
+                                     gpointer               data);
+
 struct _MetaX11Display
 {
   GObject parent;
@@ -54,6 +58,11 @@ struct _MetaX11Display
 #include "x11/atomnames.h"
 #undef item
 
+  GHashTable *xids;
+
+  MetaAlarmFilter alarm_filter;
+  gpointer alarm_filter_data;
+
   int composite_event_base;
   int composite_error_base;
   int composite_major_version;
@@ -96,4 +105,29 @@ Cursor meta_x11_display_create_x_cursor (MetaX11Display *x11_display,
 
 void meta_x11_display_reload_cursor (MetaX11Display *x11_display);
 
+MetaWindow *meta_x11_display_lookup_x_window     (MetaX11Display *x11_display,
+                                                  Window          xwindow);
+void        meta_x11_display_register_x_window   (MetaX11Display *x11_display,
+                                                  Window         *xwindowp,
+                                                  MetaWindow     *window);
+void        meta_x11_display_unregister_x_window (MetaX11Display *x11_display,
+                                                  Window          xwindow);
+
+MetaWindow *meta_x11_display_lookup_sync_alarm     (MetaX11Display *x11_display,
+                                                    XSyncAlarm      alarm);
+void        meta_x11_display_register_sync_alarm   (MetaX11Display *x11_display,
+                                                    XSyncAlarm     *alarmp,
+                                                    MetaWindow     *window);
+void        meta_x11_display_unregister_sync_alarm (MetaX11Display *x11_display,
+                                                    XSyncAlarm      alarm);
+
+#ifdef HAVE_XI23
+gboolean meta_x11_display_process_barrier_xevent (MetaX11Display *x11_display,
+                                                  XIEvent        *event);
+#endif /* HAVE_XI23 */
+
+void meta_x11_display_set_alarm_filter (MetaX11Display *x11_display,
+                                        MetaAlarmFilter filter,
+                                        gpointer        data);
+
 #endif /* META_X11_DISPLAY_PRIVATE_H */

src/x11/meta-x11-display.c

@@ -68,6 +68,15 @@ meta_x11_display_dispose (GObject *object)
 {
   MetaX11Display *x11_display = META_X11_DISPLAY (object);
 
+  if (x11_display->xids)
+    {
+      /* Must be after all calls to meta_window_unmanage() since they
+       * unregister windows
+       */
+      g_hash_table_destroy (x11_display->xids);
+      x11_display->xids = NULL;
+    }
+
   if (x11_display->xroot != None)
     {
       meta_error_trap_push (x11_display);
@@ -397,6 +406,9 @@ meta_x11_display_new (MetaDisplay *display, GError **error)
 
   update_cursor_theme (x11_display);
 
+  x11_display->xids = g_hash_table_new (meta_unsigned_long_hash,
+                                        meta_unsigned_long_equal);
+
   return x11_display;
 }
 
@@ -556,3 +568,72 @@ update_cursor_theme (MetaX11Display *x11_display)
       set_cursor_theme (xdisplay);
     }
 }
+
+MetaWindow *
+meta_x11_display_lookup_x_window (MetaX11Display *x11_display,
+                                  Window          xwindow)
+{
+  return g_hash_table_lookup (x11_display->xids, &xwindow);
+}
+
+void
+meta_x11_display_register_x_window (MetaX11Display *x11_display,
+                                    Window         *xwindowp,
+                                    MetaWindow     *window)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, xwindowp) == NULL);
+
+  g_hash_table_insert (x11_display->xids, xwindowp, window);
+}
+
+void
+meta_x11_display_unregister_x_window (MetaX11Display *x11_display,
+                                      Window          xwindow)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, &xwindow) != NULL);
+
+  g_hash_table_remove (x11_display->xids, &xwindow);
+}
+
+
+/* We store sync alarms in the window ID hash table, because they are
+ * just more types of XIDs in the same global space, but we have
+ * typesafe functions to register/unregister for readability.
+ */
+
+MetaWindow *
+meta_x11_display_lookup_sync_alarm (MetaX11Display *x11_display,
+                                    XSyncAlarm      alarm)
+{
+  return g_hash_table_lookup (x11_display->xids, &alarm);
+}
+
+void
+meta_x11_display_register_sync_alarm (MetaX11Display *x11_display,
+                                      XSyncAlarm     *alarmp,
+                                      MetaWindow     *window)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, alarmp) == NULL);
+
+  g_hash_table_insert (x11_display->xids, alarmp, window);
+}
+
+void
+meta_x11_display_unregister_sync_alarm (MetaX11Display *x11_display,
+                                        XSyncAlarm      alarm)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, &alarm) != NULL);
+
+  g_hash_table_remove (x11_display->xids, &alarm);
+}
+
+void
+meta_x11_display_set_alarm_filter (MetaX11Display *x11_display,
+                                   MetaAlarmFilter filter,
+                                   gpointer        data)
+{
+  g_return_if_fail (filter == NULL || x11_display->alarm_filter == NULL);
+
+  x11_display->alarm_filter = filter;
+  x11_display->alarm_filter_data = data;
+}

src/x11/window-props.c

@@ -468,8 +468,8 @@ reload_net_wm_user_time_window (MetaWindow    *window,
       if (window->user_time_window != None)
         {
           /* See the comment to the meta_display_register_x_window call below. */
-          meta_display_unregister_x_window (window->display,
-                                            window->user_time_window);
+          meta_x11_display_unregister_x_window (window->display->x11_display,
+                                                window->user_time_window);
           /* Don't get events on not-managed windows */
           XSelectInput (window->display->x11_display->xdisplay,
                         window->user_time_window,
@@ -479,10 +479,12 @@ reload_net_wm_user_time_window (MetaWindow    *window,
       /* Ensure the new user time window is not used on another MetaWindow,
        * and unset its user time window if that is the case.
        */
-      prev_owner = meta_display_lookup_x_window (window->display, value->v.xwindow);
+      prev_owner = meta_x11_display_lookup_x_window (window->display->x11_display,
+                                                     value->v.xwindow);
       if (prev_owner && prev_owner->user_time_window == value->v.xwindow)
         {
-          meta_display_unregister_x_window (window->display, value->v.xwindow);
+          meta_x11_display_unregister_x_window (window->display->x11_display,
+                                               value->v.xwindow);
           prev_owner->user_time_window = None;
         }
 
@@ -502,9 +504,9 @@ reload_net_wm_user_time_window (MetaWindow    *window,
            * than atom__NET_WM_USER_TIME ones, but I just don't care
            * and it's not specified in the spec anyway.
            */
-          meta_display_register_x_window (window->display,
-                                          &window->user_time_window,
-                                          window);
+          meta_x11_display_register_x_window (window->display->x11_display,
+                                              &window->user_time_window,
+                                              window);
           /* Just listen for property notify events */
           XSelectInput (window->display->x11_display->xdisplay,
                         window->user_time_window,
@@ -1630,7 +1632,8 @@ reload_transient_for (MetaWindow    *window,
     {
       transient_for = value->v.xwindow;
 
-      parent = meta_display_lookup_x_window (window->display, transient_for);
+      parent = meta_x11_display_lookup_x_window (window->display->x11_display,
+                                                 transient_for);
       if (!parent)
         {
           meta_warning ("Invalid WM_TRANSIENT_FOR window 0x%lx specified for %s.\n",
@@ -1649,8 +1652,8 @@ reload_transient_for (MetaWindow    *window,
               break;
             }
 
-          parent = meta_display_lookup_x_window (parent->display,
-                                                 parent->xtransient_for);
+          parent = meta_x11_display_lookup_x_window (parent->display->x11_display,
+                                                     parent->xtransient_for);
         }
     }
   else
@@ -1671,8 +1674,8 @@ reload_transient_for (MetaWindow    *window,
     meta_window_set_transient_for (window, NULL);
   else
     {
-      parent = meta_display_lookup_x_window (window->display,
-                                             window->xtransient_for);
+      parent = meta_x11_display_lookup_x_window (window->display->x11_display,
+                                                 window->xtransient_for);
       meta_window_set_transient_for (window, parent);
     }
 }

src/x11/window-x11.c

@@ -510,7 +510,9 @@ meta_window_x11_manage (MetaWindow *window)
 
   meta_icon_cache_init (&priv->icon_cache);
 
-  meta_display_register_x_window (display, &window->xwindow, window);
+  meta_x11_display_register_x_window (display->x11_display,
+                                      &window->xwindow,
+                                      window);
 
   /* assign the window to its group, or create a new group if needed */
   window->group = NULL;
@@ -617,7 +619,7 @@ meta_window_x11_unmanage (MetaWindow *window)
                   window->xwindow);
     }
 
-  meta_display_unregister_x_window (window->display, window->xwindow);
+  meta_x11_display_unregister_x_window (x11_display, window->xwindow);
 
   /* Put back anything we messed up */
   if (priv->border_width != 0)
@@ -645,8 +647,8 @@ meta_window_x11_unmanage (MetaWindow *window)
 
   if (window->user_time_window != None)
     {
-      meta_display_unregister_x_window (window->display,
-                                        window->user_time_window);
+      meta_x11_display_unregister_x_window (x11_display,
+                                            window->user_time_window);
       window->user_time_window = None;
     }
 
@@ -2247,8 +2249,8 @@ meta_window_x11_configure_request (MetaWindow *window,
               MetaDisplay *display;
 
               display = meta_window_get_display (window);
-              sibling = meta_display_lookup_x_window (display,
-                                                      event->xconfigurerequest.above);
+              sibling = meta_x11_display_lookup_x_window (display->x11_display,
+                                                          event->xconfigurerequest.above);
               if (sibling == NULL)
                 return TRUE;
 
@@ -2340,14 +2342,14 @@ handle_net_restack_window (MetaDisplay *display,
   if (event->xclient.data.l[0] != 2)
     return;
 
-  window = meta_display_lookup_x_window (display,
-                                         event->xclient.window);
+  window = meta_x11_display_lookup_x_window (display->x11_display,
+                                             event->xclient.window);
 
   if (window)
     {
       if (event->xclient.data.l[1])
-        sibling = meta_display_lookup_x_window (display,
-                                                event->xclient.data.l[1]);
+        sibling = meta_x11_display_lookup_x_window (display->x11_display,
+                                                    event->xclient.data.l[1]);
 
       restack_window (window, sibling, event->xclient.data.l[2]);
     }
@@ -3484,7 +3486,7 @@ meta_window_x11_create_sync_request_alarm (MetaWindow *window)
                                                  &values);
 
   if (meta_error_trap_pop_with_return (x11_display) == Success)
-    meta_display_register_sync_alarm (window->display, &window->sync_request_alarm, window);
+    meta_x11_display_register_sync_alarm (x11_display, &window->sync_request_alarm, window);
   else
     {
       window->sync_request_alarm = None;
@@ -3495,11 +3497,13 @@ meta_window_x11_create_sync_request_alarm (MetaWindow *window)
 void
 meta_window_x11_destroy_sync_request_alarm (MetaWindow *window)
 {
+  MetaX11Display *x11_display = window->display->x11_display;
+
   if (window->sync_request_alarm != None)
     {
       /* Has to be unregistered _before_ clearing the structure field */
-      meta_display_unregister_sync_alarm (window->display, window->sync_request_alarm);
-      XSyncDestroyAlarm (window->display->x11_display->xdisplay,
+      meta_x11_display_unregister_sync_alarm (x11_display, window->sync_request_alarm);
+      XSyncDestroyAlarm (x11_display->xdisplay,
                          window->sync_request_alarm);
       window->sync_request_alarm = None;
     }

src/x11/xprops.c

@@ -132,7 +132,7 @@ validate_or_free_results (GetPropertyResults *results,
   prop_name = XGetAtomName (x11_display->xdisplay, results->xatom);
   meta_error_trap_pop (x11_display);
 
-  w = meta_display_lookup_x_window (results->display, results->xwindow);
+  w = meta_x11_display_lookup_x_window (x11_display, results->xwindow);
 
   if (w != NULL)
     {