core: Set timestamp in our DESKTOP_STARTUP_ID tokens

We must be educated to X11 clients (which usually parse the timestamp from
the DESKTOP_STARTUP_ID, and request focus with it) to make focus stealing
prevention work across the board.

To wayland clients the startup ID should be as opaque and meaningless as
it was before.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/540

clutter/clutter/clutter-device-manager.c

@@ -550,13 +550,7 @@ static gboolean
 are_kbd_a11y_settings_equal (ClutterKbdA11ySettings *a,
                              ClutterKbdA11ySettings *b)
 {
-  return (a->controls == b->controls &&
-          a->slowkeys_delay == b->slowkeys_delay &&
-          a->debounce_delay == b->debounce_delay &&
-          a->timeout_delay == b->timeout_delay &&
-          a->mousekeys_init_delay == b->mousekeys_init_delay &&
-          a->mousekeys_max_speed == b->mousekeys_max_speed &&
-          a->mousekeys_accel_time == b->mousekeys_accel_time);
+  return (memcmp (a, b, sizeof (ClutterKbdA11ySettings)) == 0);
 }
 
 void

clutter/clutter/evdev/clutter-input-device-evdev.c

@@ -1132,13 +1132,13 @@ clutter_input_device_evdev_process_kbd_a11y_event (ClutterEvent               *e
   if (event->key.flags & CLUTTER_EVENT_FLAG_INPUT_METHOD)
     goto emit_event;
 
-  if (!(device_evdev->a11y_flags & CLUTTER_A11Y_KEYBOARD_ENABLED))
-    goto emit_event;
-
-  if (event->type == CLUTTER_KEY_PRESS)
-    handle_enablekeys_press (event, device_evdev);
-  else
-    handle_enablekeys_release (event, device_evdev);
+  if (device_evdev->a11y_flags & CLUTTER_A11Y_KEYBOARD_ENABLED)
+    {
+      if (event->type == CLUTTER_KEY_PRESS)
+        handle_enablekeys_press (event, device_evdev);
+      else
+        handle_enablekeys_release (event, device_evdev);
+    }
 
   if (device_evdev->a11y_flags & CLUTTER_A11Y_MOUSE_KEYS_ENABLED)
     {

cogl/cogl/winsys/cogl-winsys-glx.c

@@ -99,9 +99,9 @@ typedef struct _CoglOnscreenGLX
   CoglOnscreenXlib _parent;
   GLXDrawable glxwin;
   uint32_t last_swap_vsync_counter;
-  gboolean pending_sync_notify;
-  gboolean pending_complete_notify;
-  gboolean pending_resize_notify;
+  uint32_t pending_sync_notify;
+  uint32_t pending_complete_notify;
+  uint32_t pending_resize_notify;
 
   GThread *swap_wait_thread;
   GQueue *swap_wait_queue;
@@ -347,35 +347,35 @@ flush_pending_notifications_cb (void *data,
     {
       CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
       CoglOnscreenGLX *glx_onscreen = onscreen->winsys;
-      gboolean pending_sync_notify = glx_onscreen->pending_sync_notify;
-      gboolean pending_complete_notify = glx_onscreen->pending_complete_notify;
 
-      /* If swap_region is called then notifying the sync event could
-       * potentially immediately queue a subsequent pending notify so
-       * we need to clear the flag before invoking the callback */
-      glx_onscreen->pending_sync_notify = FALSE;
-      glx_onscreen->pending_complete_notify = FALSE;
-
-      if (pending_sync_notify)
+      while (glx_onscreen->pending_sync_notify > 0 ||
+             glx_onscreen->pending_complete_notify > 0 ||
+             glx_onscreen->pending_resize_notify > 0)
         {
-          CoglFrameInfo *info = g_queue_peek_head (&onscreen->pending_frame_infos);
+          if (glx_onscreen->pending_sync_notify > 0)
+            {
+              CoglFrameInfo *info =
+                g_queue_peek_head (&onscreen->pending_frame_infos);
 
-          _cogl_onscreen_notify_frame_sync (onscreen, info);
-        }
+              _cogl_onscreen_notify_frame_sync (onscreen, info);
+              glx_onscreen->pending_sync_notify--;
+            }
 
-      if (pending_complete_notify)
-        {
-          CoglFrameInfo *info = g_queue_pop_head (&onscreen->pending_frame_infos);
+          if (glx_onscreen->pending_complete_notify > 0)
+            {
+              CoglFrameInfo *info =
+                g_queue_pop_head (&onscreen->pending_frame_infos);
 
-          _cogl_onscreen_notify_complete (onscreen, info);
+              _cogl_onscreen_notify_complete (onscreen, info);
+              cogl_object_unref (info);
+              glx_onscreen->pending_complete_notify--;
+            }
 
-          cogl_object_unref (info);
-        }
-
-      if (glx_onscreen->pending_resize_notify)
-        {
-          _cogl_onscreen_notify_resize (onscreen);
-          glx_onscreen->pending_resize_notify = FALSE;
+          if (glx_onscreen->pending_resize_notify > 0)
+            {
+              _cogl_onscreen_notify_resize (onscreen);
+              glx_onscreen->pending_resize_notify--;
+            }
         }
     }
 }
@@ -417,7 +417,7 @@ set_sync_pending (CoglOnscreen *onscreen)
                                       NULL);
     }
 
-  glx_onscreen->pending_sync_notify = TRUE;
+  glx_onscreen->pending_sync_notify++;
 }
 
 static void
@@ -440,7 +440,7 @@ set_complete_pending (CoglOnscreen *onscreen)
                                       NULL);
     }
 
-  glx_onscreen->pending_complete_notify = TRUE;
+  glx_onscreen->pending_complete_notify++;
 }
 
 static void
@@ -533,7 +533,7 @@ notify_resize (CoglContext *context,
                                       NULL);
     }
 
-  glx_onscreen->pending_resize_notify = TRUE;
+  glx_onscreen->pending_resize_notify++;
 
   if (!xlib_onscreen->is_foreign_xwin)
     {

config.h.meson

@@ -46,9 +46,6 @@
 /* Building with SM support */
 #mesondefine HAVE_SM
 
-/* Building with startup notification support */
-#mesondefine HAVE_STARTUP_NOTIFICATION
-
 /* Path to Xwayland executable */
 #mesondefine XWAYLAND_PATH
 

meson.build

@@ -225,12 +225,6 @@ if have_pango_ft2
   pangoft2_dep = dependency('pangoft2')
 endif
 
-have_startup_notification = get_option('startup_notification')
-if have_startup_notification
-  libstartup_notification_dep = dependency('libstartup-notification-1.0',
-                                           version: libstartup_notification_req)
-endif
-
 have_remote_desktop = get_option('remote_desktop')
 if have_remote_desktop
   libpipewire_dep = dependency('libpipewire-0.2', version: libpipewire_req)
@@ -334,7 +328,6 @@ cdata.set('HAVE_WAYLAND_EGLSTREAM', have_wayland_eglstream)
 cdata.set('HAVE_LIBGUDEV', have_libgudev)
 cdata.set('HAVE_LIBWACOM', have_libwacom)
 cdata.set('HAVE_SM', have_sm)
-cdata.set('HAVE_STARTUP_NOTIFICATION', have_startup_notification)
 cdata.set('HAVE_INTROSPECTION', have_introspection)
 
 xkb_base = xkeyboard_config_dep.get_pkgconfig_variable('xkb_base')
@@ -399,7 +392,6 @@ output = [
   '        gudev.................... ' + have_libgudev.to_string(),
   '        Wacom.................... ' + have_libwacom.to_string(),
   '        SM....................... ' + have_sm.to_string(),
-  '        Startup notification..... ' + have_startup_notification.to_string(),
   '        Introspection............ ' + have_introspection.to_string(),
   '',
   '    Tests:',

src/backends/native/meta-renderer-native.c

@@ -3787,16 +3787,13 @@ gpu_kms_is_hardware_rendering (MetaRendererNative *renderer_native,
   return data->secondary.is_hardware_rendering;
 }
 
-static MetaRendererNativeGpuData *
-create_renderer_gpu_data_gbm (MetaRendererNative  *renderer_native,
-                              MetaGpuKms          *gpu_kms,
-                              GError             **error)
+static EGLDisplay
+init_gbm_egl_display (MetaRendererNative  *renderer_native,
+                      struct gbm_device   *gbm_device,
+                      GError             **error)
 {
   MetaEgl *egl = meta_renderer_native_get_egl (renderer_native);
-  struct gbm_device *gbm_device;
   EGLDisplay egl_display;
-  int kms_fd;
-  MetaRendererNativeGpuData *renderer_gpu_data;
 
   if (!meta_egl_has_extensions (egl, EGL_NO_DISPLAY, NULL,
                                 "EGL_MESA_platform_gbm",
@@ -3808,9 +3805,31 @@ create_renderer_gpu_data_gbm (MetaRendererNative  *renderer_native,
       g_set_error (error, G_IO_ERROR,
                    G_IO_ERROR_FAILED,
                    "Missing extension for GBM renderer: EGL_KHR_platform_gbm");
-      return NULL;
+      return EGL_NO_DISPLAY;
     }
 
+  egl_display = meta_egl_get_platform_display (egl,
+                                               EGL_PLATFORM_GBM_KHR,
+                                               gbm_device, NULL, error);
+  if (egl_display == EGL_NO_DISPLAY)
+    return EGL_NO_DISPLAY;
+
+  if (!meta_egl_initialize (egl, egl_display, error))
+    return EGL_NO_DISPLAY;
+
+  return egl_display;
+}
+
+static MetaRendererNativeGpuData *
+create_renderer_gpu_data_gbm (MetaRendererNative  *renderer_native,
+                              MetaGpuKms          *gpu_kms,
+                              GError             **error)
+{
+  struct gbm_device *gbm_device;
+  int kms_fd;
+  MetaRendererNativeGpuData *renderer_gpu_data;
+  g_autoptr (GError) local_error = NULL;
+
   kms_fd = meta_gpu_kms_get_fd (gpu_kms);
 
   gbm_device = gbm_create_device (kms_fd);
@@ -3822,26 +3841,25 @@ create_renderer_gpu_data_gbm (MetaRendererNative  *renderer_native,
       return NULL;
     }
 
-  egl_display = meta_egl_get_platform_display (egl,
-                                               EGL_PLATFORM_GBM_KHR,
-                                               gbm_device, NULL, error);
-  if (egl_display == EGL_NO_DISPLAY)
-    {
-      gbm_device_destroy (gbm_device);
-      return NULL;
-    }
-
-  if (!meta_egl_initialize (egl, egl_display, error))
-    return NULL;
-
   renderer_gpu_data = meta_create_renderer_native_gpu_data (gpu_kms);
   renderer_gpu_data->renderer_native = renderer_native;
   renderer_gpu_data->gbm.device = gbm_device;
   renderer_gpu_data->mode = META_RENDERER_NATIVE_MODE_GBM;
-  renderer_gpu_data->egl_display = egl_display;
+
+  renderer_gpu_data->egl_display = init_gbm_egl_display (renderer_native,
+                                                         gbm_device,
+                                                         &local_error);
+  if (renderer_gpu_data->egl_display == EGL_NO_DISPLAY)
+    {
+      g_debug ("GBM EGL init for %s failed: %s",
+               meta_gpu_kms_get_file_path (gpu_kms),
+               local_error->message);
+
+      init_secondary_gpu_data_cpu (renderer_gpu_data);
+      return renderer_gpu_data;
+    }
 
   init_secondary_gpu_data (renderer_gpu_data);
-
   return renderer_gpu_data;
 }
 
@@ -4134,8 +4152,8 @@ on_gpu_added (MetaMonitorManager *monitor_manager,
 }
 
 static MetaGpuKms *
-choose_primary_gpu (MetaMonitorManager *manager,
-                    MetaRendererNative *renderer_native)
+choose_primary_gpu_unchecked (MetaMonitorManager *manager,
+                              MetaRendererNative *renderer_native)
 {
   GList *gpus = meta_monitor_manager_get_gpus (manager);
   GList *l;
@@ -4184,6 +4202,28 @@ choose_primary_gpu (MetaMonitorManager *manager,
   return NULL;
 }
 
+static MetaGpuKms *
+choose_primary_gpu (MetaMonitorManager  *manager,
+                    MetaRendererNative  *renderer_native,
+                    GError             **error)
+{
+  MetaGpuKms *gpu_kms;
+  MetaRendererNativeGpuData *renderer_gpu_data;
+
+  gpu_kms = choose_primary_gpu_unchecked (manager, renderer_native);
+  renderer_gpu_data = meta_renderer_native_get_gpu_data (renderer_native,
+                                                         gpu_kms);
+  if (renderer_gpu_data->egl_display == EGL_NO_DISPLAY)
+    {
+      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
+                   "The GPU %s chosen as primary is not supported by EGL.",
+                   meta_gpu_kms_get_file_path (gpu_kms));
+      return NULL;
+    }
+
+  return gpu_kms;
+}
+
 static gboolean
 meta_renderer_native_initable_init (GInitable     *initable,
                                     GCancellable  *cancellable,
@@ -4207,7 +4247,10 @@ meta_renderer_native_initable_init (GInitable     *initable,
     }
 
   renderer_native->primary_gpu_kms = choose_primary_gpu (monitor_manager,
-                                                         renderer_native);
+                                                         renderer_native,
+                                                         error);
+  if (!renderer_native->primary_gpu_kms)
+    return FALSE;
 
   return TRUE;
 }

src/core/display-private.h

@@ -31,10 +31,6 @@
 #include <X11/extensions/sync.h>
 #include <X11/Xlib.h>
 
-#ifdef HAVE_STARTUP_NOTIFICATION
-#include <libsn/sn.h>
-#endif
-
 #include "clutter/clutter.h"
 #include "core/keybindings-private.h"
 #include "core/meta-gesture-tracker-private.h"

src/core/keybindings.c

@@ -2214,6 +2214,8 @@ meta_keybindings_process_event (MetaDisplay        *display,
     {
     case CLUTTER_BUTTON_PRESS:
     case CLUTTER_BUTTON_RELEASE:
+    case CLUTTER_TOUCH_BEGIN:
+    case CLUTTER_TOUCH_END:
       keys->overlay_key_only_pressed = FALSE;
       return FALSE;
 

src/core/main.c

@@ -118,11 +118,6 @@ static void prefs_changed_callback (MetaPreference pref,
 static void
 meta_print_compilation_info (void)
 {
-#ifdef HAVE_STARTUP_NOTIFICATION
-  meta_verbose ("Compiled with startup notification\n");
-#else
-  meta_verbose ("Compiled without startup notification\n");
-#endif
 }
 
 /**

src/core/meta-launch-context.c

@@ -119,40 +119,37 @@ meta_launch_context_constructed (GObject *object)
                                "WAYLAND_DISPLAY", getenv ("WAYLAND_DISPLAY"));
 }
 
+static gchar *
+create_startup_notification_id (uint32_t timestamp)
+{
+  gchar *uuid, *id;
+
+  uuid = g_uuid_string_random ();
+  id = g_strdup_printf ("%s_TIME%u", uuid, timestamp);
+  g_free (uuid);
+
+  return id;
+}
+
 static gchar *
 meta_launch_context_get_startup_notify_id (GAppLaunchContext *launch_context,
                                            GAppInfo          *info,
                                            GList             *files)
 {
   MetaLaunchContext *context = META_LAUNCH_CONTEXT (launch_context);
-  MetaDisplay *display = context->display;
   int workspace_idx = -1;
   char *startup_id = NULL;
 
   if (context->workspace)
     workspace_idx = meta_workspace_index (context->workspace);
 
-  if (display->x11_display)
-    {
-      /* If there is a X11 display, we prefer going entirely through
-       * libsn, as SnMonitor expects to keep a view of the full lifetime
-       * of the startup sequence. We can't avoid it when launching and
-       * expect that a "remove" message from a X11 client will be handled.
-       */
-      startup_id =
-        meta_x11_startup_notification_launch (display->x11_display,
-                                              info,
-                                              context->timestamp,
-                                              workspace_idx);
-    }
-
   if (!startup_id)
     {
       const char *application_id = NULL;
       MetaStartupNotification *sn;
       MetaStartupSequence *seq;
 
-      startup_id = g_uuid_string_random ();
+      startup_id = create_startup_notification_id (context->timestamp);
 
       /* Fallback through inserting our own startup sequence, this
        * will be enough for wayland clients.

src/core/startup-notification.c

@@ -37,7 +37,7 @@
  * OpenOffice or whatever seems to stop launching - people
  * might decide they need to launch it again.
  */
-#define STARTUP_TIMEOUT 15000000
+#define STARTUP_TIMEOUT_MS 15000
 
 enum
 {
@@ -59,6 +59,12 @@ enum
   N_SEQ_PROPS
 };
 
+enum
+{
+  SEQ_COMPLETE,
+  N_SEQ_SIGNALS
+};
+
 enum
 {
   CHANGED,
@@ -67,6 +73,7 @@ enum
 
 static guint sn_signals[N_SIGNALS];
 static GParamSpec *sn_props[N_PROPS];
+static guint seq_signals[N_SEQ_SIGNALS];
 static GParamSpec *seq_props[N_SEQ_PROPS];
 
 typedef struct
@@ -106,12 +113,26 @@ G_DEFINE_TYPE_WITH_PRIVATE (MetaStartupSequence,
 
 static void meta_startup_notification_ensure_timeout  (MetaStartupNotification *sn);
 
+static gboolean
+meta_startup_notification_has_pending_sequences (MetaStartupNotification *sn)
+{
+  GSList *l;
+
+  for (l = sn->startup_sequences; l; l = l->next)
+    {
+      if (!meta_startup_sequence_get_completed (l->data))
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
 static void
 meta_startup_notification_update_feedback (MetaStartupNotification *sn)
 {
   MetaDisplay *display = sn->display;
 
-  if (sn->startup_sequences != NULL)
+  if (meta_startup_notification_has_pending_sequences (sn))
     {
       meta_topic (META_DEBUG_STARTUP,
                   "Setting busy cursor\n");
@@ -239,6 +260,14 @@ meta_startup_sequence_class_init (MetaStartupSequenceClass *klass)
   object_class->set_property = meta_startup_sequence_set_property;
   object_class->get_property = meta_startup_sequence_get_property;
 
+  seq_signals[SEQ_COMPLETE] =
+    g_signal_new ("complete",
+                  META_TYPE_STARTUP_SEQUENCE,
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (MetaStartupSequenceClass, complete),
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
   seq_props[PROP_SEQ_ID] =
     g_param_spec_string ("id",
                          "ID",
@@ -317,7 +346,6 @@ meta_startup_sequence_get_timestamp (MetaStartupSequence *seq)
 void
 meta_startup_sequence_complete (MetaStartupSequence *seq)
 {
-  MetaStartupSequenceClass *klass;
   MetaStartupSequencePrivate *priv;
 
   g_return_if_fail (META_IS_STARTUP_SEQUENCE (seq));
@@ -327,10 +355,7 @@ meta_startup_sequence_complete (MetaStartupSequence *seq)
     return;
 
   priv->completed = TRUE;
-  klass = META_STARTUP_SEQUENCE_GET_CLASS (seq);
-
-  if (klass->complete)
-    klass->complete (seq);
+  g_signal_emit (seq, seq_signals[SEQ_COMPLETE], 0);
 }
 
 gboolean
@@ -399,12 +424,22 @@ meta_startup_sequence_get_wmclass (MetaStartupSequence *seq)
   return priv->wmclass;
 }
 
+static void
+on_sequence_completed (MetaStartupSequence     *seq,
+                       MetaStartupNotification *sn)
+{
+  meta_startup_notification_update_feedback (sn);
+  g_signal_emit (sn, sn_signals[CHANGED], 0, seq);
+}
+
 void
 meta_startup_notification_add_sequence (MetaStartupNotification *sn,
                                         MetaStartupSequence     *seq)
 {
   sn->startup_sequences = g_slist_prepend (sn->startup_sequences,
                                            g_object_ref (seq));
+  g_signal_connect (seq, "complete",
+                    G_CALLBACK (on_sequence_completed), sn);
 
   meta_startup_notification_ensure_timeout (sn);
   meta_startup_notification_update_feedback (sn);
@@ -425,10 +460,10 @@ collect_timed_out_foreach (void *element,
 
   meta_topic (META_DEBUG_STARTUP,
               "Sequence used %" G_GINT64_FORMAT " ms vs. %d max: %s\n",
-              elapsed, STARTUP_TIMEOUT,
+              elapsed, STARTUP_TIMEOUT_MS,
               meta_startup_sequence_get_id (sequence));
 
-  if (elapsed > STARTUP_TIMEOUT)
+  if (elapsed > STARTUP_TIMEOUT_MS)
     ctod->list = g_slist_prepend (ctod->list, sequence);
 }
 
@@ -440,7 +475,7 @@ startup_sequence_timeout (void *data)
   GSList *l;
 
   ctod.list = NULL;
-  ctod.now = g_get_monotonic_time ();
+  ctod.now = g_get_monotonic_time () / 1000;
   g_slist_foreach (sn->startup_sequences,
                    collect_timed_out_foreach,
                    &ctod);
@@ -494,6 +529,8 @@ meta_startup_notification_remove_sequence (MetaStartupNotification *sn,
   sn->startup_sequences = g_slist_remove (sn->startup_sequences, seq);
   meta_startup_notification_update_feedback (sn);
 
+  g_signal_handlers_disconnect_by_func (seq, on_sequence_completed, sn);
+
   if (sn->startup_sequences == NULL &&
       sn->startup_sequence_timeout != 0)
     {

src/meson.build

@@ -55,12 +55,6 @@ if have_libgudev
   ]
 endif
 
-if have_startup_notification
-  mutter_pkg_private_deps += [
-    libstartup_notification_dep,
-  ]
-endif
-
 if have_libwacom
   mutter_pkg_private_deps += [
     libwacom_dep,

src/wayland/meta-wayland-outputs.c

@@ -624,14 +624,14 @@ meta_xdg_output_manager_get_xdg_output (struct wl_client   *client,
                                             wl_resource_get_version (resource),
                                             id);
 
-  wl_resource_set_implementation (xdg_output_resource,
-                                  &meta_xdg_output_interface,
-                                  NULL, meta_xdg_output_destructor);
-
   wayland_output = wl_resource_get_user_data (output);
   if (!wayland_output)
     return;
 
+  wl_resource_set_implementation (xdg_output_resource,
+                                  &meta_xdg_output_interface,
+                                  wayland_output, meta_xdg_output_destructor);
+
   wayland_output->xdg_output_resources =
     g_list_prepend (wayland_output->xdg_output_resources, xdg_output_resource);
 

src/x11/meta-startup-notification-x11.c

@@ -26,266 +26,301 @@
 #include "meta/meta-x11-errors.h"
 #include "x11/meta-x11-display-private.h"
 
-#ifdef HAVE_STARTUP_NOTIFICATION
+#define MAX_MESSAGE_LENGTH 4096
+#define CLIENT_MESSAGE_DATA_LENGTH 20
 
 enum
 {
-  PROP_SEQ_X11_0,
-  PROP_SEQ_X11_SEQ,
-  N_SEQ_X11_PROPS
-};
-
-struct _MetaStartupSequenceX11
-{
-  MetaStartupSequence parent_instance;
-  SnStartupSequence *seq;
+  MESSAGE_TYPE_NEW,
+  MESSAGE_TYPE_REMOVE,
 };
 
 struct _MetaX11StartupNotification
 {
-  SnDisplay *sn_display;
-  SnMonitorContext *sn_context;
+  Atom atom_net_startup_info_begin;
+  Atom atom_net_startup_info;
+  GHashTable *messages;
+  MetaX11Display *x11_display;
 };
 
-static GParamSpec *seq_x11_props[N_SEQ_X11_PROPS];
-
-G_DEFINE_TYPE (MetaStartupSequenceX11,
-               meta_startup_sequence_x11,
-               META_TYPE_STARTUP_SEQUENCE)
-
-static void
-meta_startup_sequence_x11_complete (MetaStartupSequence *seq)
+typedef struct
 {
-  MetaStartupSequenceX11 *seq_x11;
+  Window xwindow;
+  GString *data;
+} StartupMessage;
 
-  seq_x11 = META_STARTUP_SEQUENCE_X11 (seq);
-  sn_startup_sequence_complete (seq_x11->seq);
+
+static StartupMessage *
+startup_message_new (Window window)
+{
+  StartupMessage *message;
+
+  message = g_new0 (StartupMessage, 1);
+  message->xwindow = window;
+  message->data = g_string_new (NULL);
+
+  return message;
 }
 
 static void
-meta_startup_sequence_x11_finalize (GObject *object)
+startup_message_free (StartupMessage *message)
 {
-  MetaStartupSequenceX11 *seq_x11;
-
-  seq_x11 = META_STARTUP_SEQUENCE_X11 (object);
-  sn_startup_sequence_unref (seq_x11->seq);
-
-  G_OBJECT_CLASS (meta_startup_sequence_x11_parent_class)->finalize (object);
+  g_string_free (message->data, TRUE);
+  g_free (message);
 }
 
 static void
-meta_startup_sequence_x11_set_property (GObject      *object,
-                                        guint         prop_id,
-                                        const GValue *value,
-                                        GParamSpec   *pspec)
+skip_whitespace (const gchar **str)
 {
-  MetaStartupSequenceX11 *seq_x11;
+  while ((*str)[0] == ' ')
+    (*str)++;
+}
 
-  seq_x11 = META_STARTUP_SEQUENCE_X11 (object);
+static gchar *
+parse_key (const gchar **str)
+{
+  const gchar *start = *str;
 
-  switch (prop_id)
+  while (*str[0] != '\0' && *str[0] != '=')
+    (*str)++;
+
+  if (start == *str)
+    return NULL;
+
+  return g_strndup (start, *str - start);
+}
+
+static gchar *
+parse_value (const gchar **str)
+{
+  const gchar *end;
+  gboolean escaped = FALSE, quoted = FALSE;
+  GString *value;
+
+  end = *str;
+  value = g_string_new (NULL);
+
+  while (end[0] != '\0')
     {
-    case PROP_SEQ_X11_SEQ:
-      seq_x11->seq = g_value_get_pointer (value);
-      sn_startup_sequence_ref (seq_x11->seq);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
+      if (escaped)
+        {
+          g_string_append_c (value, end[0]);
+          escaped = FALSE;
+        }
+      else
+        {
+          if (!quoted && end[0] == ' ')
+            break;
+          else if (end[0] == '"')
+            quoted = !quoted;
+          else if (end[0] == '\\')
+            escaped = TRUE;
+          else
+            g_string_append_c (value, end[0]);
+        }
 
-static void
-meta_startup_sequence_x11_get_property (GObject    *object,
-                                        guint       prop_id,
-                                        GValue     *value,
-                                        GParamSpec *pspec)
-{
-  MetaStartupSequenceX11 *seq_x11;
-
-  seq_x11 = META_STARTUP_SEQUENCE_X11 (object);
-
-  switch (prop_id)
-    {
-    case PROP_SEQ_X11_SEQ:
-      g_value_set_pointer (value, seq_x11->seq);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-meta_startup_sequence_x11_init (MetaStartupSequenceX11 *seq)
-{
-}
-
-static void
-meta_startup_sequence_x11_class_init (MetaStartupSequenceX11Class *klass)
-{
-  MetaStartupSequenceClass *seq_class;
-  GObjectClass *object_class;
-
-  seq_class = META_STARTUP_SEQUENCE_CLASS (klass);
-  seq_class->complete = meta_startup_sequence_x11_complete;
-
-  object_class = G_OBJECT_CLASS (klass);
-  object_class->finalize = meta_startup_sequence_x11_finalize;
-  object_class->set_property = meta_startup_sequence_x11_set_property;
-  object_class->get_property = meta_startup_sequence_x11_get_property;
-
-  seq_x11_props[PROP_SEQ_X11_SEQ] =
-    g_param_spec_pointer ("seq",
-                          "Sequence",
-                          "Sequence",
-                          G_PARAM_READWRITE |
-                          G_PARAM_CONSTRUCT_ONLY);
-
-  g_object_class_install_properties (object_class, N_SEQ_X11_PROPS,
-                                     seq_x11_props);
-}
-
-static MetaStartupSequence *
-meta_startup_sequence_x11_new (SnStartupSequence *seq)
-{
-  gint64 timestamp;
-
-  timestamp = sn_startup_sequence_get_timestamp (seq) * 1000;
-  return g_object_new (META_TYPE_STARTUP_SEQUENCE_X11,
-                       "id", sn_startup_sequence_get_id (seq),
-                       "icon-name", sn_startup_sequence_get_icon_name (seq),
-                       "application-id", sn_startup_sequence_get_application_id (seq),
-                       "wmclass", sn_startup_sequence_get_wmclass (seq),
-                       "name", sn_startup_sequence_get_name (seq),
-                       "workspace", sn_startup_sequence_get_workspace (seq),
-                       "timestamp", timestamp,
-                       "seq", seq,
-                       NULL);
-}
-
-static void
-sn_error_trap_push (SnDisplay *sn_display,
-                    Display   *xdisplay)
-{
-  MetaDisplay *display;
-
-  display = meta_display_for_x_display (xdisplay);
-  if (display != NULL)
-    meta_x11_error_trap_push (display->x11_display);
-}
-
-static void
-sn_error_trap_pop (SnDisplay *sn_display,
-                   Display   *xdisplay)
-{
-  MetaDisplay *display;
-
-  display = meta_display_for_x_display (xdisplay);
-  if (display != NULL)
-    meta_x11_error_trap_pop (display->x11_display);
-}
-
-static void
-meta_startup_notification_sn_event (SnMonitorEvent *event,
-                                    void           *user_data)
-{
-  MetaX11Display *x11_display = user_data;
-  MetaStartupNotification *sn = x11_display->display->startup_notification;
-  MetaStartupSequence *seq;
-  SnStartupSequence *sequence;
-
-  sequence = sn_monitor_event_get_startup_sequence (event);
-
-  sn_startup_sequence_ref (sequence);
-
-  switch (sn_monitor_event_get_type (event))
-    {
-    case SN_MONITOR_EVENT_INITIATED:
-      {
-        const char *wmclass;
-
-        wmclass = sn_startup_sequence_get_wmclass (sequence);
-
-        meta_topic (META_DEBUG_STARTUP,
-                    "Received startup initiated for %s wmclass %s\n",
-                    sn_startup_sequence_get_id (sequence),
-                    wmclass ? wmclass : "(unset)");
-
-        seq = meta_startup_sequence_x11_new (sequence);
-        meta_startup_notification_add_sequence (sn, seq);
-        g_object_unref (seq);
-      }
-      break;
-
-    case SN_MONITOR_EVENT_COMPLETED:
-      {
-        meta_topic (META_DEBUG_STARTUP,
-                    "Received startup completed for %s\n",
-                    sn_startup_sequence_get_id (sequence));
-
-        seq = meta_startup_notification_lookup_sequence (sn, sn_startup_sequence_get_id (sequence));
-        if (seq)
-          {
-            meta_startup_sequence_complete (seq);
-            meta_startup_notification_remove_sequence (sn, seq);
-          }
-      }
-      break;
-
-    case SN_MONITOR_EVENT_CHANGED:
-      meta_topic (META_DEBUG_STARTUP,
-                  "Received startup changed for %s\n",
-                  sn_startup_sequence_get_id (sequence));
-      break;
-
-    case SN_MONITOR_EVENT_CANCELED:
-      meta_topic (META_DEBUG_STARTUP,
-                  "Received startup canceled for %s\n",
-                  sn_startup_sequence_get_id (sequence));
-      break;
+      end++;
     }
 
-  sn_startup_sequence_unref (sequence);
+  *str = end;
+
+  if (value->len == 0)
+    {
+      g_string_free (value, TRUE);
+      return NULL;
+    }
+
+  return g_string_free (value, FALSE);
+}
+
+static gboolean
+startup_message_parse (StartupMessage  *message,
+                       int             *type,
+                       gchar          **id,
+                       GHashTable     **data)
+{
+  const gchar *str = message->data->str;
+
+  if (strncmp (str, "new:", 4) == 0)
+    {
+      *type = MESSAGE_TYPE_NEW;
+      str += 4;
+    }
+  else if (strncmp (str, "remove:", 7) == 0)
+    {
+      *type = MESSAGE_TYPE_REMOVE;
+      str += 7;
+    }
+  else
+    {
+      return FALSE;
+    }
+
+  *data = g_hash_table_new_full (g_str_hash,
+                                 g_str_equal,
+                                 g_free,
+                                 g_free);
+  while (str[0])
+    {
+      gchar *key, *value;
+
+      skip_whitespace (&str);
+      key = parse_key (&str);
+      if (!key)
+        break;
+
+      str++;
+      value = parse_value (&str);
+
+      if (!value)
+        {
+          g_free (key);
+          break;
+        }
+
+      g_hash_table_insert (*data, key, value);
+    }
+
+  *id = g_strdup (g_hash_table_lookup (*data, "ID"));
+
+  return TRUE;
+}
+
+static gboolean
+startup_message_add_data (StartupMessage *message,
+                          const gchar    *data)
+{
+  int len;
+
+  len = strnlen (data, CLIENT_MESSAGE_DATA_LENGTH);
+  g_string_append_len (message->data, data, len);
+
+  return (message->data->len > MAX_MESSAGE_LENGTH ||
+          len < CLIENT_MESSAGE_DATA_LENGTH);
 }
-#endif
 
 void
 meta_x11_startup_notification_init (MetaX11Display *x11_display)
 {
-#ifdef HAVE_STARTUP_NOTIFICATION
   MetaX11StartupNotification *x11_sn;
 
   x11_sn = g_new0 (MetaX11StartupNotification, 1);
-  x11_sn->sn_display = sn_display_new (x11_display->xdisplay,
-                                            sn_error_trap_push,
-                                            sn_error_trap_pop);
-  x11_sn->sn_context =
-    sn_monitor_context_new (x11_sn->sn_display,
-                            meta_x11_display_get_screen_number (x11_display),
-                            meta_startup_notification_sn_event,
-                            x11_display,
-                            NULL);
-
+  x11_sn->atom_net_startup_info_begin = XInternAtom (x11_display->xdisplay,
+                                                     "_NET_STARTUP_INFO_BEGIN",
+                                                     False);
+  x11_sn->atom_net_startup_info = XInternAtom (x11_display->xdisplay,
+                                               "_NET_STARTUP_INFO",
+                                               False);
+  x11_sn->messages = g_hash_table_new_full (NULL, NULL, NULL,
+                                            (GDestroyNotify) startup_message_free);
+  x11_sn->x11_display = x11_display;
   x11_display->startup_notification = x11_sn;
-#endif
 }
 
 void
 meta_x11_startup_notification_release (MetaX11Display *x11_display)
 {
-#ifdef HAVE_STARTUP_NOTIFICATION
   MetaX11StartupNotification *x11_sn = x11_display->startup_notification;
 
   x11_display->startup_notification = NULL;
 
   if (x11_sn)
     {
-      sn_monitor_context_unref (x11_sn->sn_context);
-      sn_display_unref (x11_sn->sn_display);
+      g_hash_table_unref (x11_sn->messages);
       g_free (x11_sn);
     }
-#endif
+}
+
+static void
+handle_message (MetaX11StartupNotification *x11_sn,
+                StartupMessage             *message)
+{
+  MetaStartupNotification *sn = x11_sn->x11_display->display->startup_notification;
+  MetaStartupSequence *seq;
+  GHashTable *data;
+  char *id;
+  int type;
+
+  if (message->data->len <= MAX_MESSAGE_LENGTH &&
+      g_utf8_validate (message->data->str, -1, NULL) &&
+      startup_message_parse (message, &type, &id, &data))
+    {
+      if (type == MESSAGE_TYPE_NEW)
+        {
+          uint64_t timestamp = 0;
+          int workspace = -1;
+
+          if (g_hash_table_contains (data, "DESKTOP"))
+            workspace = atoi (g_hash_table_lookup (data, "DESKTOP"));
+          if (g_hash_table_contains (data, "TIMESTAMP"))
+            timestamp = g_ascii_strtoull (g_hash_table_lookup (data, "TIMESTAMP"), NULL, 10);
+
+          seq = g_object_new (META_TYPE_STARTUP_SEQUENCE,
+                              "id", id,
+                              "icon-name", g_hash_table_lookup (data, "ICON_NAME"),
+                              "application-id", g_hash_table_lookup (data, "APPLICATION_ID"),
+                              "wmclass", g_hash_table_lookup (data, "WMCLASS"),
+                              "name", g_hash_table_lookup (data, "NAME"),
+                              "workspace", workspace,
+                              "timestamp", timestamp,
+                              NULL);
+
+          meta_topic (META_DEBUG_STARTUP,
+                      "Received startup initiated for %s wmclass %s\n",
+                      id, (gchar*) g_hash_table_lookup (data, "WMCLASS"));
+
+          meta_startup_notification_add_sequence (sn, seq);
+          g_object_unref (seq);
+        }
+      else if (type == MESSAGE_TYPE_REMOVE)
+        {
+          meta_topic (META_DEBUG_STARTUP,
+                      "Received startup completed for %s\n", id);
+          seq = meta_startup_notification_lookup_sequence (sn, id);
+
+          if (seq)
+            {
+              meta_startup_sequence_complete (seq);
+              meta_startup_notification_remove_sequence (sn, seq);
+            }
+        }
+
+      g_hash_table_unref (data);
+      g_free (id);
+    }
+
+  g_hash_table_remove (x11_sn->messages, GINT_TO_POINTER (message->xwindow));
+}
+
+static gboolean
+handle_startup_notification_event (MetaX11StartupNotification *x11_sn,
+                                   XClientMessageEvent        *client_event)
+{
+  StartupMessage *message;
+
+  if (client_event->message_type == x11_sn->atom_net_startup_info_begin)
+    {
+      message = startup_message_new (client_event->window);
+      g_hash_table_insert (x11_sn->messages,
+                           GINT_TO_POINTER (client_event->window),
+                           message);
+      if (startup_message_add_data (message, client_event->data.b))
+        handle_message (x11_sn, message);
+      return TRUE;
+    }
+  else if (client_event->message_type == x11_sn->atom_net_startup_info)
+    {
+      message = g_hash_table_lookup (x11_sn->messages,
+                                     GINT_TO_POINTER (client_event->window));
+      if (message)
+        {
+          if (startup_message_add_data (message, client_event->data.b))
+            handle_message (x11_sn, message);
+          return TRUE;
+        }
+    }
+
+  return FALSE;
 }
 
 gboolean
@@ -297,74 +332,8 @@ meta_x11_startup_notification_handle_xevent (MetaX11Display *x11_display,
   if (!x11_sn)
     return FALSE;
 
-  return sn_display_process_event (x11_sn->sn_display, xevent);
-}
-
-typedef void (* SetAppIdFunc) (SnLauncherContext *context,
-                               const char        *app_id);
-
-gchar *
-meta_x11_startup_notification_launch (MetaX11Display *x11_display,
-                                      GAppInfo       *app_info,
-                                      uint32_t        timestamp,
-                                      int             workspace)
-{
-  gchar *startup_id = NULL;
-#ifdef HAVE_STARTUP_NOTIFICATION
-  MetaX11StartupNotification *x11_sn = x11_display->startup_notification;
-  SnLauncherContext *sn_launcher;
-  int screen;
-
-  screen = meta_x11_display_get_screen_number (x11_display);
-  sn_launcher = sn_launcher_context_new (x11_sn->sn_display, screen);
-
-  sn_launcher_context_set_name (sn_launcher, g_app_info_get_name (app_info));
-  sn_launcher_context_set_workspace (sn_launcher, workspace);
-  sn_launcher_context_set_binary_name (sn_launcher,
-                                       g_app_info_get_executable (app_info));
-
-  if (G_IS_DESKTOP_APP_INFO (app_info))
-    {
-      const char *application_id;
-      SetAppIdFunc func = NULL;
-      GModule *self;
-
-      application_id =
-        g_desktop_app_info_get_filename (G_DESKTOP_APP_INFO (app_info));
-      self = g_module_open (NULL, G_MODULE_BIND_MASK);
-
-      /* This here is a terrible workaround to bypass a libsn bug that is not
-       * likely to get fixed at this point.
-       * sn_launcher_context_set_application_id is correctly defined in the
-       * sn-launcher.h file, but it's mistakenly called
-       * sn_launcher_set_application_id in the C file.
-       *
-       * We look up the symbol instead, but still prefer the correctly named
-       * function, if one were ever to be added.
-       */
-      if (!g_module_symbol (self, "sn_launcher_context_set_application_id",
-                            (gpointer *) &func))
-        {
-          g_module_symbol (self, "sn_launcher_set_application_id",
-                           (gpointer *) &func);
-        }
-
-      if (func)
-        func (sn_launcher, application_id);
-
-      g_module_close (self);
-    }
-
-  sn_launcher_context_initiate (sn_launcher,
-                                g_get_prgname (),
-                                g_app_info_get_name (app_info),
-                                timestamp);
-
-  startup_id = g_strdup (sn_launcher_context_get_startup_id (sn_launcher));
-
-  /* Fire and forget, we have a SnMonitor in addition */
-  sn_launcher_context_unref (sn_launcher);
-#endif /* HAVE_STARTUP_NOTIFICATION */
-
-  return startup_id;
+  if (xevent->xany.type != ClientMessage)
+    return FALSE;
+
+  return handle_startup_notification_event (x11_sn, &xevent->xclient);
 }

src/x11/meta-startup-notification-x11.h

@@ -36,9 +36,4 @@ void     meta_x11_startup_notification_release (MetaX11Display *x11_display);
 gboolean meta_x11_startup_notification_handle_xevent (MetaX11Display *x11_display,
                                                       XEvent         *xevent);
 
-gchar *  meta_x11_startup_notification_launch (MetaX11Display *x11_display,
-                                               GAppInfo       *app_info,
-                                               uint32_t        timestamp,
-                                               int             workspace);
-
 #endif /* META_X11_STARTUP_NOTIFICATION_H */