clutter: Keep depressed mods across keymap changes

Those are, evidently, depressed. Forgetting about those when the keymap changes does no good to them, nor the stuff we are typing.
wayland: Check if state and size changed before calling move_resize()
2018-04-26 20:50:36 +02:00 · 2018-04-25 23:33:41 -03:00 · 2018-04-25 21:55:05 -03:00 · 2018-04-25 21:55:05 -03:00 · 2018-04-25 20:25:43 +02:00 · 2018-04-25 17:22:24 +02:00
66 changed files with 1194 additions and 1165 deletions
--- a/22
+++ b/22
@@ -1,3 +1,25 @@
+3.29.1
+======
+* Fix various input-method regressions [Carlos, Olivier; #65, #74, #66, #112]
+* Fix wayland build on FreeBSD [Ting-Wei; #792280, #792717]
+* Fix swapped colors in screenshots (again) [Carlos; #72]
+* Allow building with elogind [Rasmus; !46]
+* Consider display rotation for cursor [Olivier; #85]
+* Fall back to non-modifier GBM surfaces [Daniel; #84]
+* Take inhibitors into account for monitoring idle [Bastien; #705942]
+* Misc. bug fixes [handsome-feng, Olivier, Mario, Jonas; !45, #83, #104,
+  gnome-shell#157, #130, #21]
+
+Contributors:
+  Jonas Ådahl, Olivier Fourdan, Carlos Garnacho, handsome-feng, Yussuf Khalil,
+  Ting-Wei Lan, Aleksandr Mezin, Alberts Muktupāvels,
+  Georges Basile Stavracas Neto, Bastien Nocera, Benjamin Otte,
+  Mario Sanchez Prada, Daniel Stone, Ray Strode, Rasmus Thomsen,
+  Marco Trevisan (Treviño), Daniel van Vugt
+
+Translators:
+  Emin Tufan Çetin [tr], Dušan Kazik [sk], Matej Urbančič [sl]
+
 3.28.0
 ======
 * Fix xdg-foreign regression [Carlos; #63]
--- a/clutter/clutter/cally/cally-util.c
+++ b/clutter/clutter/cally/cally-util.c
@@ -214,6 +214,8 @@ cally_util_simulate_snooper_install (void)
                    G_CALLBACK (cally_util_stage_added_cb), cally_key_snooper);
  g_signal_connect (G_OBJECT (stage_manager), "stage-removed",
                    G_CALLBACK (cally_util_stage_removed_cb), cally_key_snooper);
+
+  g_slist_free (stage_list);
 }

 static void
--- a/clutter/clutter/clutter-input-method.c
+++ b/clutter/clutter/clutter-input-method.c
@@ -353,6 +353,7 @@ clutter_input_method_notify_key_event (ClutterInputMethod *im,
      copy = clutter_event_copy (event);
      clutter_event_set_flags (copy, clutter_event_get_flags (event) |
                               CLUTTER_EVENT_FLAG_INPUT_METHOD);
+      clutter_event_set_source_device (copy, clutter_event_get_device (copy));
      clutter_event_put (copy);
      clutter_event_free (copy);
    }
--- a/clutter/clutter/clutter-text.c
+++ b/clutter/clutter/clutter-text.c
@@ -2830,6 +2830,10 @@ clutter_text_key_focus_in (ClutterActor *actor)
  if (method && priv->editable)
    {
      clutter_input_method_focus_in (method, priv->input_focus);
+      clutter_input_focus_set_content_purpose (priv->input_focus,
+					       priv->input_purpose);
+      clutter_input_focus_set_content_hints (priv->input_focus,
+					     priv->input_hints);
      update_cursor_location (CLUTTER_TEXT (actor));
    }

@@ -4511,6 +4515,27 @@ buffer_deleted_text (ClutterTextBuffer *buffer,
    }
 }

+static void
+clutter_text_queue_redraw_or_relayout (ClutterText *self)
+{
+  ClutterActor *actor = CLUTTER_ACTOR (self);
+  gfloat preferred_width;
+  gfloat preferred_height;
+
+  clutter_text_dirty_cache (self);
+
+  /* we're using our private implementations here to avoid the caching done by ClutterActor */
+  clutter_text_get_preferred_width (actor, -1, NULL, &preferred_width);
+  clutter_text_get_preferred_height (actor, preferred_width, NULL, &preferred_height);
+
+  if (clutter_actor_has_allocation (actor) &&
+      (fabsf (preferred_width - clutter_actor_get_width (actor)) > 0.001 ||
+       fabsf (preferred_height - clutter_actor_get_height (actor)) > 0.001))
+    clutter_actor_queue_relayout (actor);
+  else
+    clutter_text_queue_redraw (actor);
+}
+
 static void
 buffer_notify_text (ClutterTextBuffer *buffer,
                    GParamSpec        *spec,
@@ -4518,9 +4543,7 @@ buffer_notify_text (ClutterTextBuffer *buffer,
 {
  g_object_freeze_notify (G_OBJECT (self));

-  clutter_text_dirty_cache (self);
-
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+  clutter_text_queue_redraw_or_relayout (self);

  g_signal_emit (self, text_signals[TEXT_CHANGED], 0);
  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_TEXT]);
@@ -4872,8 +4895,7 @@ clutter_text_set_cursor_visible (ClutterText *self,
    {
      priv->cursor_visible = cursor_visible;

-      clutter_text_dirty_cache (self);
-      clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+      clutter_text_queue_redraw_or_relayout (self);

      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CURSOR_VISIBLE]);
    }
@@ -5774,9 +5796,7 @@ clutter_text_set_line_alignment (ClutterText    *self,
    {
      priv->alignment = alignment;

-      clutter_text_dirty_cache (self);
-
-      clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+      clutter_text_queue_redraw_or_relayout (self);

      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_LINE_ALIGNMENT]);
    }
@@ -5831,9 +5851,7 @@ clutter_text_set_use_markup (ClutterText *self,
  if (setting)
    clutter_text_set_markup_internal (self, text);

-  clutter_text_dirty_cache (self);
-
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+  clutter_text_queue_redraw_or_relayout (self);
 }

 /**
@@ -5880,9 +5898,7 @@ clutter_text_set_justify (ClutterText *self,
    {
      priv->justify = justify;

-      clutter_text_dirty_cache (self);
-
-      clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+      clutter_text_queue_redraw_or_relayout (self);

      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_JUSTIFY]);
    }
@@ -6449,8 +6465,7 @@ clutter_text_set_preedit_string (ClutterText   *self,
      priv->preedit_set = TRUE;
    }

-  clutter_text_dirty_cache (self);
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+  clutter_text_queue_redraw_or_relayout (self);
 }


@@ -6512,7 +6527,9 @@ clutter_text_set_input_hints (ClutterText                  *self,
  g_return_if_fail (CLUTTER_IS_TEXT (self));

  self->priv->input_hints = hints;
-  clutter_input_focus_set_content_hints (self->priv->input_focus, hints);
+
+  if (clutter_input_focus_is_focused (self->priv->input_focus))
+    clutter_input_focus_set_content_hints (self->priv->input_focus, hints);
  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_INPUT_HINTS]);
 }

@@ -6531,7 +6548,9 @@ clutter_text_set_input_purpose (ClutterText                *self,
  g_return_if_fail (CLUTTER_IS_TEXT (self));

  self->priv->input_purpose = purpose;
-  clutter_input_focus_set_content_purpose (self->priv->input_focus, purpose);
+
+  if (clutter_input_focus_is_focused (self->priv->input_focus))
+    clutter_input_focus_set_content_purpose (self->priv->input_focus, purpose);
  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_INPUT_PURPOSE]);
 }

--- a/clutter/clutter/evdev/clutter-device-manager-evdev.c
+++ b/clutter/clutter/evdev/clutter-device-manager-evdev.c
@@ -2276,6 +2276,7 @@ clutter_evdev_update_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
  ClutterSeatEvdev *seat;
  xkb_mod_mask_t latched_mods;
  xkb_mod_mask_t locked_mods;
+  xkb_mod_mask_t depressed_mods;

  priv = manager_evdev->priv;

@@ -2283,6 +2284,8 @@ clutter_evdev_update_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
    {
      seat = iter->data;

+      depressed_mods = xkb_state_serialize_mods (seat->xkb,
+                                                 XKB_STATE_MODS_DEPRESSED);
      latched_mods = xkb_state_serialize_mods (seat->xkb,
                                               XKB_STATE_MODS_LATCHED);
      locked_mods = xkb_state_serialize_mods (seat->xkb,
@@ -2291,7 +2294,7 @@ clutter_evdev_update_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
      seat->xkb = xkb_state_new (priv->keymap);

      xkb_state_update_mask (seat->xkb,
-                             0, /* depressed */
+                             depressed_mods,
                             latched_mods,
                             locked_mods,
                             0, 0, seat->layout_idx);
--- a/clutter/clutter/evdev/clutter-input-device-evdev.c
+++ b/clutter/clutter/evdev/clutter-input-device-evdev.c
@@ -433,6 +433,8 @@ key_event_is_modifier (ClutterEvent *event)
    case XKB_KEY_Super_R:
    case XKB_KEY_Hyper_L:
    case XKB_KEY_Hyper_R:
+    case XKB_KEY_Caps_Lock:
+    case XKB_KEY_Shift_Lock:
      return TRUE;
    default:
      return FALSE;
@@ -584,6 +586,12 @@ handle_stickykeys_press (ClutterEvent            *event,
    }

  depressed_mods = xkb_state_serialize_mods (seat->xkb, XKB_STATE_MODS_DEPRESSED);
+  /* Ignore the lock modifier mask, that one cannot be sticky, yet the
+   * CAPS_LOCK key itself counts as a modifier as it might be remapped
+   * to some other modifier which can be sticky.
+   */
+  depressed_mods &= ~CLUTTER_LOCK_MASK;
+
  new_latched_mask = device->stickykeys_latched_mask;
  new_locked_mask = device->stickykeys_locked_mask;

@@ -1122,6 +1130,10 @@ clutter_input_device_evdev_process_kbd_a11y_event (ClutterEvent               *e
 {
  ClutterInputDeviceEvdev *device_evdev = CLUTTER_INPUT_DEVICE_EVDEV (device);

+  /* Ignore key events injected from IM */
+  if (event->key.flags & CLUTTER_EVENT_FLAG_INPUT_METHOD)
+    goto emit_event;
+
  if (!device_evdev->a11y_flags & CLUTTER_A11Y_KEYBOARD_ENABLED)
    goto emit_event;

--- a/cogl/cogl/Makefile.am
+++ b/cogl/cogl/Makefile.am
@@ -452,7 +452,7 @@ libmutter_cogl_@LIBMUTTER_API_VERSION@_la_LDFLAGS = \
 	-avoid-version \
 	-export-dynamic \
 	-rpath $(mutterlibdir) \
-	-export-symbols-regex "^(cogl|_cogl_debug_flags|_cogl_atlas_new|_cogl_atlas_add_reorganize_callback|_cogl_atlas_reserve_space|_cogl_callback|_cogl_util_get_eye_planes_for_screen_poly|_cogl_atlas_texture_remove_reorganize_callback|_cogl_atlas_texture_add_reorganize_callback|_cogl_texture_get_format|_cogl_texture_foreach_sub_texture_in_region|_cogl_texture_set_region|_cogl_profile_trace_message|_cogl_context_get_default|_cogl_framebuffer_get_stencil_bits|_cogl_clip_stack_push_rectangle|_cogl_framebuffer_get_modelview_stack|_cogl_object_default_unref|_cogl_pipeline_foreach_layer_internal|_cogl_clip_stack_push_primitive|_cogl_buffer_unmap_for_fill_or_fallback|_cogl_framebuffer_draw_primitive|_cogl_debug_instances|_cogl_framebuffer_get_projection_stack|_cogl_pipeline_layer_get_texture|_cogl_buffer_map_for_fill_or_fallback|_cogl_texture_can_hardware_repeat|_cogl_pipeline_prune_to_n_layers|_cogl_primitive_draw|test_|unit_test_|_cogl_winsys_glx_get_vtable|_cogl_winsys_egl_xlib_get_vtable|_cogl_winsys_egl_get_vtable|_cogl_closure_disconnect|_cogl_onscreen_notify_complete|_cogl_onscreen_notify_frame_sync|_cogl_winsys_egl_renderer_connect_common|_cogl_winsys_error_quark|_cogl_set_error|_cogl_poll_renderer_add_fd|_cogl_poll_renderer_add_idle|_cogl_framebuffer_winsys_update_size|_cogl_winsys_egl_make_current|_cogl_pixel_format_get_bytes_per_pixel).*"
+	-export-symbols-regex "^(cogl|_cogl_debug_flags|_cogl_atlas_new|_cogl_atlas_add_reorganize_callback|_cogl_atlas_reserve_space|_cogl_callback|_cogl_util_get_eye_planes_for_screen_poly|_cogl_atlas_texture_remove_reorganize_callback|_cogl_atlas_texture_add_reorganize_callback|_cogl_texture_get_format|_cogl_texture_foreach_sub_texture_in_region|_cogl_texture_set_region|_cogl_profile_trace_message|_cogl_context_get_default|_cogl_framebuffer_get_stencil_bits|_cogl_clip_stack_push_rectangle|_cogl_framebuffer_get_modelview_stack|_cogl_object_default_unref|_cogl_pipeline_foreach_layer_internal|_cogl_clip_stack_push_primitive|_cogl_buffer_unmap_for_fill_or_fallback|_cogl_framebuffer_draw_primitive|_cogl_debug_instances|_cogl_framebuffer_get_projection_stack|_cogl_pipeline_layer_get_texture|_cogl_buffer_map_for_fill_or_fallback|_cogl_texture_can_hardware_repeat|_cogl_pipeline_prune_to_n_layers|_cogl_primitive_draw|test_|unit_test_|_cogl_winsys_glx_get_vtable|_cogl_winsys_egl_xlib_get_vtable|_cogl_winsys_egl_get_vtable|_cogl_closure_disconnect|_cogl_onscreen_notify_complete|_cogl_onscreen_notify_frame_sync|_cogl_winsys_egl_renderer_connect_common|_cogl_winsys_error_quark|_cogl_set_error|_cogl_poll_renderer_add_fd|_cogl_poll_renderer_add_idle|_cogl_framebuffer_winsys_update_size|_cogl_winsys_egl_make_current|_cogl_winsys_egl_ensure_current|_cogl_pixel_format_get_bytes_per_pixel).*"

 libmutter_cogl_@LIBMUTTER_API_VERSION@_la_SOURCES = $(cogl_sources_c)
 nodist_libmutter_cogl_@LIBMUTTER_API_VERSION@_la_SOURCES = $(BUILT_SOURCES)
--- a/cogl/cogl/cogl-object.c
+++ b/cogl/cogl/cogl-object.c
@@ -109,7 +109,11 @@ _cogl_object_default_unref (void *object)
 void
 cogl_object_unref (void *obj)
 {
-  void (* unref_func) (void *) = ((CoglObject *) obj)->klass->virt_unref;
+  void (* unref_func) (void *);
+
+  _COGL_RETURN_IF_FAIL (obj != NULL);
+
+  unref_func = ((CoglObject *) obj)->klass->virt_unref;
  unref_func (obj);
 }

--- a/cogl/cogl/driver/gl/cogl-framebuffer-gl.c
+++ b/cogl/cogl/driver/gl/cogl-framebuffer-gl.c
@@ -1412,22 +1412,12 @@ _cogl_framebuffer_gl_read_pixels_into_bitmap (CoglFramebuffer *framebuffer,
  if (!cogl_is_offscreen (framebuffer))
    y = framebuffer_height - y - height;

-  required_format = ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                                            format,
-                                                            &gl_intformat,
-                                                            &gl_format,
-                                                            &gl_type);
-#if HAVE_COGL_GL
-  /* As we are reading pixels, we want to consider the bitmap according to
-   * its real pixel format, not the swizzled channels we pretend face to the
-   * pipeline.
-   */
-  if ((ctx->driver == COGL_DRIVER_GL || ctx->driver == COGL_DRIVER_GL3) &&
-      (format == COGL_PIXEL_FORMAT_BGRA_8888 ||
-       format == COGL_PIXEL_FORMAT_BGRA_8888_PRE) &&
-      _cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE))
-    gl_format = GL_BGRA;
-#endif
+  required_format = ctx->driver_vtable->pixel_format_to_gl_with_target (ctx,
+                                                                        framebuffer->internal_format,
+                                                                        format,
+                                                                        &gl_intformat,
+                                                                        &gl_format,
+                                                                        &gl_type);

  /* NB: All offscreen rendering is done upside down so there is no need
   * to flip in this case... */
--- a/cogl/cogl/winsys/cogl-winsys-egl-private.h
+++ b/cogl/cogl/winsys/cogl-winsys-egl-private.h
@@ -181,6 +181,9 @@ _cogl_winsys_egl_make_current (CoglDisplay *display,
                               EGLSurface read,
                               EGLContext context);

+EGLBoolean
+_cogl_winsys_egl_ensure_current (CoglDisplay *display);
+
 #ifdef EGL_KHR_image_base
 EGLImageKHR
 _cogl_egl_create_image (CoglContext *ctx,
--- a/cogl/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/cogl/winsys/cogl-winsys-egl.c
@@ -309,6 +309,18 @@ _cogl_winsys_egl_make_current (CoglDisplay *display,
  return ret;
 }

+EGLBoolean
+_cogl_winsys_egl_ensure_current (CoglDisplay *display)
+{
+  CoglDisplayEGL *egl_display = display->winsys;
+  CoglRendererEGL *egl_renderer = display->renderer->winsys;
+
+  return eglMakeCurrent (egl_renderer->edpy,
+                         egl_display->current_draw_surface,
+                         egl_display->current_read_surface,
+                         egl_display->current_context);
+}
+
 static void
 cleanup_context (CoglDisplay *display)
 {
--- a/configure.ac
+++ b/configure.ac
@@ -1,8 +1,8 @@
 AC_PREREQ(2.62)

 m4_define([mutter_major_version], [3])
-m4_define([mutter_minor_version], [28])
-m4_define([mutter_micro_version], [0])
+m4_define([mutter_minor_version], [29])
+m4_define([mutter_micro_version], [1])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -262,7 +262,22 @@ AC_SUBST(XWAYLAND_PATH)

 PKG_CHECK_MODULES(MUTTER, $MUTTER_PC_MODULES)

-MUTTER_NATIVE_BACKEND_MODULES="libdrm >= 2.4.83 libsystemd libinput >= 1.4 gudev-1.0 gbm >= 17.1"
+PKG_CHECK_MODULES(ELOGIND, [libelogind], [have_elogind=yes], [have_elogind=no])
+
+if test x$have_elogind = xyes; then
+     logind_provider="libelogind"
+fi
+
+PKG_CHECK_MODULES(SYSTEMD, [libsystemd], [have_systemd=yes], [have_systemd=no])
+
+if test x$have_systemd = xyes; then
+     logind_provider="libsystemd"
+fi
+
+AS_IF([test -z "$logind_provider"],
+  AC_MSG_ERROR([Could not find either systemd or elogind as logind provider])])
+
+MUTTER_NATIVE_BACKEND_MODULES="libdrm $logind_provider libinput >= 1.4 gudev-1.0 gbm >= 10.3"

 AC_ARG_ENABLE(native-backend,
  AS_HELP_STRING([--disable-native-backend], [disable mutter native (KMS) backend]),,
--- a/po/sl.po
+++ b/po/sl.po
@@ -10,8 +10,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: mutter master\n"
 "Report-Msgid-Bugs-To: https://gitlab.gnome.org/GNOME/mutter/issues\n"
-"POT-Creation-Date: 2018-03-05 19:32+0000\n"
-"PO-Revision-Date: 2018-03-06 22:02+0100\n"
+"POT-Creation-Date: 2018-04-03 20:43+0000\n"
+"PO-Revision-Date: 2018-04-09 20:28+0200\n"
 "Last-Translator: Matej Urbančič <mateju@svn.gnome.org>\n"
 "Language-Team: Slovenian GNOME Translation Team <gnome-si@googlegroups.com>\n"
 "Language: sl_SI\n"
@@ -21,7 +21,7 @@ msgstr ""
 "Plural-Forms: nplurals=4; plural=(n%100==1 ? 1 : n%100==2 ? 2 : n%100==3 || n"
 "%100==4 ? 3 : 0);\n"
 "X-Poedit-SourceCharset: utf-8\n"
-"X-Generator: Poedit 2.0.4\n"
+"X-Generator: Poedit 2.0.6\n"

 #: data/50-mutter-navigation.xml:6
 msgid "Navigation"
@@ -481,7 +481,7 @@ msgstr "Ponovno omogoči tipkovne bližnjice"

 #: data/org.gnome.mutter.wayland.gschema.xml.in:64
 msgid "Allow grabs with Xwayland"
-msgstr ""
+msgstr "Dovoli zajemanje z XWayland"

 #: data/org.gnome.mutter.wayland.gschema.xml.in:65
 msgid ""
@@ -491,10 +491,14 @@ msgid ""
 "window or be among the applications white-listed in key “xwayland-grab-"
 "access-rules”."
 msgstr ""
+"Upošteva zajeme s tipkovnico, ki jih sprožijo programi X11, zagnani v okolju "
+"Xwayland. Če naj se programski zajem upošteva, mora odjemalec ali poslati "
+"specifično sporočilo X11 na korensko okno ali pa mora biti zaveden na "
+"seznamu programov v ključu »xwayland-garb-access-rules«."

 #: data/org.gnome.mutter.wayland.gschema.xml.in:77
 msgid "Xwayland applications allowed to issue keyboard grabs"
-msgstr ""
+msgstr "Program XWayland ima dovoljenje za zajemanje s tipkovnico"

 #: data/org.gnome.mutter.wayland.gschema.xml.in:78
 msgid ""
@@ -509,6 +513,15 @@ msgid ""
 "using the specific keyboard shortcut defined by the keybinding key “restore-"
 "shortcuts”."
 msgstr ""
+"Seznam imen ali razredov virov oken X11, ki lahko sprožijo zajeme v okolju "
+"Xwayland. Ime oziroma razred vira podanega okna X11 je mogoče pridobiti z "
+"ukazom »xprop WM_CLASS«. Uporaba pomožnih znakov » * « in » ? « je podprta. "
+"Vrednosti, ki se začnejo z znakom » ! « so uvrščeni na črni seznam. Ta "
+"seznam je obravnavan prednostno pred belim seznamom in prekliče zajeme na "
+"seznamu sistema. Privzeti seznam vključuje ključ: "
+"»@XWAYLAND_GRAB_DEFAULT_ACCESS_RULES@« Uporabniki lahko prekinejo obstoječi "
+"zajem z uporabo posebne tipkovne bližnjice, določene s tipkovnim ključem "
+"»restore-shortcuts«."

 #. TRANSLATORS: This string refers to a button that switches between
 #. * different modes.
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -161,6 +161,7 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES =	\
 	backends/meta-renderer-view.h		\
 	backends/edid-parse.c			\
 	backends/edid.h				\
+	backends/gsm-inhibitor-flag.h		\
 	backends/x11/meta-backend-x11.c			\
 	backends/x11/meta-backend-x11.h			\
 	backends/x11/meta-barrier-x11.c			\
@@ -183,8 +184,6 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES =	\
 	backends/x11/nested/meta-cursor-renderer-x11-nested.h		\
 	backends/x11/nested/meta-renderer-x11-nested.c	\
 	backends/x11/nested/meta-renderer-x11-nested.h	\
-	backends/x11/meta-idle-monitor-xsync.c		\
-	backends/x11/meta-idle-monitor-xsync.h		\
 	backends/x11/meta-input-settings-x11.c		\
 	backends/x11/meta-input-settings-x11.h		\
 	backends/x11/meta-monitor-manager-xrandr.c	\
@@ -487,8 +486,6 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES +=		\
 	backends/native/meta-default-modes.h		\
 	backends/native/meta-gpu-kms.c			\
 	backends/native/meta-gpu-kms.h			\
-	backends/native/meta-idle-monitor-native.c	\
-	backends/native/meta-idle-monitor-native.h	\
 	backends/native/meta-input-settings-native.c	\
 	backends/native/meta-input-settings-native.h	\
 	backends/native/meta-monitor-manager-kms.c	\
--- a/src/backends/gsm-inhibitor-flag.h
+++ b/src/backends/gsm-inhibitor-flag.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2008 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GSM_INHIBITOR_FLAG_H__
+#define __GSM_INHIBITOR_FLAG_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef enum {
+        GSM_INHIBITOR_FLAG_LOGOUT      = 1 << 0,
+        GSM_INHIBITOR_FLAG_SWITCH_USER = 1 << 1,
+        GSM_INHIBITOR_FLAG_SUSPEND     = 1 << 2,
+        GSM_INHIBITOR_FLAG_IDLE        = 1 << 3,
+        GSM_INHIBITOR_FLAG_AUTOMOUNT   = 1 << 4
+} GsmInhibitorFlag;
+
+G_END_DECLS
+
+#endif /* __GSM_INHIBITOR_FLAG_H__ */
--- a/src/backends/meta-backend-private.h
+++ b/src/backends/meta-backend-private.h
@@ -59,8 +59,6 @@ struct _MetaBackendClass

  void (* post_init) (MetaBackend *backend);

-  MetaIdleMonitor * (* create_idle_monitor) (MetaBackend *backend,
-                                             int          device_id);
  MetaMonitorManager * (* create_monitor_manager) (MetaBackend *backend,
                                                   GError     **error);
  MetaCursorRenderer * (* create_cursor_renderer) (MetaBackend *backend);
--- a/src/backends/meta-backend.c
+++ b/src/backends/meta-backend.c
@@ -110,6 +110,11 @@ struct _MetaBackendPrivate

  MetaPointerConstraint *client_pointer_constraint;
  MetaDnd *dnd;
+
+  UpClient *up_client;
+  guint sleep_signal_id;
+  GCancellable *cancellable;
+  GDBusConnection *system_bus;
 };
 typedef struct _MetaBackendPrivate MetaBackendPrivate;

@@ -136,6 +141,13 @@ meta_backend_finalize (GObject *object)
  g_clear_object (&priv->dbus_session_watcher);
 #endif

+  g_object_unref (priv->up_client);
+  if (priv->sleep_signal_id)
+    g_dbus_connection_signal_unsubscribe (priv->system_bus, priv->sleep_signal_id);
+  g_cancellable_cancel (priv->cancellable);
+  g_clear_object (&priv->cancellable);
+  g_clear_object (&priv->system_bus);
+
  if (priv->device_update_idle_id)
    g_source_remove (priv->device_update_idle_id);

@@ -158,7 +170,7 @@ meta_backend_sync_screen_size (MetaBackend *backend)
 }

 static void
-center_pointer (MetaBackend *backend)
+reset_pointer_position (MetaBackend *backend)
 {
  MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
  MetaMonitorManager *monitor_manager = priv->monitor_manager;
@@ -167,9 +179,11 @@ center_pointer (MetaBackend *backend)
  primary =
    meta_monitor_manager_get_primary_logical_monitor (monitor_manager);

+  /* Move the pointer out of the way to avoid hovering over reactive
+   * elements (e.g. users list at login) causing undesired behaviour. */
  meta_backend_warp_pointer (backend,
-                             primary->rect.x + primary->rect.width / 2,
-                             primary->rect.y + primary->rect.height / 2);
+                             primary->rect.x + primary->rect.width * 0.9,
+                             primary->rect.y + primary->rect.height * 0.9);
 }

 void
@@ -192,7 +206,7 @@ meta_backend_monitors_changed (MetaBackend *backend)
           !priv->is_pointer_position_initialized) &&
          !meta_monitor_manager_is_headless (monitor_manager))
        {
-          center_pointer (backend);
+          reset_pointer_position (backend);
          priv->is_pointer_position_initialized = TRUE;
        }
    }
@@ -222,7 +236,9 @@ static MetaIdleMonitor *
 meta_backend_create_idle_monitor (MetaBackend *backend,
                                  int          device_id)
 {
-  return META_BACKEND_GET_CLASS (backend)->create_idle_monitor (backend, device_id);
+  return g_object_new (META_TYPE_IDLE_MONITOR,
+                       "device-id", device_id,
+                       NULL);
 }

 static void
@@ -465,7 +481,7 @@ meta_backend_real_post_init (MetaBackend *backend)

  if (!meta_monitor_manager_is_headless (priv->monitor_manager))
    {
-      center_pointer (backend);
+      reset_pointer_position (backend);
      priv->is_pointer_position_initialized = TRUE;
    }
 }
@@ -590,6 +606,61 @@ meta_backend_create_renderer (MetaBackend *backend,
  return META_BACKEND_GET_CLASS (backend)->create_renderer (backend, error);
 }

+static void
+lid_is_closed_changed_cb (UpClient   *client,
+                          GParamSpec *pspec,
+                          gpointer    user_data)
+{
+  if (up_client_get_lid_is_closed (client))
+    return;
+
+  meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
+}
+
+static void
+prepare_for_sleep_cb (GDBusConnection *connection,
+                      const gchar     *sender_name,
+                      const gchar     *object_path,
+                      const gchar     *interface_name,
+                      const gchar     *signal_name,
+                      GVariant        *parameters,
+                      gpointer         user_data)
+{
+  gboolean suspending;
+
+  g_variant_get (parameters, "(b)", &suspending);
+  if (suspending)
+    return;
+  meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
+}
+
+static void
+system_bus_gotten_cb (GObject      *object,
+                      GAsyncResult *res,
+                      gpointer      user_data)
+{
+  MetaBackendPrivate *priv;
+  GDBusConnection *bus;
+
+  bus = g_bus_get_finish (res, NULL);
+  if (!bus)
+    return;
+
+  priv = meta_backend_get_instance_private (user_data);
+  priv->system_bus = bus;
+  priv->sleep_signal_id =
+    g_dbus_connection_signal_subscribe (priv->system_bus,
+                                        "org.freedesktop.login1",
+                                        "org.freedesktop.login1.Manager",
+                                        "PrepareForSleep",
+                                        "/org/freedesktop/login1",
+                                        NULL,
+                                        G_DBUS_SIGNAL_FLAGS_NONE,
+                                        prepare_for_sleep_cb,
+                                        NULL,
+                                        NULL);
+}
+
 static gboolean
 meta_backend_initable_init (GInitable     *initable,
                            GCancellable  *cancellable,
@@ -619,6 +690,16 @@ meta_backend_initable_init (GInitable     *initable,

  priv->dnd = g_object_new (META_TYPE_DND, NULL);

+  priv->up_client = up_client_new ();
+  g_signal_connect (priv->up_client, "notify::lid-is-closed",
+                    G_CALLBACK (lid_is_closed_changed_cb), NULL);
+
+  priv->cancellable = g_cancellable_new ();
+  g_bus_get (G_BUS_TYPE_SYSTEM,
+             priv->cancellable,
+             system_bus_gotten_cb,
+             backend);
+
  return TRUE;
 }

--- a/src/backends/meta-cursor-renderer.c
+++ b/src/backends/meta-cursor-renderer.c
@@ -264,6 +264,18 @@ meta_cursor_renderer_set_position (MetaCursorRenderer *renderer,
  update_cursor (renderer, priv->displayed_cursor);
 }

+ClutterPoint
+meta_cursor_renderer_get_position (MetaCursorRenderer *renderer)
+{
+  MetaCursorRendererPrivate *priv =
+    meta_cursor_renderer_get_instance_private (renderer);
+
+  return (ClutterPoint) {
+    .x = priv->current_x,
+    .y = priv->current_y
+  };
+}
+
 MetaCursorSprite *
 meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer)
 {
--- a/src/backends/meta-cursor-renderer.h
+++ b/src/backends/meta-cursor-renderer.h
@@ -62,6 +62,7 @@ void meta_cursor_renderer_set_cursor (MetaCursorRenderer *renderer,
 void meta_cursor_renderer_set_position (MetaCursorRenderer *renderer,
                                        float               x,
                                        float               y);
+ClutterPoint meta_cursor_renderer_get_position (MetaCursorRenderer *renderer);
 void meta_cursor_renderer_force_update (MetaCursorRenderer *renderer);

 MetaCursorSprite * meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer);
--- a/src/backends/meta-idle-monitor-dbus.c
+++ b/src/backends/meta-idle-monitor-dbus.c
@@ -24,6 +24,7 @@

 #include "meta-idle-monitor-dbus.h"
 #include <meta/meta-idle-monitor.h>
+#include <backends/meta-idle-monitor-private.h>
 #include "meta-dbus-idle-monitor.h"

 #include <clutter/clutter.h>
@@ -43,6 +44,26 @@ handle_get_idletime (MetaDBusIdleMonitor   *skeleton,
  return TRUE;
 }

+static gboolean
+handle_reset_idletime (MetaDBusIdleMonitor   *skeleton,
+                       GDBusMethodInvocation *invocation,
+                       MetaIdleMonitor       *monitor)
+{
+  if (!g_getenv ("MUTTER_DEBUG_RESET_IDLETIME"))
+    {
+      g_dbus_method_invocation_return_error_literal (invocation,
+                                                     G_DBUS_ERROR,
+                                                     G_DBUS_ERROR_UNKNOWN_METHOD,
+                                                     "No such method");
+      return FALSE;
+    }
+
+  meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
+  meta_dbus_idle_monitor_complete_reset_idletime (skeleton, invocation);
+
+  return TRUE;
+}
+
 typedef struct {
  MetaDBusIdleMonitor *dbus_monitor;
  MetaIdleMonitor *monitor;
@@ -173,6 +194,8 @@ create_monitor_skeleton (GDBusObjectManagerServer *manager,
                           G_CALLBACK (handle_add_user_active_watch), monitor, 0);
  g_signal_connect_object (skeleton, "handle-remove-watch",
                           G_CALLBACK (handle_remove_watch), monitor, 0);
+  g_signal_connect_object (skeleton, "handle-reset-idletime",
+                           G_CALLBACK (handle_reset_idletime), monitor, 0);
  g_signal_connect_object (skeleton, "handle-get-idletime",
                           G_CALLBACK (handle_get_idletime), monitor, 0);

--- a/src/backends/meta-idle-monitor-private.h
+++ b/src/backends/meta-idle-monitor-private.h
@@ -26,9 +26,6 @@
 #include <meta/meta-idle-monitor.h>
 #include "display-private.h"

-#include <X11/Xlib.h>
-#include <X11/extensions/sync.h>
-
 typedef struct
 {
  MetaIdleMonitor          *monitor;
@@ -38,28 +35,26 @@ typedef struct
  GDestroyNotify            notify;
  guint64                   timeout_msec;
  int                       idle_source_id;
+  GSource                  *timeout_source;
 } MetaIdleMonitorWatch;

 struct _MetaIdleMonitor
 {
  GObject parent_instance;

+  GDBusProxy *session_proxy;
+  gboolean inhibited;
  GHashTable *watches;
  int device_id;
+  guint64 last_event_time;
 };

 struct _MetaIdleMonitorClass
 {
  GObjectClass parent_class;
-
-  gint64 (*get_idletime) (MetaIdleMonitor *monitor);
-  MetaIdleMonitorWatch * (*make_watch) (MetaIdleMonitor           *monitor,
-                                        guint64                    timeout_msec,
-                                        MetaIdleMonitorWatchFunc   callback,
-                                        gpointer                   user_data,
-                                        GDestroyNotify             notify);
 };

 void _meta_idle_monitor_watch_fire (MetaIdleMonitorWatch *watch);
+void meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor);

 #endif /* META_IDLE_MONITOR_PRIVATE_H */
--- a/src/backends/meta-idle-monitor.c
+++ b/src/backends/meta-idle-monitor.c
@@ -36,6 +36,7 @@
 #include <meta/util.h>
 #include <meta/main.h>
 #include <meta/meta-idle-monitor.h>
+#include "gsm-inhibitor-flag.h"
 #include "meta-idle-monitor-private.h"
 #include "meta-idle-monitor-dbus.h"
 #include "meta-backend-private.h"
@@ -87,6 +88,7 @@ meta_idle_monitor_dispose (GObject *object)
  MetaIdleMonitor *monitor = META_IDLE_MONITOR (object);

  g_clear_pointer (&monitor->watches, g_hash_table_destroy);
+  g_clear_object (&monitor->session_proxy);

  G_OBJECT_CLASS (meta_idle_monitor_parent_class)->dispose (object);
 }
@@ -151,9 +153,117 @@ meta_idle_monitor_class_init (MetaIdleMonitorClass *klass)
  g_object_class_install_property (object_class, PROP_DEVICE_ID, obj_props[PROP_DEVICE_ID]);
 }

+static void
+free_watch (gpointer data)
+{
+  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) data;
+  MetaIdleMonitor *monitor = watch->monitor;
+
+  g_object_ref (monitor);
+
+  if (watch->idle_source_id)
+    {
+      g_source_remove (watch->idle_source_id);
+      watch->idle_source_id = 0;
+    }
+
+  if (watch->notify != NULL)
+    watch->notify (watch->user_data);
+
+  if (watch->timeout_source != NULL)
+    g_source_destroy (watch->timeout_source);
+
+  g_object_unref (monitor);
+  g_slice_free (MetaIdleMonitorWatch, watch);
+}
+
+static void
+update_inhibited_watch (gpointer key,
+                        gpointer value,
+                        gpointer user_data)
+{
+  MetaIdleMonitor *monitor = user_data;
+  MetaIdleMonitorWatch *watch = value;
+
+  if (!watch->timeout_source)
+    return;
+
+  if (monitor->inhibited)
+    {
+      g_source_set_ready_time (watch->timeout_source, -1);
+    }
+  else
+    {
+      g_source_set_ready_time (watch->timeout_source,
+                               monitor->last_event_time +
+                               watch->timeout_msec * 1000);
+    }
+}
+
+static void
+update_inhibited (MetaIdleMonitor *monitor,
+                  gboolean         inhibited)
+{
+  if (inhibited == monitor->inhibited)
+    return;
+
+  g_hash_table_foreach (monitor->watches,
+                        update_inhibited_watch,
+                        monitor);
+}
+
+static void
+meta_idle_monitor_inhibited_actions_changed (GDBusProxy  *session,
+                                             GVariant    *changed,
+                                             char       **invalidated,
+                                             gpointer     user_data)
+{
+  MetaIdleMonitor *monitor = user_data;
+  GVariant *v;
+
+  v = g_variant_lookup_value (changed, "InhibitedActions", G_VARIANT_TYPE_UINT32);
+  if (v)
+    {
+      gboolean inhibited;
+
+      inhibited = g_variant_get_uint32 (v) & GSM_INHIBITOR_FLAG_IDLE;
+      g_variant_unref (v);
+
+      if (!inhibited)
+        monitor->last_event_time = g_get_monotonic_time ();
+      update_inhibited (monitor, inhibited);
+    }
+}
+
 static void
 meta_idle_monitor_init (MetaIdleMonitor *monitor)
 {
+  GVariant *v;
+
+  monitor->watches = g_hash_table_new_full (NULL, NULL, NULL, free_watch);
+  monitor->last_event_time = g_get_monotonic_time ();
+
+  /* Monitor inhibitors */
+  monitor->session_proxy =
+    g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                   G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
+                                   NULL,
+                                   "org.gnome.SessionManager",
+                                   "/org/gnome/SessionManager",
+                                   "org.gnome.SessionManager",
+                                   NULL,
+                                   NULL);
+  if (!monitor->session_proxy)
+    return;
+
+  g_signal_connect (monitor->session_proxy, "g-properties-changed",
+                    G_CALLBACK (meta_idle_monitor_inhibited_actions_changed),
+                    monitor);
+
+  v = g_dbus_proxy_get_cached_property (monitor->session_proxy,
+                                        "InhibitedActions");
+  monitor->inhibited = g_variant_get_uint32 (v) & GSM_INHIBITOR_FLAG_IDLE;
+  g_variant_unref (v);
 }

 /**
@@ -185,6 +295,36 @@ meta_idle_monitor_get_for_device (int device_id)
  return meta_backend_get_idle_monitor (backend, device_id);
 }

+static guint32
+get_next_watch_serial (void)
+{
+  static guint32 serial = 0;
+
+  g_atomic_int_inc (&serial);
+
+  return serial;
+}
+
+static gboolean
+idle_monitor_dispatch_timeout (GSource     *source,
+                               GSourceFunc  callback,
+                               gpointer     user_data)
+{
+  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) user_data;
+
+  _meta_idle_monitor_watch_fire (watch);
+  g_source_set_ready_time (watch->timeout_source, -1);
+
+  return TRUE;
+}
+
+static GSourceFuncs idle_monitor_source_funcs = {
+  .prepare = NULL,
+  .check = NULL,
+  .dispatch = idle_monitor_dispatch_timeout,
+  .finalize = NULL,
+};
+
 static MetaIdleMonitorWatch *
 make_watch (MetaIdleMonitor           *monitor,
            guint64                    timeout_msec,
@@ -194,11 +334,32 @@ make_watch (MetaIdleMonitor           *monitor,
 {
  MetaIdleMonitorWatch *watch;

-  watch = META_IDLE_MONITOR_GET_CLASS (monitor)->make_watch (monitor,
-                                                             timeout_msec,
-                                                             callback,
-                                                             user_data,
-                                                             notify);
+  watch = g_slice_new0 (MetaIdleMonitorWatch);
+
+  watch->monitor = monitor;
+  watch->id = get_next_watch_serial ();
+  watch->callback = callback;
+  watch->user_data = user_data;
+  watch->notify = notify;
+  watch->timeout_msec = timeout_msec;
+
+  if (timeout_msec != 0)
+    {
+      GSource *source = g_source_new (&idle_monitor_source_funcs,
+                                      sizeof (GSource));
+
+      g_source_set_callback (source, NULL, watch, NULL);
+      if (!monitor->inhibited)
+        {
+          g_source_set_ready_time (source,
+                                   monitor->last_event_time +
+                                   timeout_msec * 1000);
+        }
+      g_source_attach (source, NULL);
+      g_source_unref (source);
+
+      watch->timeout_source = source;
+    }

  g_hash_table_insert (monitor->watches,
                       GUINT_TO_POINTER (watch->id),
@@ -314,5 +475,39 @@ meta_idle_monitor_remove_watch (MetaIdleMonitor *monitor,
 gint64
 meta_idle_monitor_get_idletime (MetaIdleMonitor *monitor)
 {
-  return META_IDLE_MONITOR_GET_CLASS (monitor)->get_idletime (monitor);
+  return (g_get_monotonic_time () - monitor->last_event_time) / 1000;
+}
+
+void
+meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor)
+{
+  GList *node, *watch_ids;
+
+  monitor->last_event_time = g_get_monotonic_time ();
+
+  watch_ids = g_hash_table_get_keys (monitor->watches);
+
+  for (node = watch_ids; node != NULL; node = node->next)
+    {
+      guint watch_id = GPOINTER_TO_UINT (node->data);
+      MetaIdleMonitorWatch *watch;
+
+      watch = g_hash_table_lookup (monitor->watches,
+                                   GUINT_TO_POINTER (watch_id));
+      if (!watch)
+        continue;
+
+      if (watch->timeout_msec == 0)
+        {
+          _meta_idle_monitor_watch_fire ((MetaIdleMonitorWatch *) watch);
+        }
+      else
+        {
+          g_source_set_ready_time (watch->timeout_source,
+                                   monitor->last_event_time +
+                                   watch->timeout_msec * 1000);
+        }
+    }
+
+  g_list_free (watch_ids);
 }
--- a/src/backends/meta-input-settings.c
+++ b/src/backends/meta-input-settings.c
@@ -1088,7 +1088,7 @@ meta_input_settings_changed_cb (GSettings  *settings,
        update_device_natural_scroll (input_settings, NULL);
      else if (strcmp (key, "tap-to-click") == 0)
        update_touchpad_tap_enabled (input_settings, NULL);
-      else if (strcmp (key, "tap-and_drag") == 0)
+      else if (strcmp (key, "tap-and-drag") == 0)
        update_touchpad_tap_and_drag_enabled (input_settings, NULL);
      else if (strcmp(key, "disable-while-typing") == 0)
        update_touchpad_disable_while_typing (input_settings, NULL);
--- a/src/backends/meta-monitor-manager.c
+++ b/src/backends/meta-monitor-manager.c
@@ -89,6 +89,9 @@ static gboolean
 meta_monitor_manager_is_config_complete (MetaMonitorManager *manager,
                                         MetaMonitorsConfig *config);

+static MetaMonitor *
+meta_monitor_manager_get_active_monitor (MetaMonitorManager *manager);
+
 MetaBackend *
 meta_monitor_manager_get_backend (MetaMonitorManager *manager)
 {
@@ -198,13 +201,17 @@ calculate_monitor_scale (MetaMonitorManager *manager,
 static float
 derive_calculated_global_scale (MetaMonitorManager *manager)
 {
-  MetaMonitor *primary_monitor;
+  MetaMonitor *monitor = NULL;

-  primary_monitor = meta_monitor_manager_get_primary_monitor (manager);
-  if (!primary_monitor)
+  monitor = meta_monitor_manager_get_primary_monitor (manager);
+
+  if (!monitor || !meta_monitor_is_active (monitor))
+    monitor = meta_monitor_manager_get_active_monitor (manager);
+
+  if (!monitor)
    return 1.0;

-  return calculate_monitor_scale (manager, primary_monitor);
+  return calculate_monitor_scale (manager, monitor);
 }

 static float
@@ -578,8 +585,6 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
                                                       &error))
        {
          g_clear_object (&config);
-          g_warning ("Failed to use linear monitor configuration: %s",
-                     error->message);
          g_clear_error (&error);
        }
      else
@@ -597,8 +602,6 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
                                                       &error))
        {
          g_clear_object (&config);
-          g_warning ("Failed to use fallback monitor configuration: %s",
-                 error->message);
          g_clear_error (&error);
        }
      else
@@ -1032,7 +1035,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
                             NULL /* properties */);
    }

-  for (l = combined_outputs; l; l = l->next)
+  for (l = combined_outputs, i = 0; l; l = l->next, i++)
    {
      MetaOutput *output = l->data;
      GVariantBuilder crtcs, modes, clones, properties;
@@ -2382,6 +2385,12 @@ meta_monitor_manager_get_laptop_panel (MetaMonitorManager *manager)
  return find_monitor (manager, meta_monitor_is_laptop_panel);
 }

+static MetaMonitor *
+meta_monitor_manager_get_active_monitor (MetaMonitorManager *manager)
+{
+  return find_monitor (manager, meta_monitor_is_active);
+}
+
 MetaMonitor *
 meta_monitor_manager_get_monitor_from_connector (MetaMonitorManager *manager,
                                                 const char         *connector)
--- a/src/backends/meta-screen-cast-stream-src.c
+++ b/src/backends/meta-screen-cast-stream-src.c
@@ -360,7 +360,7 @@ create_pipewire_stream (MetaScreenCastStreamSrc  *src,
                         PW_DIRECTION_OUTPUT,
                         NULL,
                         PW_STREAM_FLAG_NONE,
-                         params, G_N_ELEMENTS (&params)) != 0)
+                         params, G_N_ELEMENTS (params)) != 0)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                   "Could not connect");
--- a/src/backends/meta-settings-private.h
+++ b/src/backends/meta-settings-private.h
@@ -33,6 +33,7 @@ typedef enum _MetaExperimentalFeature
  META_EXPERIMENTAL_FEATURE_SCALE_MONITOR_FRAMEBUFFER = (1 << 0),
  META_EXPERIMENTAL_FEATURE_SCREEN_CAST = (1 << 1),
  META_EXPERIMENTAL_FEATURE_REMOTE_DESKTOP  = (1 << 2),
+  META_EXPERIMENTAL_FEATURE_KMS_MODIFIERS  = (1 << 3),
 } MetaExperimentalFeature;

 #define META_TYPE_SETTINGS (meta_settings_get_type ())
--- a/src/backends/meta-settings.c
+++ b/src/backends/meta-settings.c
@@ -267,6 +267,8 @@ experimental_features_handler (GVariant *features_variant,
        features |= META_EXPERIMENTAL_FEATURE_SCREEN_CAST;
      else if (g_str_equal (feature, "remote-desktop"))
        features |= META_EXPERIMENTAL_FEATURE_REMOTE_DESKTOP;
+      else if (g_str_equal (feature, "kms-modifiers"))
+        features |= META_EXPERIMENTAL_FEATURE_KMS_MODIFIERS;
      else
        g_info ("Unknown experimental feature '%s'\n", feature);
    }
--- a/src/backends/native/meta-backend-native.c
+++ b/src/backends/native/meta-backend-native.c
@@ -35,11 +35,11 @@
 #include "clutter/evdev/clutter-evdev.h"
 #include "meta-barrier-native.h"
 #include "meta-border.h"
-#include "meta-idle-monitor-native.h"
 #include "meta-monitor-manager-kms.h"
 #include "meta-cursor-renderer-native.h"
 #include "meta-launcher.h"
 #include "backends/meta-cursor-tracker-private.h"
+#include "backends/meta-idle-monitor-private.h"
 #include "backends/meta-logical-monitor.h"
 #include "backends/meta-monitor-manager-private.h"
 #include "backends/meta-pointer-constraint.h"
@@ -60,10 +60,6 @@ struct _MetaBackendNativePrivate
 {
  MetaLauncher *launcher;
  MetaBarrierManagerNative *barrier_manager;
-  UpClient *up_client;
-  guint sleep_signal_id;
-  GCancellable *cancellable;
-  GDBusConnection *system_bus;
 };
 typedef struct _MetaBackendNativePrivate MetaBackendNativePrivate;

@@ -85,69 +81,9 @@ meta_backend_native_finalize (GObject *object)

  meta_launcher_free (priv->launcher);

-  g_object_unref (priv->up_client);
-  if (priv->sleep_signal_id)
-    g_dbus_connection_signal_unsubscribe (priv->system_bus, priv->sleep_signal_id);
-  g_cancellable_cancel (priv->cancellable);
-  g_clear_object (&priv->cancellable);
-  g_clear_object (&priv->system_bus);
-
  G_OBJECT_CLASS (meta_backend_native_parent_class)->finalize (object);
 }

-static void
-prepare_for_sleep_cb (GDBusConnection *connection,
-                      const gchar     *sender_name,
-                      const gchar     *object_path,
-                      const gchar     *interface_name,
-                      const gchar     *signal_name,
-                      GVariant        *parameters,
-                      gpointer         user_data)
-{
-  gboolean suspending;
-  g_variant_get (parameters, "(b)", &suspending);
-  if (suspending)
-    return;
-  meta_idle_monitor_native_reset_idletime (meta_idle_monitor_get_core ());
-}
-
-static void
-system_bus_gotten_cb (GObject      *object,
-                      GAsyncResult *res,
-                      gpointer      user_data)
-{
-  MetaBackendNativePrivate *priv;
-  GDBusConnection *bus;
-
-  bus = g_bus_get_finish (res, NULL);
-  if (!bus)
-    return;
-
-  priv = meta_backend_native_get_instance_private (META_BACKEND_NATIVE (user_data));
-  priv->system_bus = bus;
-  priv->sleep_signal_id = g_dbus_connection_signal_subscribe (priv->system_bus,
-                                                              "org.freedesktop.login1",
-                                                              "org.freedesktop.login1.Manager",
-                                                              "PrepareForSleep",
-                                                              "/org/freedesktop/login1",
-                                                              NULL,
-                                                              G_DBUS_SIGNAL_FLAGS_NONE,
-                                                              prepare_for_sleep_cb,
-                                                              NULL,
-                                                              NULL);
-}
-
-static void
-lid_is_closed_changed_cb (UpClient   *client,
-                          GParamSpec *pspec,
-                          gpointer    user_data)
-{
-  if (up_client_get_lid_is_closed (client))
-    return;
-
-  meta_idle_monitor_native_reset_idletime (meta_idle_monitor_get_core ());
-}
-
 static void
 constrain_to_barriers (ClutterInputDevice *device,
                       guint32             time,
@@ -398,15 +334,6 @@ meta_backend_native_post_init (MetaBackend *backend)
                                            meta_backend_get_monitor_manager (backend));
 }

-static MetaIdleMonitor *
-meta_backend_native_create_idle_monitor (MetaBackend *backend,
-                                         int          device_id)
-{
-  return g_object_new (META_TYPE_IDLE_MONITOR_NATIVE,
-                       "device-id", device_id,
-                       NULL);
-}
-
 static MetaMonitorManager *
 meta_backend_native_create_monitor_manager (MetaBackend *backend,
                                            GError     **error)
@@ -604,7 +531,6 @@ meta_backend_native_class_init (MetaBackendNativeClass *klass)

  backend_class->post_init = meta_backend_native_post_init;

-  backend_class->create_idle_monitor = meta_backend_native_create_idle_monitor;
  backend_class->create_monitor_manager = meta_backend_native_create_monitor_manager;
  backend_class->create_cursor_renderer = meta_backend_native_create_cursor_renderer;
  backend_class->create_renderer = meta_backend_native_create_renderer;
@@ -637,16 +563,6 @@ meta_backend_native_init (MetaBackendNative *native)
    }

  priv->barrier_manager = meta_barrier_manager_native_new ();
-
-  priv->up_client = up_client_new ();
-  g_signal_connect (priv->up_client, "notify::lid-is-closed",
-                    G_CALLBACK (lid_is_closed_changed_cb), NULL);
-
-  priv->cancellable = g_cancellable_new ();
-  g_bus_get (G_BUS_TYPE_SYSTEM,
-             priv->cancellable,
-             system_bus_gotten_cb,
-             native);
 }

 MetaLauncher *
@@ -747,5 +663,5 @@ void meta_backend_native_resume (MetaBackendNative *native)
  meta_cursor_renderer_native_force_update (cursor_renderer_native);

  idle_monitor = meta_backend_get_idle_monitor (backend, 0);
-  meta_idle_monitor_native_reset_idletime (idle_monitor);
+  meta_idle_monitor_reset_idletime (idle_monitor);
 }
--- a/src/backends/native/meta-cursor-renderer-native.c
+++ b/src/backends/native/meta-cursor-renderer-native.c
@@ -291,9 +291,11 @@ update_monitor_crtc_cursor (MetaMonitor         *monitor,
    data->in_cursor_renderer_native;
  MetaCursorRendererNativePrivate *priv =
    meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
+  MetaMonitorTransform transform;
  ClutterRect scaled_crtc_rect;
  float scale;
  int crtc_x, crtc_y;
+  int crtc_width, crtc_height;

  if (meta_is_stage_views_scaled ())
    scale = meta_logical_monitor_get_scale (data->in_logical_monitor);
@@ -305,14 +307,26 @@ update_monitor_crtc_cursor (MetaMonitor         *monitor,
                                   META_MONITOR_TRANSFORM_NORMAL,
                                   &crtc_x, &crtc_y);

+  transform = meta_logical_monitor_get_transform (data->in_logical_monitor);
+  if (meta_monitor_transform_is_rotated (transform))
+    {
+      crtc_width = monitor_crtc_mode->crtc_mode->height;
+      crtc_height = monitor_crtc_mode->crtc_mode->width;
+    }
+  else
+    {
+      crtc_width = monitor_crtc_mode->crtc_mode->width;
+      crtc_height = monitor_crtc_mode->crtc_mode->height;
+    }
+
  scaled_crtc_rect = (ClutterRect) {
    .origin = {
      .x = crtc_x / scale,
      .y = crtc_y / scale
    },
    .size = {
-      .width = monitor_crtc_mode->crtc_mode->width / scale,
-      .height = monitor_crtc_mode->crtc_mode->height / scale
+      .width = crtc_width / scale,
+      .height = crtc_height / scale
    },
  };

--- a/src/backends/native/meta-gpu-kms.c
+++ b/src/backends/native/meta-gpu-kms.c
@@ -778,7 +778,7 @@ meta_gpu_kms_new (MetaMonitorManagerKms  *monitor_manager_kms,

  kms_fd = meta_launcher_open_restricted (launcher, kms_file_path, error);
  if (kms_fd == -1)
-    return FALSE;
+    return NULL;

  gpu_kms = g_object_new (META_TYPE_GPU_KMS,
                          "monitor-manager", monitor_manager_kms,
--- a/src/backends/native/meta-idle-monitor-native.c
+++ b/src/backends/native/meta-idle-monitor-native.c
@@ -1,200 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright 2013 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- *
- * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
- *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
- */
-
-#include "config.h"
-
-#include "meta-idle-monitor-native.h"
-#include "meta-idle-monitor-private.h"
-
-#include <meta/util.h>
-#include "display-private.h"
-
-#include <string.h>
-
-struct _MetaIdleMonitorNative
-{
-  MetaIdleMonitor parent;
-
-  guint64 last_event_time;
-};
-
-struct _MetaIdleMonitorNativeClass
-{
-  MetaIdleMonitorClass parent_class;
-};
-
-typedef struct {
-  MetaIdleMonitorWatch base;
-
-  GSource *timeout_source;
-} MetaIdleMonitorWatchNative;
-
-G_DEFINE_TYPE (MetaIdleMonitorNative, meta_idle_monitor_native, META_TYPE_IDLE_MONITOR)
-
-static gint64
-meta_idle_monitor_native_get_idletime (MetaIdleMonitor *monitor)
-{
-  MetaIdleMonitorNative *monitor_native = META_IDLE_MONITOR_NATIVE (monitor);
-
-  return (g_get_monotonic_time () - monitor_native->last_event_time) / 1000;
-}
-
-static guint32
-get_next_watch_serial (void)
-{
-  static guint32 serial = 0;
-  g_atomic_int_inc (&serial);
-  return serial;
-}
-
-static gboolean
-native_dispatch_timeout (GSource     *source,
-                         GSourceFunc  callback,
-                         gpointer     user_data)
-{
-  MetaIdleMonitorWatchNative *watch_native = user_data;
-  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) watch_native;
-
-  _meta_idle_monitor_watch_fire (watch);
-  g_source_set_ready_time (watch_native->timeout_source, -1);
-  return TRUE;
-}
-
-static GSourceFuncs native_source_funcs = {
-  NULL, /* prepare */
-  NULL, /* check */
-  native_dispatch_timeout,
-  NULL, /* finalize */
-};
-
-static void
-free_watch (gpointer data)
-{
-  MetaIdleMonitorWatchNative *watch_native = data;
-  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) watch_native;
-  MetaIdleMonitor *monitor = watch->monitor;
-
-  g_object_ref (monitor);
-
-  if (watch->idle_source_id)
-    {
-      g_source_remove (watch->idle_source_id);
-      watch->idle_source_id = 0;
-    }
-
-  if (watch->notify != NULL)
-    watch->notify (watch->user_data);
-
-  if (watch_native->timeout_source != NULL)
-    g_source_destroy (watch_native->timeout_source);
-
-  g_object_unref (monitor);
-  g_slice_free (MetaIdleMonitorWatchNative, watch_native);
-}
-
-static MetaIdleMonitorWatch *
-meta_idle_monitor_native_make_watch (MetaIdleMonitor           *monitor,
-                                     guint64                    timeout_msec,
-                                     MetaIdleMonitorWatchFunc   callback,
-                                     gpointer                   user_data,
-                                     GDestroyNotify             notify)
-{
-  MetaIdleMonitorWatchNative *watch_native;
-  MetaIdleMonitorWatch *watch;
-  MetaIdleMonitorNative *monitor_native = META_IDLE_MONITOR_NATIVE (monitor);
-
-  watch_native = g_slice_new0 (MetaIdleMonitorWatchNative);
-  watch = (MetaIdleMonitorWatch *) watch_native;
-
-  watch->monitor = monitor;
-  watch->id = get_next_watch_serial ();
-  watch->callback = callback;
-  watch->user_data = user_data;
-  watch->notify = notify;
-  watch->timeout_msec = timeout_msec;
-
-  if (timeout_msec != 0)
-    {
-      GSource *source = g_source_new (&native_source_funcs, sizeof (GSource));
-
-      g_source_set_callback (source, NULL, watch, NULL);
-      g_source_set_ready_time (source, monitor_native->last_event_time + timeout_msec * 1000);
-      g_source_attach (source, NULL);
-      g_source_unref (source);
-
-      watch_native->timeout_source = source;
-    }
-
-  return watch;
-}
-
-static void
-meta_idle_monitor_native_class_init (MetaIdleMonitorNativeClass *klass)
-{
-  MetaIdleMonitorClass *idle_monitor_class = META_IDLE_MONITOR_CLASS (klass);
-
-  idle_monitor_class->get_idletime = meta_idle_monitor_native_get_idletime;
-  idle_monitor_class->make_watch = meta_idle_monitor_native_make_watch;
-}
-
-static void
-meta_idle_monitor_native_init (MetaIdleMonitorNative *monitor_native)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (monitor_native);
-
-  monitor->watches = g_hash_table_new_full (NULL, NULL, NULL, free_watch);
-  monitor_native->last_event_time = g_get_monotonic_time ();
-}
-
-void
-meta_idle_monitor_native_reset_idletime (MetaIdleMonitor *monitor)
-{
-  MetaIdleMonitorNative *monitor_native = META_IDLE_MONITOR_NATIVE (monitor);
-  GList *node, *watch_ids;
-
-  monitor_native->last_event_time = g_get_monotonic_time ();
-
-  watch_ids = g_hash_table_get_keys (monitor->watches);
-
-  for (node = watch_ids; node != NULL; node = node->next)
-    {
-      guint watch_id = GPOINTER_TO_UINT (node->data);
-      MetaIdleMonitorWatchNative *watch;
-
-      watch = g_hash_table_lookup (monitor->watches, GUINT_TO_POINTER (watch_id));
-      if (!watch)
-        continue;
-
-      if (watch->base.timeout_msec == 0)
-        {
-          _meta_idle_monitor_watch_fire ((MetaIdleMonitorWatch *) watch);
-        }
-      else
-        {
-          g_source_set_ready_time (watch->timeout_source,
-                                   monitor_native->last_event_time +
-                                   watch->base.timeout_msec * 1000);
-        }
-    }
-
-  g_list_free (watch_ids);
-}
--- a/src/backends/native/meta-idle-monitor-native.h
+++ b/src/backends/native/meta-idle-monitor-native.h
@@ -1,43 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright 2013 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- *
- * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
- *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
- */
-
-#ifndef META_IDLE_MONITOR_NATIVE_H
-#define META_IDLE_MONITOR_NATIVE_H
-
-#include <glib-object.h>
-#include <meta/meta-idle-monitor.h>
-
-#define META_TYPE_IDLE_MONITOR_NATIVE            (meta_idle_monitor_native_get_type ())
-#define META_IDLE_MONITOR_NATIVE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_IDLE_MONITOR_NATIVE, MetaIdleMonitorNative))
-#define META_IDLE_MONITOR_NATIVE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_IDLE_MONITOR_NATIVE, MetaIdleMonitorNativeClass))
-#define META_IS_IDLE_MONITOR_NATIVE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_IDLE_MONITOR_NATIVE))
-#define META_IS_IDLE_MONITOR_NATIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_IDLE_MONITOR_NATIVE))
-#define META_IDLE_MONITOR_NATIVE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_IDLE_MONITOR_NATIVE, MetaIdleMonitorNativeClass))
-
-typedef struct _MetaIdleMonitorNative        MetaIdleMonitorNative;
-typedef struct _MetaIdleMonitorNativeClass   MetaIdleMonitorNativeClass;
-
-GType meta_idle_monitor_native_get_type (void);
-
-void meta_idle_monitor_native_reset_idletime (MetaIdleMonitor *monitor);
-
-#endif /* META_IDLE_MONITOR_NATIVE_H */
--- a/src/backends/native/meta-launcher.c
+++ b/src/backends/native/meta-launcher.c
@@ -44,7 +44,6 @@
 #include "backends/meta-backend-private.h"
 #include "backends/native/meta-backend-native.h"
 #include "meta-cursor-renderer-native.h"
-#include "meta-idle-monitor-native.h"
 #include "meta-renderer-native.h"

 struct _MetaLauncher
--- a/src/backends/native/meta-monitor-manager-kms.c
+++ b/src/backends/native/meta-monitor-manager-kms.c
@@ -674,7 +674,7 @@ meta_monitor_manager_kms_initable_init (GInitable    *initable,
  gpu_paths = get_gpu_paths (manager_kms, GPU_TYPE_SECONDARY, primary_gpu_path);
  for (l = gpu_paths; l; l = l->next)
    {
-      GError *secondary_error = NULL;
+      g_autoptr (GError) secondary_error = NULL;
      char *gpu_path = l->data;
      MetaGpuKms *gpu_kms;

@@ -683,7 +683,7 @@ meta_monitor_manager_kms_initable_init (GInitable    *initable,
        {
          g_warning ("Failed to open secondary gpu '%s': %s",
                     gpu_path, secondary_error->message);
-          g_error_free (secondary_error);
+          continue;
        }

      meta_monitor_manager_add_gpu (META_MONITOR_MANAGER (manager_kms),
--- a/src/backends/native/meta-renderer-native.c
+++ b/src/backends/native/meta-renderer-native.c
@@ -193,6 +193,8 @@ struct _MetaRendererNative
  MetaMonitorManagerKms *monitor_manager_kms;
  MetaGles3 *gles3;

+  gboolean use_modifiers;
+
  GHashTable *gpu_datas;

  CoglClosure *swap_notify_idle;
@@ -1586,6 +1588,7 @@ gbm_get_next_fb_id (MetaGpuKms         *gpu_kms,
                    struct gbm_bo     **out_next_bo,
                    uint32_t           *out_next_fb_id)
 {
+  MetaRendererNative *renderer_native = meta_renderer_native_from_gpu (gpu_kms);
  struct gbm_bo *next_bo;
  uint32_t next_fb_id;
  int kms_fd;
@@ -1608,7 +1611,8 @@ gbm_get_next_fb_id (MetaGpuKms         *gpu_kms,

  kms_fd = meta_gpu_kms_get_fd (gpu_kms);

-  if (modifiers[0] != DRM_FORMAT_MOD_INVALID)
+  if (renderer_native->use_modifiers &&
+      modifiers[0] != DRM_FORMAT_MOD_INVALID)
    {
      if (drmModeAddFB2WithModifiers (kms_fd,
                                      gbm_bo_get_width (next_bo),
@@ -1854,18 +1858,18 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
  frame_info = g_queue_peek_tail (&onscreen->pending_frame_infos);
  frame_info->global_frame_counter = renderer_native->frame_counter;

-  /*
-   * Wait for the flip callback before continuing, as we might have started the
-   * animation earlier due to the animation being driven by some other monitor.
-   */
-  wait_for_pending_flips (onscreen);
-
  update_secondary_gpu_state_pre_swap_buffers (onscreen);

  parent_vtable->onscreen_swap_buffers_with_damage (onscreen,
                                                    rectangles,
                                                    n_rectangles);

+  /*
+   * Wait for the flip callback before continuing, as we might have started the
+   * animation earlier due to the animation being driven by some other monitor.
+   */
+  wait_for_pending_flips (onscreen);
+
  renderer_gpu_data = meta_renderer_native_get_gpu_data (renderer_native,
                                                         render_gpu);
  switch (renderer_gpu_data->mode)
@@ -1907,12 +1911,7 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
   * context.
   */
  if (egl_context_changed)
-    {
-      _cogl_winsys_egl_make_current (cogl_display,
-                                     EGL_NO_SURFACE,
-                                     EGL_NO_SURFACE,
-                                     EGL_NO_CONTEXT);
-    }
+    _cogl_winsys_egl_ensure_current (cogl_display);
 }

 static gboolean
@@ -1996,7 +1995,7 @@ meta_renderer_native_create_surface_gbm (CoglOnscreen        *onscreen,
  CoglRenderer *cogl_renderer = cogl_display->renderer;
  CoglRendererEGL *cogl_renderer_egl = cogl_renderer->winsys;
  MetaRendererNativeGpuData *renderer_gpu_data = cogl_renderer_egl->platform;
-  struct gbm_surface *new_gbm_surface;
+  struct gbm_surface *new_gbm_surface = NULL;
  EGLNativeWindowType egl_native_window;
  EGLSurface new_egl_surface;
  uint32_t format = GBM_FORMAT_XRGB8888;
@@ -2006,7 +2005,10 @@ meta_renderer_native_create_surface_gbm (CoglOnscreen        *onscreen,
    meta_renderer_native_get_gpu_data (renderer_native,
                                       onscreen_native->render_gpu);

-  modifiers = get_supported_modifiers (onscreen, format);
+  if (renderer_native->use_modifiers)
+    modifiers = get_supported_modifiers (onscreen, format);
+  else
+    modifiers = NULL;

  if (modifiers)
    {
@@ -2017,7 +2019,8 @@ meta_renderer_native_create_surface_gbm (CoglOnscreen        *onscreen,
                                           modifiers->len);
      g_array_free (modifiers, TRUE);
    }
-  else
+
+  if (!new_gbm_surface)
    {
      uint32_t flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;

@@ -3389,6 +3392,22 @@ meta_renderer_native_finalize (GObject *object)
  G_OBJECT_CLASS (meta_renderer_native_parent_class)->finalize (object);
 }

+static void
+meta_renderer_native_constructed (GObject *object)
+{
+  MetaRendererNative *renderer_native = META_RENDERER_NATIVE (object);
+  MetaMonitorManager *monitor_manager =
+    META_MONITOR_MANAGER (renderer_native->monitor_manager_kms);
+  MetaBackend *backend = meta_monitor_manager_get_backend (monitor_manager);
+  MetaSettings *settings = meta_backend_get_settings (backend);
+
+  if (meta_settings_is_experimental_feature_enabled (
+        settings, META_EXPERIMENTAL_FEATURE_KMS_MODIFIERS))
+    renderer_native->use_modifiers = TRUE;
+
+  G_OBJECT_CLASS (meta_renderer_native_parent_class)->constructed (object);
+}
+
 static void
 meta_renderer_native_init (MetaRendererNative *renderer_native)
 {
@@ -3407,6 +3426,7 @@ meta_renderer_native_class_init (MetaRendererNativeClass *klass)
  object_class->get_property = meta_renderer_native_get_property;
  object_class->set_property = meta_renderer_native_set_property;
  object_class->finalize = meta_renderer_native_finalize;
+  object_class->constructed = meta_renderer_native_constructed;

  renderer_class->create_cogl_renderer = meta_renderer_native_create_cogl_renderer;
  renderer_class->create_view = meta_renderer_native_create_view;
--- a/src/backends/x11/meta-backend-x11.c
+++ b/src/backends/x11/meta-backend-x11.c
@@ -37,7 +37,6 @@
 #include <X11/Xlib-xcb.h>
 #include <xkbcommon/xkbcommon-x11.h>

-#include "meta-idle-monitor-xsync.h"
 #include "backends/meta-stage.h"
 #include "backends/x11/meta-clutter-backend-x11.h"
 #include "backends/x11/meta-renderer-x11.h"
@@ -47,6 +46,7 @@
 #include "display-private.h"
 #include "compositor/compositor-private.h"
 #include "backends/meta-dnd-private.h"
+#include "backends/meta-idle-monitor-private.h"

 struct _MetaBackendX11Private
 {
@@ -57,6 +57,8 @@ struct _MetaBackendX11Private

  int xsync_event_base;
  int xsync_error_base;
+  XSyncAlarm user_active_alarm;
+  XSyncCounter counter;

  int xinput_opcode;
  int xinput_event_base;
@@ -83,13 +85,77 @@ G_DEFINE_TYPE_WITH_CODE (MetaBackendX11, meta_backend_x11, META_TYPE_BACKEND,
                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
                                                initable_iface_init));

+
 static void
-handle_alarm_notify (MetaBackend *backend,
-                     XEvent      *event)
+uint64_to_xsync_value (uint64_t    value,
+                       XSyncValue *xsync_value)
 {
-  meta_backend_foreach_device_monitor (backend,
-                                       (GFunc) meta_idle_monitor_xsync_handle_xevent,
-                                       event);
+  XSyncIntsToValue (xsync_value, value & 0xffffffff, value >> 32);
+}
+
+static XSyncAlarm
+xsync_user_active_alarm_set (MetaBackendX11Private *priv)
+{
+  XSyncAlarmAttributes attr;
+  XSyncValue delta;
+  unsigned long flags;
+
+  flags = (XSyncCACounter | XSyncCAValueType | XSyncCATestType |
+           XSyncCAValue | XSyncCADelta | XSyncCAEvents);
+
+  XSyncIntToValue (&delta, 0);
+  attr.trigger.counter = priv->counter;
+  attr.trigger.value_type = XSyncAbsolute;
+  attr.delta = delta;
+  attr.events = TRUE;
+
+  uint64_to_xsync_value (1, &attr.trigger.wait_value);
+
+  attr.trigger.test_type = XSyncNegativeTransition;
+  return XSyncCreateAlarm (priv->xdisplay, flags, &attr);
+}
+
+static XSyncCounter
+find_idletime_counter (MetaBackendX11Private *priv)
+{
+  int i;
+  int n_counters;
+  XSyncSystemCounter *counters;
+  XSyncCounter counter = None;
+
+  counters = XSyncListSystemCounters (priv->xdisplay, &n_counters);
+  for (i = 0; i < n_counters; i++)
+    {
+      if (g_strcmp0 (counters[i].name, "IDLETIME") == 0)
+        {
+          counter = counters[i].counter;
+          break;
+        }
+    }
+  XSyncFreeSystemCounterList (counters);
+
+  return counter;
+}
+
+static void
+handle_alarm_notify (MetaBackend           *backend,
+                     XSyncAlarmNotifyEvent *alarm_event)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+  MetaIdleMonitor *idle_monitor;
+  XSyncAlarmAttributes attr;
+
+  if (alarm_event->state != XSyncAlarmActive ||
+      alarm_event->alarm != priv->user_active_alarm)
+    return;
+
+  attr.events = TRUE;
+  XSyncChangeAlarm (priv->xdisplay, priv->user_active_alarm,
+                    XSyncCAEvents, &attr);
+
+  idle_monitor = meta_backend_get_idle_monitor (backend, 0);
+  meta_idle_monitor_reset_idletime (idle_monitor);
 }

 static void
@@ -275,7 +341,7 @@ handle_host_xevent (MetaBackend *backend,
                    bypass_clutter);

  if (event->type == (priv->xsync_event_base + XSyncAlarmNotify))
-    handle_alarm_notify (backend, event);
+    handle_alarm_notify (backend, (XSyncAlarmNotifyEvent *) event);

  if (event->type == priv->xkb_event_base)
    {
@@ -423,6 +489,12 @@ meta_backend_x11_post_init (MetaBackend *backend)
      !XSyncInitialize (priv->xdisplay, &major, &minor))
    meta_fatal ("Could not initialize XSync");

+  priv->counter = find_idletime_counter (priv);
+  if (priv->counter == None)
+    meta_fatal ("Could not initialize XSync counter");
+
+  priv->user_active_alarm = xsync_user_active_alarm_set (priv);
+
  if (XQueryExtension (priv->xdisplay,
                       "XInputExtension",
                       &priv->xinput_opcode,
@@ -464,15 +536,6 @@ meta_backend_x11_create_clutter_backend (MetaBackend *backend)
  return g_object_new (META_TYPE_CLUTTER_BACKEND_X11, NULL);
 }

-static MetaIdleMonitor *
-meta_backend_x11_create_idle_monitor (MetaBackend *backend,
-                                      int          device_id)
-{
-  return g_object_new (META_TYPE_IDLE_MONITOR_XSYNC,
-                       "device-id", device_id,
-                       NULL);
-}
-
 static gboolean
 meta_backend_x11_grab_device (MetaBackend *backend,
                              int          device_id,
@@ -679,14 +742,30 @@ initable_iface_init (GInitableIface *initable_iface)
  initable_iface->init = meta_backend_x11_initable_init;
 }

+static void
+meta_backend_x11_finalize (GObject *object)
+{
+  MetaBackendX11 *x11 = META_BACKEND_X11 (object);
+  MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
+
+  if (priv->user_active_alarm != None)
+    {
+      XSyncDestroyAlarm (priv->xdisplay, priv->user_active_alarm);
+      priv->user_active_alarm = None;
+    }
+
+  G_OBJECT_CLASS (meta_backend_x11_parent_class)->finalize (object);
+}
+
 static void
 meta_backend_x11_class_init (MetaBackendX11Class *klass)
 {
  MetaBackendClass *backend_class = META_BACKEND_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);

+  object_class->finalize = meta_backend_x11_finalize;
  backend_class->create_clutter_backend = meta_backend_x11_create_clutter_backend;
  backend_class->post_init = meta_backend_x11_post_init;
-  backend_class->create_idle_monitor = meta_backend_x11_create_idle_monitor;
  backend_class->grab_device = meta_backend_x11_grab_device;
  backend_class->ungrab_device = meta_backend_x11_ungrab_device;
  backend_class->warp_pointer = meta_backend_x11_warp_pointer;
--- a/src/backends/x11/meta-idle-monitor-xsync.c
+++ b/src/backends/x11/meta-idle-monitor-xsync.c
@@ -1,373 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright 2013 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- *
- * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
- *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
- */
-
-#include "config.h"
-
-#include "meta-idle-monitor-xsync.h"
-#include "meta-idle-monitor-private.h"
-
-#include "meta-backend-x11.h"
-
-#include <string.h>
-
-struct _MetaIdleMonitorXSync
-{
-  MetaIdleMonitor parent;
-
-  GHashTable  *alarms;
-  Display     *display;
-  XSyncCounter counter;
-  XSyncAlarm   user_active_alarm;
-};
-
-struct _MetaIdleMonitorXSyncClass
-{
-  MetaIdleMonitorClass parent_class;
-};
-
-typedef struct {
-  MetaIdleMonitorWatch base;
-
-  XSyncAlarm xalarm;
-} MetaIdleMonitorWatchXSync;
-
-G_DEFINE_TYPE (MetaIdleMonitorXSync, meta_idle_monitor_xsync, META_TYPE_IDLE_MONITOR)
-
-static gint64
-_xsyncvalue_to_int64 (XSyncValue value)
-{
-  return ((guint64) XSyncValueHigh32 (value)) << 32
-    | (guint64) XSyncValueLow32 (value);
-}
-
-#define GUINT64_TO_XSYNCVALUE(value, ret) XSyncIntsToValue (ret, (value) & 0xFFFFFFFF, ((guint64)(value)) >> 32)
-
-static XSyncAlarm
-_xsync_alarm_set (MetaIdleMonitorXSync	*monitor_xsync,
-		  XSyncTestType          test_type,
-		  guint64                interval,
-		  gboolean               want_events)
-{
-  XSyncAlarmAttributes attr;
-  XSyncValue	     delta;
-  guint		     flags;
-
-  flags = XSyncCACounter | XSyncCAValueType | XSyncCATestType |
-    XSyncCAValue | XSyncCADelta | XSyncCAEvents;
-
-  XSyncIntToValue (&delta, 0);
-  attr.trigger.counter = monitor_xsync->counter;
-  attr.trigger.value_type = XSyncAbsolute;
-  attr.delta = delta;
-  attr.events = want_events;
-
-  GUINT64_TO_XSYNCVALUE (interval, &attr.trigger.wait_value);
-  attr.trigger.test_type = test_type;
-  return XSyncCreateAlarm (monitor_xsync->display, flags, &attr);
-}
-
-static void
-ensure_alarm_rescheduled (Display    *dpy,
-			  XSyncAlarm  alarm)
-{
-  XSyncAlarmAttributes attr;
-
-  /* Some versions of Xorg have an issue where alarms aren't
-   * always rescheduled. Calling XSyncChangeAlarm, even
-   * without any attributes, will reschedule the alarm. */
-  XSyncChangeAlarm (dpy, alarm, 0, &attr);
-}
-
-static void
-set_alarm_enabled (Display    *dpy,
-		   XSyncAlarm  alarm,
-		   gboolean    enabled)
-{
-  XSyncAlarmAttributes attr;
-  attr.events = enabled;
-  XSyncChangeAlarm (dpy, alarm, XSyncCAEvents, &attr);
-}
-
-static char *
-counter_name_for_device (int device_id)
-{
-  if (device_id > 0)
-    return g_strdup_printf ("DEVICEIDLETIME %d", device_id);
-
-  return g_strdup ("IDLETIME");
-}
-
-static XSyncCounter
-find_idletime_counter (MetaIdleMonitorXSync *monitor_xsync)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (monitor_xsync);
-  int		      i;
-  int		      ncounters;
-  XSyncSystemCounter *counters;
-  XSyncCounter        counter = None;
-  char               *counter_name;
-
-  counter_name = counter_name_for_device (monitor->device_id);
-  counters = XSyncListSystemCounters (monitor_xsync->display, &ncounters);
-  for (i = 0; i < ncounters; i++)
-    {
-      if (counters[i].name != NULL && strcmp (counters[i].name, counter_name) == 0)
-        {
-          counter = counters[i].counter;
-          break;
-        }
-    }
-  XSyncFreeSystemCounterList (counters);
-  g_free (counter_name);
-
-  return counter;
-}
-
-static void
-init_xsync (MetaIdleMonitorXSync *monitor_xsync)
-{
-  monitor_xsync->counter = find_idletime_counter (monitor_xsync);
-  /* IDLETIME counter not found? */
-  if (monitor_xsync->counter == None)
-    {
-      g_warning ("IDLETIME counter not found\n");
-      return;
-    }
-
-  monitor_xsync->user_active_alarm = _xsync_alarm_set (monitor_xsync, XSyncNegativeTransition, 1, FALSE);
-}
-
-static void
-meta_idle_monitor_xsync_dispose (GObject *object)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (object);
-
-  if (monitor_xsync->user_active_alarm != None)
-    {
-      XSyncDestroyAlarm (monitor_xsync->display, monitor_xsync->user_active_alarm);
-      monitor_xsync->user_active_alarm = None;
-    }
-
-  g_clear_pointer (&monitor_xsync->alarms, g_hash_table_destroy);
-
-  G_OBJECT_CLASS (meta_idle_monitor_xsync_parent_class)->dispose (object);
-}
-
-static void
-meta_idle_monitor_xsync_constructed (GObject *object)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (object);
-  MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ());
-
-  monitor_xsync->display = meta_backend_x11_get_xdisplay (backend);
-  init_xsync (monitor_xsync);
-
-  G_OBJECT_CLASS (meta_idle_monitor_xsync_parent_class)->constructed (object);
-}
-
-static gint64
-meta_idle_monitor_xsync_get_idletime (MetaIdleMonitor *monitor)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-  XSyncValue value;
-
-  if (!XSyncQueryCounter (monitor_xsync->display, monitor_xsync->counter, &value))
-    return -1;
-
-  return _xsyncvalue_to_int64 (value);
-}
-
-static gboolean
-fire_watch_idle (gpointer data)
-{
-  MetaIdleMonitorWatch *watch = data;
-
-  watch->idle_source_id = 0;
-  _meta_idle_monitor_watch_fire (watch);
-
-  return FALSE;
-}
-
-static guint32
-get_next_watch_serial (void)
-{
-  static guint32 serial = 0;
-  g_atomic_int_inc (&serial);
-  return serial;
-}
-
-static void
-free_watch (gpointer data)
-{
-  MetaIdleMonitorWatchXSync *watch_xsync = data;
-  MetaIdleMonitorWatch *watch = (MetaIdleMonitorWatch *) watch_xsync;
-  MetaIdleMonitor *monitor = watch->monitor;
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-
-  g_object_ref (monitor);
-
-  if (watch->idle_source_id)
-    {
-      g_source_remove (watch->idle_source_id);
-      watch->idle_source_id = 0;
-    }
-
-  if (watch->notify != NULL)
-    watch->notify (watch->user_data);
-
-  if (watch_xsync->xalarm != monitor_xsync->user_active_alarm &&
-      watch_xsync->xalarm != None)
-    {
-      XSyncDestroyAlarm (monitor_xsync->display, watch_xsync->xalarm);
-      g_hash_table_remove (monitor_xsync->alarms, (gpointer) watch_xsync->xalarm);
-    }
-
-  g_object_unref (monitor);
-  g_slice_free (MetaIdleMonitorWatchXSync, watch_xsync);
-}
-
-static MetaIdleMonitorWatch *
-meta_idle_monitor_xsync_make_watch (MetaIdleMonitor           *monitor,
-                                    guint64                    timeout_msec,
-                                    MetaIdleMonitorWatchFunc   callback,
-                                    gpointer                   user_data,
-                                    GDestroyNotify             notify)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-  MetaIdleMonitorWatchXSync *watch_xsync;
-  MetaIdleMonitorWatch *watch;
-
-  watch_xsync = g_slice_new0 (MetaIdleMonitorWatchXSync);
-  watch = (MetaIdleMonitorWatch *) watch_xsync;
-
-  watch->monitor = monitor;
-  watch->id = get_next_watch_serial ();
-  watch->callback = callback;
-  watch->user_data = user_data;
-  watch->notify = notify;
-  watch->timeout_msec = timeout_msec;
-
-  if (monitor_xsync->user_active_alarm != None)
-    {
-      if (timeout_msec != 0)
-        {
-          watch_xsync->xalarm = _xsync_alarm_set (monitor_xsync, XSyncPositiveTransition, timeout_msec, TRUE);
-
-          g_hash_table_add (monitor_xsync->alarms, (gpointer) watch_xsync->xalarm);
-
-          if (meta_idle_monitor_get_idletime (monitor) > (gint64)timeout_msec)
-            {
-              watch->idle_source_id = g_idle_add (fire_watch_idle, watch);
-              g_source_set_name_by_id (watch->idle_source_id, "[mutter] fire_watch_idle");
-            }
-        }
-      else
-        {
-          watch_xsync->xalarm = monitor_xsync->user_active_alarm;
-
-          set_alarm_enabled (monitor_xsync->display, monitor_xsync->user_active_alarm, TRUE);
-        }
-    }
-
-  return watch;
-}
-
-static void
-meta_idle_monitor_xsync_class_init (MetaIdleMonitorXSyncClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  MetaIdleMonitorClass *idle_monitor_class = META_IDLE_MONITOR_CLASS (klass);
-
-  object_class->dispose = meta_idle_monitor_xsync_dispose;
-  object_class->constructed = meta_idle_monitor_xsync_constructed;
-
-  idle_monitor_class->get_idletime = meta_idle_monitor_xsync_get_idletime;
-  idle_monitor_class->make_watch = meta_idle_monitor_xsync_make_watch;
-}
-
-static void
-meta_idle_monitor_xsync_init (MetaIdleMonitorXSync *monitor_xsync)
-{
-  MetaIdleMonitor *monitor = META_IDLE_MONITOR (monitor_xsync);
-
-  monitor->watches = g_hash_table_new_full (NULL, NULL, NULL, free_watch);
-  monitor_xsync->alarms = g_hash_table_new (NULL, NULL);
-}
-
-static void
-check_x11_watches (MetaIdleMonitor *monitor,
-                   XSyncAlarm       alarm)
-{
-  GList *node, *watch_ids;
-
-  /* we get the keys and do explicit look ups in case
-   * an early iteration of the loop ends up leading
-   * to watches from later iterations getting invalidated
-   */
-  watch_ids = g_hash_table_get_keys (monitor->watches);
-
-  for (node = watch_ids; node != NULL; node = node->next)
-    {
-      guint watch_id = GPOINTER_TO_UINT (node->data);
-      MetaIdleMonitorWatchXSync *watch;
-
-      watch = g_hash_table_lookup (monitor->watches, GUINT_TO_POINTER (watch_id));
-
-      if (watch && watch->xalarm == alarm)
-        _meta_idle_monitor_watch_fire ((MetaIdleMonitorWatch *) watch);
-    }
-
-  g_list_free (watch_ids);
-}
-
-void
-meta_idle_monitor_xsync_handle_xevent (MetaIdleMonitor       *monitor,
-                                       XSyncAlarmNotifyEvent *alarm_event)
-{
-  MetaIdleMonitorXSync *monitor_xsync = META_IDLE_MONITOR_XSYNC (monitor);
-  XSyncAlarm alarm;
-  gboolean has_alarm;
-
-  if (alarm_event->state != XSyncAlarmActive)
-    return;
-
-  alarm = alarm_event->alarm;
-
-  has_alarm = FALSE;
-
-  if (alarm == monitor_xsync->user_active_alarm)
-    {
-      set_alarm_enabled (monitor_xsync->display,
-                         alarm,
-                         FALSE);
-      has_alarm = TRUE;
-    }
-  else if (g_hash_table_contains (monitor_xsync->alarms, (gpointer) alarm))
-    {
-      ensure_alarm_rescheduled (monitor_xsync->display,
-                                alarm);
-      has_alarm = TRUE;
-    }
-
-  if (has_alarm)
-    check_x11_watches (monitor, alarm);
-}
--- a/src/backends/x11/meta-idle-monitor-xsync.h
+++ b/src/backends/x11/meta-idle-monitor-xsync.h
@@ -1,47 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright 2013 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- *
- * Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
- *         from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
- */
-
-#ifndef META_IDLE_MONITOR_XSYNC_H
-#define META_IDLE_MONITOR_XSYNC_H
-
-#include <glib-object.h>
-#include <meta/meta-idle-monitor.h>
-
-#include <X11/Xlib.h>
-#include <X11/extensions/sync.h>
-
-#define META_TYPE_IDLE_MONITOR_XSYNC            (meta_idle_monitor_xsync_get_type ())
-#define META_IDLE_MONITOR_XSYNC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_IDLE_MONITOR_XSYNC, MetaIdleMonitorXSync))
-#define META_IDLE_MONITOR_XSYNC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_IDLE_MONITOR_XSYNC, MetaIdleMonitorXSyncClass))
-#define META_IS_IDLE_MONITOR_XSYNC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_IDLE_MONITOR_XSYNC))
-#define META_IS_IDLE_MONITOR_XSYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_IDLE_MONITOR_XSYNC))
-#define META_IDLE_MONITOR_XSYNC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_IDLE_MONITOR_XSYNC, MetaIdleMonitorXSyncClass))
-
-typedef struct _MetaIdleMonitorXSync        MetaIdleMonitorXSync;
-typedef struct _MetaIdleMonitorXSyncClass   MetaIdleMonitorXSyncClass;
-
-GType meta_idle_monitor_xsync_get_type (void);
-
-void meta_idle_monitor_xsync_handle_xevent (MetaIdleMonitor       *monitor,
-                                            XSyncAlarmNotifyEvent *xevent);
-
-#endif /* META_IDLE_MONITOR_XSYNC_H */
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -58,5 +58,6 @@ void meta_window_actor_effect_completed (MetaWindowActor  *actor,

 MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self);
 void meta_window_actor_update_surface (MetaWindowActor *self);
+MetaWindowActor *meta_window_actor_from_window (MetaWindow *window);

 #endif /* META_WINDOW_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -142,6 +142,8 @@ struct _FrameData
 enum
 {
  FIRST_FRAME,
+  EFFECTS_COMPLETED,
+
  LAST_SIGNAL
 };

@@ -238,6 +240,21 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 0);

+  /**
+   * MetaWindowActor::effects-completed:
+   * @actor: the #MetaWindowActor instance
+   *
+   * The ::effects-completed signal will be emitted once all pending compositor
+   * effects are completed.
+   */
+  signals[EFFECTS_COMPLETED] =
+    g_signal_new ("effects-completed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
  pspec = g_param_spec_object ("meta-window",
                               "MetaWindow",
                               "The displayed MetaWindow",
@@ -433,7 +450,7 @@ meta_window_actor_update_surface (MetaWindowActor *self)

 #ifdef HAVE_WAYLAND
  if (window->surface)
-    surface_actor = window->surface->surface_actor;
+    surface_actor = meta_wayland_surface_get_actor (window->surface);
  else
 #endif
  if (!meta_is_wayland_compositor ())
@@ -1131,6 +1148,7 @@ meta_window_actor_after_effects (MetaWindowActor *self)
      return;
    }

+  g_signal_emit (self, signals[EFFECTS_COMPLETED], 0);
  meta_window_actor_sync_visibility (self);
  meta_window_actor_sync_actor_geometry (self, FALSE);
 }
@@ -2157,3 +2175,9 @@ meta_window_actor_sync_updates_frozen (MetaWindowActor *self)

  meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (window));
 }
+
+MetaWindowActor *
+meta_window_actor_from_window (MetaWindow *window)
+{
+  return META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+}
--- a/src/core/events.c
+++ b/src/core/events.c
@@ -32,9 +32,10 @@

 #ifdef HAVE_NATIVE_BACKEND
 #include "backends/native/meta-backend-native.h"
-#include "backends/native/meta-idle-monitor-native.h"
 #endif

+#include "backends/meta-idle-monitor-private.h"
+
 #ifdef HAVE_WAYLAND
 #include "wayland/meta-wayland-private.h"
 #endif
@@ -92,46 +93,38 @@ get_window_for_event (MetaDisplay        *display,
 static void
 handle_idletime_for_event (const ClutterEvent *event)
 {
-#ifdef HAVE_NATIVE_BACKEND
-  /* This is handled by XSync under X11. */
-  MetaBackend *backend = meta_get_backend ();
+  ClutterInputDevice *device, *source_device;
+  MetaIdleMonitor *core_monitor, *device_monitor;
+  int device_id;

-  if (META_IS_BACKEND_NATIVE (backend))
+  device = clutter_event_get_device (event);
+  if (device == NULL)
+    return;
+
+  if (event->any.flags & CLUTTER_EVENT_FLAG_SYNTHETIC ||
+      event->type == CLUTTER_ENTER ||
+      event->type == CLUTTER_LEAVE ||
+      event->type == CLUTTER_STAGE_STATE ||
+      event->type == CLUTTER_DESTROY_NOTIFY ||
+      event->type == CLUTTER_CLIENT_MESSAGE ||
+      event->type == CLUTTER_DELETE)
+    return;
+
+  device_id = clutter_input_device_get_device_id (device);
+
+  core_monitor = meta_idle_monitor_get_core ();
+  device_monitor = meta_idle_monitor_get_for_device (device_id);
+
+  meta_idle_monitor_reset_idletime (core_monitor);
+  meta_idle_monitor_reset_idletime (device_monitor);
+
+  source_device = clutter_event_get_source_device (event);
+  if (source_device != device)
    {
-      ClutterInputDevice *device, *source_device;
-      MetaIdleMonitor *core_monitor, *device_monitor;
-      int device_id;
-
-      device = clutter_event_get_device (event);
-      if (device == NULL)
-        return;
-
-      if (event->any.flags & CLUTTER_EVENT_FLAG_SYNTHETIC ||
-          event->type == CLUTTER_ENTER ||
-          event->type == CLUTTER_LEAVE ||
-          event->type == CLUTTER_STAGE_STATE ||
-          event->type == CLUTTER_DESTROY_NOTIFY ||
-          event->type == CLUTTER_CLIENT_MESSAGE ||
-          event->type == CLUTTER_DELETE)
-        return;
-
      device_id = clutter_input_device_get_device_id (device);
-
-      core_monitor = meta_idle_monitor_get_core ();
      device_monitor = meta_idle_monitor_get_for_device (device_id);
-
-      meta_idle_monitor_native_reset_idletime (core_monitor);
-      meta_idle_monitor_native_reset_idletime (device_monitor);
-
-      source_device = clutter_event_get_source_device (event);
-      if (source_device != device)
-        {
-          device_id = clutter_input_device_get_device_id (device);
-          device_monitor = meta_idle_monitor_get_for_device (device_id);
-          meta_idle_monitor_native_reset_idletime (device_monitor);
-        }
+      meta_idle_monitor_reset_idletime (device_monitor);
    }
-#endif /* HAVE_NATIVE_BACKEND */
 }

 static gboolean
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -81,6 +81,7 @@ typedef enum
  META_MOVE_RESIZE_STATE_CHANGED = 1 << 5,
  META_MOVE_RESIZE_UNMAXIMIZE = 1 << 6,
  META_MOVE_RESIZE_FORCE_MOVE = 1 << 7,
+  META_MOVE_RESIZE_WAYLAND_STATE_CHANGED = 1 << 8,
 } MetaMoveResizeFlags;

 typedef enum
@@ -88,6 +89,7 @@ typedef enum
  META_MOVE_RESIZE_RESULT_MOVED               = 1 << 0,
  META_MOVE_RESIZE_RESULT_RESIZED             = 1 << 1,
  META_MOVE_RESIZE_RESULT_FRAME_SHAPE_CHANGED = 1 << 2,
+  META_MOVE_RESIZE_RESULT_STATE_CHANGED       = 1 << 3,
 } MetaMoveResizeResultFlags;

 typedef enum
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -3997,7 +3997,7 @@ meta_window_move_resize_internal (MetaWindow          *window,

  if ((moved_or_resized ||
       did_placement ||
-       (flags & META_MOVE_RESIZE_STATE_CHANGED) != 0) &&
+       (result & META_MOVE_RESIZE_RESULT_STATE_CHANGED) != 0) &&
      window->known_to_compositor)
    {
      meta_compositor_sync_window_geometry (window->display->compositor,
@@ -5268,7 +5268,7 @@ static cairo_surface_t *
 load_default_window_icon (int size)
 {
  GtkIconTheme *theme = gtk_icon_theme_get_default ();
-  GdkPixbuf *pixbuf;
+  g_autoptr (GdkPixbuf) pixbuf = NULL;
  const char *icon_name;

  if (gtk_icon_theme_has_icon (theme, META_DEFAULT_ICON_NAME))
--- a/src/org.gnome.Mutter.IdleMonitor.xml
+++ b/src/org.gnome.Mutter.IdleMonitor.xml
@@ -28,6 +28,8 @@
      <arg name="id" direction="in" type="u" />
    </method>

+    <method name="ResetIdletime"/>
+
    <signal name="WatchFired">
      <arg name="id" direction="out" type="u" />
    </signal>
--- a/src/ui/frames.c
+++ b/src/ui/frames.c
@@ -1330,7 +1330,9 @@ meta_ui_frame_get_mask (MetaUIFrame *frame,
  MetaFrameBorders borders;
  MetaFrameFlags flags;
  MetaRectangle frame_rect;
-  int scale = meta_theme_get_window_scaling_factor ();
+  cairo_surface_t *surface;
+  double xscale, yscale;
+  int scale;

  meta_window_get_frame_rect (frame->meta_window, &frame_rect);

@@ -1340,7 +1342,11 @@ meta_ui_frame_get_mask (MetaUIFrame *frame,
  meta_ui_frame_get_borders (frame, &borders);

  /* See comment in meta_frame_layout_draw_with_style() for details on HiDPI handling */
-  cairo_scale (cr, scale, scale);
+  scale = meta_theme_get_window_scaling_factor ();
+  surface = cairo_get_target (cr);
+  cairo_surface_get_device_scale (surface, &xscale, &yscale);
+  cairo_surface_set_device_scale (surface, scale, scale);
+
  gtk_render_background (frame->style_info->styles[META_STYLE_ELEMENT_FRAME], cr,
                         borders.invisible.left / scale,
                         borders.invisible.top / scale,
@@ -1349,6 +1355,8 @@ meta_ui_frame_get_mask (MetaUIFrame *frame,
                         borders.invisible.left / scale,
                         borders.invisible.top / scale,
                         frame_rect.width / scale, borders.total.top / scale);
+
+  cairo_surface_set_device_scale (surface, xscale, yscale);
 }

 /* XXX -- this is disgusting. Find a better approach here.
--- a/src/ui/theme.c
+++ b/src/ui/theme.c
@@ -580,7 +580,7 @@ meta_frame_layout_calc_geometry (MetaFrameLayout        *layout,
      x = rect->visible.x - layout->button_margin.left * scale;

      if (i > 0)
-        x -= layout->titlebar_spacing;
+        x -= layout->titlebar_spacing * scale;

      --i;
    }
@@ -712,6 +712,8 @@ get_class_from_button_type (MetaButtonType type)
      return "maximize";
    case META_BUTTON_TYPE_MINIMIZE:
      return "minimize";
+    case META_BUTTON_TYPE_APPMENU:
+      return "appmenu";
    default:
      return NULL;
    }
@@ -734,7 +736,9 @@ meta_frame_layout_draw_with_style (MetaFrameLayout         *layout,
  GdkRectangle titlebar_rect;
  GdkRectangle button_rect;
  const MetaFrameBorders *borders;
-  int scale = meta_theme_get_window_scaling_factor ();
+  cairo_surface_t *frame_surface;
+  double xscale, yscale;
+  int scale;

  /* We opt out of GTK+/Clutter's HiDPI handling, so we have to do the scaling
   * ourselves; the nitty-gritty is a bit confusing, so here is an overview:
@@ -746,8 +750,14 @@ meta_frame_layout_draw_with_style (MetaFrameLayout         *layout,
   *  - for drawing, we scale the canvas to have GTK+ render elements (borders,
   *    radii, ...) at the correct scale - as a result, we have to "unscale"
   *    the geometry again to not apply the scaling twice
+   *  - As per commit e36b629c GTK expects the device scale to be set and match
+   *    the final scaling or the surface caching won't take this in account
+   *    breaking -gtk-scaled items.
   */
-  cairo_scale (cr, scale, scale);
+  scale = meta_theme_get_window_scaling_factor ();
+  frame_surface = cairo_get_target (cr);
+  cairo_surface_get_device_scale (frame_surface, &xscale, &yscale);
+  cairo_surface_set_device_scale (frame_surface, scale, scale);

  borders = &fgeom->borders;

@@ -903,6 +913,8 @@ meta_frame_layout_draw_with_style (MetaFrameLayout         *layout,
        gtk_style_context_remove_class (style, button_class);
      gtk_style_context_set_state (style, state);
    }
+
+  cairo_surface_set_device_scale (frame_surface, xscale, yscale);
 }

 /**
--- a/src/wayland/meta-pointer-confinement-wayland.c
+++ b/src/wayland/meta-pointer-confinement-wayland.c
@@ -664,17 +664,8 @@ meta_pointer_confinement_wayland_maybe_warp (MetaPointerConfinementWayland *self
 }

 static void
-surface_actor_allocation_notify (MetaSurfaceActorWayland       *surface_actor,
-                                 GParamSpec                    *pspec,
-                                 MetaPointerConfinementWayland *self)
-{
-  meta_pointer_confinement_wayland_maybe_warp (self);
-}
-
-static void
-surface_actor_position_notify (MetaSurfaceActorWayland       *surface_actor,
-                               GParamSpec                    *pspec,
-                               MetaPointerConfinementWayland *self)
+surface_actor_geometry_changed (MetaSurfaceActorWayland       *surface_actor,
+                                MetaPointerConfinementWayland *self)
 {
  meta_pointer_confinement_wayland_maybe_warp (self);
 }
@@ -699,14 +690,9 @@ meta_pointer_confinement_wayland_new (MetaWaylandPointerConstraint *constraint)
  confinement->constraint = constraint;

  surface = meta_wayland_pointer_constraint_get_surface (constraint);
-  g_signal_connect_object (surface->surface_actor,
-                           "notify::allocation",
-                           G_CALLBACK (surface_actor_allocation_notify),
-                           confinement,
-                           0);
-  g_signal_connect_object (surface->surface_actor,
-                           "notify::position",
-                           G_CALLBACK (surface_actor_position_notify),
+  g_signal_connect_object (meta_wayland_surface_get_actor (surface),
+                           "geometry-changed",
+                           G_CALLBACK (surface_actor_geometry_changed),
                           confinement,
                           0);
  if (surface->window)
--- a/src/wayland/meta-wayland-actor-surface.c
+++ b/src/wayland/meta-wayland-actor-surface.c
@@ -30,30 +30,58 @@
 #include "wayland/meta-wayland-surface.h"
 #include "wayland/meta-window-wayland.h"

-G_DEFINE_ABSTRACT_TYPE (MetaWaylandActorSurface,
-                        meta_wayland_actor_surface,
-                        META_TYPE_WAYLAND_SURFACE_ROLE)
+typedef struct _MetaWaylandActorSurfacePrivate MetaWaylandActorSurfacePrivate;
+
+struct _MetaWaylandActorSurfacePrivate
+{
+  MetaSurfaceActor *actor;
+};
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (MetaWaylandActorSurface,
+                                     meta_wayland_actor_surface,
+                                     META_TYPE_WAYLAND_SURFACE_ROLE)
+
+static void
+meta_wayland_actor_surface_constructed (GObject *object)
+{
+  G_OBJECT_CLASS (meta_wayland_actor_surface_parent_class)->constructed (object);
+
+  meta_wayland_actor_surface_reset_actor (META_WAYLAND_ACTOR_SURFACE (object));
+}
+
+static void
+meta_wayland_actor_surface_finalize (GObject *object)
+{
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (META_WAYLAND_ACTOR_SURFACE (object));
+  MetaWaylandSurface *surface =
+    meta_wayland_surface_role_get_surface (META_WAYLAND_SURFACE_ROLE (object));
+
+  g_signal_handlers_disconnect_by_func (priv->actor,
+                                        meta_wayland_surface_notify_geometry_changed,
+                                        surface);
+  g_object_unref (priv->actor);
+
+  G_OBJECT_CLASS (meta_wayland_actor_surface_parent_class)->finalize (object);
+}

 static void
 meta_wayland_actor_surface_assigned (MetaWaylandSurfaceRole *surface_role)
 {
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (META_WAYLAND_ACTOR_SURFACE (surface_role));
  MetaWaylandSurface *surface =
    meta_wayland_surface_role_get_surface (surface_role);
-  MetaSurfaceActorWayland *surface_actor =
-    META_SURFACE_ACTOR_WAYLAND (surface->surface_actor);

-  meta_surface_actor_wayland_add_frame_callbacks (surface_actor,
+  meta_surface_actor_wayland_add_frame_callbacks (META_SURFACE_ACTOR_WAYLAND (priv->actor),
                                                  &surface->pending_frame_callback_list);
  wl_list_init (&surface->pending_frame_callback_list);
 }

 static void
-queue_surface_actor_frame_callbacks (MetaWaylandSurface      *surface,
+queue_surface_actor_frame_callbacks (MetaSurfaceActorWayland *surface_actor,
                                     MetaWaylandPendingState *pending)
 {
-  MetaSurfaceActorWayland *surface_actor =
-    META_SURFACE_ACTOR_WAYLAND (surface->surface_actor);
-
  meta_surface_actor_wayland_add_frame_callbacks (surface_actor,
                                                  &pending->frame_callback_list);
  wl_list_init (&pending->frame_callback_list);
@@ -90,6 +118,8 @@ meta_wayland_actor_surface_calculate_scale (MetaWaylandActorSurface *actor_surfa
 static void
 meta_wayland_actor_surface_real_sync_actor_state (MetaWaylandActorSurface *actor_surface)
 {
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (actor_surface);
  MetaWaylandSurfaceRole *surface_role =
    META_WAYLAND_SURFACE_ROLE (actor_surface);
  MetaWaylandSurface *surface =
@@ -99,7 +129,7 @@ meta_wayland_actor_surface_real_sync_actor_state (MetaWaylandActorSurface *actor
  double actor_scale;
  GList *l;

-  surface_actor = surface->surface_actor;
+  surface_actor = priv->actor;
  stex = meta_surface_actor_get_texture (surface_actor);

  actor_scale = meta_wayland_actor_surface_calculate_scale (actor_surface);
@@ -161,13 +191,16 @@ static void
 meta_wayland_actor_surface_commit (MetaWaylandSurfaceRole  *surface_role,
                                   MetaWaylandPendingState *pending)
 {
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (META_WAYLAND_ACTOR_SURFACE (surface_role));
  MetaWaylandActorSurface *actor_surface =
    META_WAYLAND_ACTOR_SURFACE (surface_role);
  MetaWaylandSurface *surface =
    meta_wayland_surface_role_get_surface (surface_role);
  MetaWaylandSurface *toplevel_surface;

-  queue_surface_actor_frame_callbacks (surface, pending);
+  queue_surface_actor_frame_callbacks (META_SURFACE_ACTOR_WAYLAND (priv->actor),
+                                       pending);

  toplevel_surface = meta_wayland_surface_get_toplevel (surface);
  if (!toplevel_surface || !toplevel_surface->window)
@@ -180,9 +213,9 @@ static gboolean
 meta_wayland_actor_surface_is_on_logical_monitor (MetaWaylandSurfaceRole *surface_role,
                                                  MetaLogicalMonitor     *logical_monitor)
 {
-  MetaWaylandSurface *surface =
-    meta_wayland_surface_role_get_surface (surface_role);
-  ClutterActor *actor = CLUTTER_ACTOR (surface->surface_actor);
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (META_WAYLAND_ACTOR_SURFACE (surface_role));
+  ClutterActor *actor = CLUTTER_ACTOR (priv->actor);
  float x, y, width, height;
  cairo_rectangle_int_t actor_rect;
  cairo_region_t *region;
@@ -226,6 +259,10 @@ meta_wayland_actor_surface_class_init (MetaWaylandActorSurfaceClass *klass)
 {
  MetaWaylandSurfaceRoleClass *surface_role_class =
    META_WAYLAND_SURFACE_ROLE_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->constructed = meta_wayland_actor_surface_constructed;
+  object_class->finalize = meta_wayland_actor_surface_finalize;

  surface_role_class->assigned = meta_wayland_actor_surface_assigned;
  surface_role_class->commit = meta_wayland_actor_surface_commit;
@@ -234,3 +271,41 @@ meta_wayland_actor_surface_class_init (MetaWaylandActorSurfaceClass *klass)

  klass->sync_actor_state = meta_wayland_actor_surface_real_sync_actor_state;
 }
+
+MetaSurfaceActor *
+meta_wayland_actor_surface_get_actor (MetaWaylandActorSurface *actor_surface)
+{
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (actor_surface);
+
+  return priv->actor;
+}
+
+void
+meta_wayland_actor_surface_reset_actor (MetaWaylandActorSurface *actor_surface)
+{
+  MetaWaylandActorSurfacePrivate *priv =
+    meta_wayland_actor_surface_get_instance_private (actor_surface);
+  MetaWaylandSurface *surface =
+    meta_wayland_surface_role_get_surface (META_WAYLAND_SURFACE_ROLE (actor_surface));
+
+  if (priv->actor)
+    {
+      g_signal_handlers_disconnect_by_func (priv->actor,
+                                            meta_wayland_surface_notify_geometry_changed,
+                                            surface);
+      g_object_unref (priv->actor);
+    }
+
+  priv->actor = g_object_ref_sink (meta_surface_actor_wayland_new (surface));
+
+  g_signal_connect_swapped (priv->actor, "notify::allocation",
+                            G_CALLBACK (meta_wayland_surface_notify_geometry_changed),
+                            surface);
+  g_signal_connect_swapped (priv->actor, "notify::position",
+                            G_CALLBACK (meta_wayland_surface_notify_geometry_changed),
+                            surface);
+  g_signal_connect_swapped (priv->actor, "notify::mapped",
+                            G_CALLBACK (meta_wayland_surface_notify_geometry_changed),
+                            surface);
+}
--- a/src/wayland/meta-wayland-actor-surface.h
+++ b/src/wayland/meta-wayland-actor-surface.h
@@ -40,4 +40,7 @@ void meta_wayland_actor_surface_sync_actor_state (MetaWaylandActorSurface *actor

 double meta_wayland_actor_surface_calculate_scale (MetaWaylandActorSurface *actor_surface);

+MetaSurfaceActor * meta_wayland_actor_surface_get_actor (MetaWaylandActorSurface *actor_surface);
+void meta_wayland_actor_surface_reset_actor (MetaWaylandActorSurface *actor_surface);
+
 #endif /* META_WAYLAND_ACTOR_SURFACE_H */
--- a/src/wayland/meta-wayland-data-device.c
+++ b/src/wayland/meta-wayland-data-device.c
@@ -1083,6 +1083,7 @@ meta_wayland_data_device_start_drag (MetaWaylandDataDevice                 *data
  MetaWaylandDragGrab *drag_grab;
  ClutterPoint pos, surface_pos;
  ClutterModifierType modifiers;
+  MetaSurfaceActor *surface_actor;

  data_device->current_grab = drag_grab = g_slice_new0 (MetaWaylandDragGrab);

@@ -1100,7 +1101,9 @@ meta_wayland_data_device_start_drag (MetaWaylandDataDevice                 *data
  wl_resource_add_destroy_listener (surface->resource,
                                    &drag_grab->drag_origin_listener);

-  clutter_actor_transform_stage_point (CLUTTER_ACTOR (meta_surface_actor_get_texture (surface->surface_actor)),
+  surface_actor = meta_wayland_surface_get_actor (surface);
+
+  clutter_actor_transform_stage_point (CLUTTER_ACTOR (meta_surface_actor_get_texture (surface_actor)),
                                       seat->pointer->grab_x,
                                       seat->pointer->grab_y,
                                       &surface_pos.x, &surface_pos.y);
@@ -1121,19 +1124,22 @@ meta_wayland_data_device_start_drag (MetaWaylandDataDevice                 *data

  if (icon_surface)
    {
+      ClutterActor *drag_origin_actor;
+
      drag_grab->drag_surface = icon_surface;

      drag_grab->drag_icon_listener.notify = destroy_data_device_icon;
      wl_resource_add_destroy_listener (icon_surface->resource,
                                        &drag_grab->drag_icon_listener);

-      drag_grab->feedback_actor = meta_dnd_actor_new (CLUTTER_ACTOR (drag_grab->drag_origin->surface_actor),
+      drag_origin_actor = CLUTTER_ACTOR (meta_wayland_surface_get_actor (drag_grab->drag_origin));
+
+      drag_grab->feedback_actor = meta_dnd_actor_new (drag_origin_actor,
                                                      drag_grab->drag_start_x,
                                                      drag_grab->drag_start_y);
      meta_feedback_actor_set_anchor (META_FEEDBACK_ACTOR (drag_grab->feedback_actor),
                                      0, 0);
-      clutter_actor_add_child (drag_grab->feedback_actor,
-                               CLUTTER_ACTOR (drag_grab->drag_surface->surface_actor));
+      clutter_actor_add_child (drag_grab->feedback_actor, drag_origin_actor);

      clutter_input_device_get_coords (seat->pointer->device, NULL, &pos);
      meta_feedback_actor_set_position (META_FEEDBACK_ACTOR (drag_grab->feedback_actor),
--- a/src/wayland/meta-wayland-legacy-xdg-shell.c
+++ b/src/wayland/meta-wayland-legacy-xdg-shell.c
@@ -585,6 +585,17 @@ is_new_size_hints_valid (MetaWindow              *window,
          (new_max_height == 0 || new_min_height <= new_max_height));
 }

+static inline gboolean
+did_geometry_change (MetaWaylandZxdgSurfaceV6 *xdg_surface,
+                     MetaWaylandPendingState  *pending)
+{
+  MetaWaylandZxdgSurfaceV6Private *priv =
+    meta_wayland_zxdg_surface_v6_get_instance_private (xdg_surface);
+
+  return pending->has_new_geometry &&
+         !meta_rectangle_equal (&priv->geometry, &pending->new_geometry);
+}
+
 static void
 meta_wayland_zxdg_toplevel_v6_commit (MetaWaylandSurfaceRole  *surface_role,
                                      MetaWaylandPendingState *pending)
@@ -600,6 +611,11 @@ meta_wayland_zxdg_toplevel_v6_commit (MetaWaylandSurfaceRole  *surface_role,
    meta_wayland_surface_role_get_surface (surface_role);
  MetaWindow *window = surface->window;
  MetaRectangle window_geometry;
+  gboolean geometry_changed;
+
+  /* This check must happen before chaining up, otherwise the new geometry
+   * is applied and it'll always return FALSE. */
+  geometry_changed = did_geometry_change (xdg_surface, pending);

  surface_role_class =
    META_WAYLAND_SURFACE_ROLE_CLASS (meta_wayland_zxdg_toplevel_v6_parent_class);
@@ -618,7 +634,7 @@ meta_wayland_zxdg_toplevel_v6_commit (MetaWaylandSurfaceRole  *surface_role,
  if (!window)
    return;

-  if (pending->has_new_geometry)
+  if (geometry_changed || meta_window_wayland_needs_move_resize (window))
    {
      window_geometry =
        meta_wayland_zxdg_surface_v6_get_window_geometry (xdg_surface);
--- a/src/wayland/meta-wayland-private.h
+++ b/src/wayland/meta-wayland-private.h
@@ -72,6 +72,8 @@ struct _MetaWaylandCompositor

  MetaWaylandSeat *seat;
  MetaWaylandTabletManager *tablet_manager;
+
+  GHashTable *scheduled_surface_associations;
 };

 #endif /* META_WAYLAND_PRIVATE_H */
--- a/src/wayland/meta-wayland-seat.c
+++ b/src/wayland/meta-wayland-seat.c
@@ -325,7 +325,8 @@ void
 meta_wayland_seat_update (MetaWaylandSeat    *seat,
                          const ClutterEvent *event)
 {
-  if (!event_from_supported_hardware_device (seat, event) &&
+  if (!(clutter_event_get_flags (event) & CLUTTER_EVENT_FLAG_INPUT_METHOD) &&
+      !event_from_supported_hardware_device (seat, event) &&
      !event_is_synthesized_crossing (event))
    return;

@@ -363,7 +364,8 @@ gboolean
 meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
                                const ClutterEvent *event)
 {
-  if (!event_from_supported_hardware_device (seat, event))
+  if (!(clutter_event_get_flags (event) & CLUTTER_EVENT_FLAG_INPUT_METHOD) &&
+      !event_from_supported_hardware_device (seat, event))
    return FALSE;

  switch (event->type)
--- a/src/wayland/meta-wayland-subsurface.c
+++ b/src/wayland/meta-wayland-subsurface.c
@@ -54,7 +54,7 @@ G_DEFINE_TYPE (MetaWaylandSubsurface,
 static void
 sync_actor_subsurface_state (MetaWaylandSurface *surface)
 {
-  ClutterActor *actor = CLUTTER_ACTOR (surface->surface_actor);
+  ClutterActor *actor = CLUTTER_ACTOR (meta_wayland_surface_get_actor (surface));
  MetaWindow *toplevel_window;
  int geometry_scale;
  int x, y;
@@ -99,8 +99,8 @@ meta_wayland_subsurface_parent_state_applied (MetaWaylandSubsurface *subsurface)
      GSList *it;
      MetaWaylandSurface *parent = surface->sub.parent;
      ClutterActor *parent_actor =
-        clutter_actor_get_parent (CLUTTER_ACTOR (parent->surface_actor));
-      ClutterActor *surface_actor = CLUTTER_ACTOR (surface->surface_actor);
+        clutter_actor_get_parent (CLUTTER_ACTOR (meta_wayland_surface_get_actor (parent)));
+      ClutterActor *surface_actor = CLUTTER_ACTOR (meta_wayland_surface_get_actor (surface));

      for (it = surface->sub.pending_placement_ops; it; it = it->next)
        {
@@ -113,7 +113,7 @@ meta_wayland_subsurface_parent_state_applied (MetaWaylandSubsurface *subsurface)
              continue;
            }

-          sibling_actor = CLUTTER_ACTOR (op->sibling->surface_actor);
+          sibling_actor = CLUTTER_ACTOR (meta_wayland_surface_get_actor (op->sibling));

          switch (op->placement)
            {
@@ -234,7 +234,7 @@ meta_wayland_subsurface_class_init (MetaWaylandSubsurfaceClass *klass)
 static void
 unparent_actor (MetaWaylandSurface *surface)
 {
-  ClutterActor *actor = CLUTTER_ACTOR (surface->surface_actor);
+  ClutterActor *actor = CLUTTER_ACTOR (meta_wayland_surface_get_actor (surface));
  ClutterActor *parent_actor;

  parent_actor = clutter_actor_get_parent (actor);
@@ -471,10 +471,10 @@ wl_subcompositor_get_subsurface (struct wl_client   *client,
                                    &surface->sub.parent_destroy_listener);
  parent->subsurfaces = g_list_append (parent->subsurfaces, surface);

-  clutter_actor_add_child (CLUTTER_ACTOR (parent->surface_actor),
-                           CLUTTER_ACTOR (surface->surface_actor));
+  clutter_actor_add_child (CLUTTER_ACTOR (meta_wayland_surface_get_actor (parent)),
+                           CLUTTER_ACTOR (meta_wayland_surface_get_actor (surface)));

-  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), TRUE);
+  clutter_actor_set_reactive (CLUTTER_ACTOR (meta_wayland_surface_get_actor (surface)), TRUE);
 }

 static const struct wl_subcompositor_interface meta_wayland_subcompositor_interface = {
--- a/src/wayland/meta-wayland-surface-role-cursor.c
+++ b/src/wayland/meta-wayland-surface-role-cursor.c
@@ -195,14 +195,15 @@ cursor_surface_role_is_on_logical_monitor (MetaWaylandSurfaceRole *role,
    META_WAYLAND_SURFACE_ROLE_CURSOR (surface->role);
  MetaWaylandSurfaceRoleCursorPrivate *priv =
    meta_wayland_surface_role_cursor_get_instance_private (cursor_role);
-  ClutterRect rect;
+  ClutterPoint point;
  ClutterRect logical_monitor_rect;

-  rect = meta_cursor_renderer_calculate_rect (priv->cursor_renderer,
-                                              priv->cursor_sprite);
  logical_monitor_rect =
    meta_rectangle_to_clutter_rect (&logical_monitor->rect);
-  return clutter_rect_intersection (&rect, &logical_monitor_rect, NULL);
+
+  point = meta_cursor_renderer_get_position (priv->cursor_renderer);
+
+  return clutter_rect_contains_point (&logical_monitor_rect, &point);
 }

 static void
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
@@ -54,6 +54,7 @@

 #include "compositor/region-utils.h"
 #include "compositor/meta-shaped-texture-private.h"
+#include "compositor/meta-window-actor-private.h"

 #include "meta-surface-actor.h"
 #include "meta-surface-actor-wayland.h"
@@ -104,6 +105,7 @@ enum {
  SURFACE_CONFIGURE,
  SURFACE_SHORTCUTS_INHIBITED,
  SURFACE_SHORTCUTS_RESTORED,
+  SURFACE_GEOMETRY_CHANGED,
  N_SURFACE_SIGNALS
 };

@@ -127,21 +129,12 @@ meta_wayland_surface_role_is_on_logical_monitor (MetaWaylandSurfaceRole *surface
 static MetaWaylandSurface *
 meta_wayland_surface_role_get_toplevel (MetaWaylandSurfaceRole *surface_role);

-static void
-surface_actor_mapped_notify (MetaSurfaceActorWayland *surface_actor,
-                             GParamSpec              *pspec,
-                             MetaWaylandSurface      *surface);
-static void
-surface_actor_allocation_notify (MetaSurfaceActorWayland *surface_actor,
-                                 GParamSpec              *pspec,
-                                 MetaWaylandSurface      *surface);
-static void
-surface_actor_position_notify (MetaSurfaceActorWayland *surface_actor,
-                               GParamSpec              *pspec,
-                               MetaWaylandSurface      *surface);
 static void
 window_position_changed (MetaWindow         *window,
                         MetaWaylandSurface *surface);
+static void
+window_actor_effects_completed (MetaWindowActor    *window_actor,
+                                MetaWaylandSurface *surface);

 static void
 role_assignment_valist_to_properties (GType       role_type,
@@ -308,7 +301,7 @@ surface_process_damage (MetaWaylandSurface *surface,
      cairo_rectangle_int_t rect;
      cairo_region_get_rectangle (scaled_region, i, &rect);

-      meta_surface_actor_process_damage (surface->surface_actor,
+      meta_surface_actor_process_damage (meta_wayland_surface_get_actor (surface),
                                         rect.x, rect.y,
                                         rect.width, rect.height);
    }
@@ -392,6 +385,7 @@ pending_state_init (MetaWaylandPendingState *state)
 {
  state->newly_attached = FALSE;
  state->buffer = NULL;
+  state->buffer_destroy_handler_id = 0;
  state->dx = 0;
  state->dy = 0;
  state->scale = 0;
@@ -421,8 +415,11 @@ pending_state_destroy (MetaWaylandPendingState *state)
  g_clear_pointer (&state->opaque_region, cairo_region_destroy);

  if (state->buffer)
-    g_signal_handler_disconnect (state->buffer,
-                                 state->buffer_destroy_handler_id);
+    {
+      g_signal_handler_disconnect (state->buffer,
+                                   state->buffer_destroy_handler_id);
+      state->buffer_destroy_handler_id = 0;
+    }
  wl_list_for_each_safe (cb, next, &state->frame_callback_list, link)
    wl_resource_destroy (cb->resource);
 }
@@ -435,36 +432,84 @@ pending_state_reset (MetaWaylandPendingState *state)
 }

 static void
-move_pending_state (MetaWaylandPendingState *from,
-                    MetaWaylandPendingState *to)
+merge_pending_state (MetaWaylandPendingState *from,
+                     MetaWaylandPendingState *to)
 {
-  if (from->buffer)
-    g_signal_handler_disconnect (from->buffer, from->buffer_destroy_handler_id);
+  if (from->newly_attached)
+    {
+      if (to->buffer)
+        {
+          g_signal_handler_disconnect (to->buffer,
+                                       to->buffer_destroy_handler_id);
+          to->buffer_destroy_handler_id = 0;
+        }

-  to->newly_attached = from->newly_attached;
-  to->buffer = from->buffer;
-  to->dx = from->dx;
-  to->dy = from->dy;
-  to->scale = from->scale;
-  to->surface_damage = from->surface_damage;
-  to->buffer_damage = from->buffer_damage;
-  to->input_region = from->input_region;
-  to->input_region_set = from->input_region_set;
-  to->opaque_region = from->opaque_region;
-  to->opaque_region_set = from->opaque_region_set;
-  to->new_geometry = from->new_geometry;
-  to->has_new_geometry = from->has_new_geometry;
-  to->has_new_min_size = from->has_new_min_size;
-  to->new_min_width = from->new_min_width;
-  to->new_min_height = from->new_min_height;
-  to->has_new_max_size = from->has_new_max_size;
-  to->new_max_width = from->new_max_width;
-  to->new_max_height = from->new_max_height;
+      if (from->buffer)
+        {
+          g_signal_handler_disconnect (from->buffer,
+                                       from->buffer_destroy_handler_id);
+          from->buffer_destroy_handler_id = 0;
+        }
+
+      to->newly_attached = TRUE;
+      to->buffer = from->buffer;
+      to->dx = from->dx;
+      to->dy = from->dy;
+    }

-  wl_list_init (&to->frame_callback_list);
  wl_list_insert_list (&to->frame_callback_list, &from->frame_callback_list);

-  if (to->buffer)
+  cairo_region_union (to->surface_damage, from->surface_damage);
+  cairo_region_union (to->buffer_damage, from->buffer_damage);
+  cairo_region_destroy (from->surface_damage);
+  cairo_region_destroy (from->buffer_damage);
+
+  if (from->input_region_set)
+    {
+      if (to->input_region)
+        cairo_region_union (to->input_region, from->input_region);
+      else
+        to->input_region = cairo_region_reference (from->input_region);
+
+      to->input_region_set = TRUE;
+      cairo_region_destroy (from->input_region);
+    }
+
+  if (from->opaque_region_set)
+    {
+      if (to->opaque_region)
+        cairo_region_union (to->opaque_region, from->opaque_region);
+      else
+        to->opaque_region = cairo_region_reference (from->opaque_region);
+
+      to->opaque_region_set = TRUE;
+      cairo_region_destroy (from->opaque_region);
+    }
+
+  if (from->has_new_geometry)
+    {
+      to->new_geometry = from->new_geometry;
+      to->has_new_geometry = TRUE;
+    }
+
+  if (from->has_new_min_size)
+    {
+      to->new_min_width = from->new_min_width;
+      to->new_min_height = from->new_min_height;
+      to->has_new_min_size = TRUE;
+    }
+
+  if (from->has_new_max_size)
+    {
+      to->new_max_width = from->new_max_width;
+      to->new_max_height = from->new_max_height;
+      to->has_new_max_size = TRUE;
+    }
+
+  if (from->scale > 0)
+    to->scale = from->scale;
+
+  if (to->buffer && to->buffer_destroy_handler_id == 0)
    {
      to->buffer_destroy_handler_id =
        g_signal_connect (to->buffer, "resource-destroyed",
@@ -596,14 +641,14 @@ meta_wayland_surface_apply_pending_state (MetaWaylandSurface      *surface,
              goto cleanup;
            }

-          if (switched_buffer)
+          if (switched_buffer && meta_wayland_surface_get_actor (surface))
            {
              MetaShapedTexture *stex;
              CoglTexture *texture;
              CoglSnippet *snippet;
              gboolean is_y_inverted;

-              stex = meta_surface_actor_get_texture (surface->surface_actor);
+              stex = meta_surface_actor_get_texture (meta_wayland_surface_get_actor (surface));
              texture = meta_wayland_buffer_get_texture (pending->buffer);
              snippet = meta_wayland_buffer_create_snippet (pending->buffer);
              is_y_inverted = meta_wayland_buffer_is_y_inverted (pending->buffer);
@@ -627,8 +672,9 @@ meta_wayland_surface_apply_pending_state (MetaWaylandSurface      *surface,
  if (pending->scale > 0)
    surface->scale = pending->scale;

-  if (!cairo_region_is_empty (pending->surface_damage) ||
-      !cairo_region_is_empty (pending->buffer_damage))
+  if (meta_wayland_surface_get_actor (surface) &&
+      (!cairo_region_is_empty (pending->surface_damage) ||
+       !cairo_region_is_empty (pending->buffer_damage)))
    surface_process_damage (surface,
                            pending->surface_damage,
                            pending->buffer_damage);
@@ -712,7 +758,7 @@ meta_wayland_surface_commit (MetaWaylandSurface *surface)
   *     surface is in effective desynchronized mode.
   */
  if (meta_wayland_surface_is_effectively_synchronized (surface))
-    move_pending_state (surface->pending, surface->sub.pending);
+    merge_pending_state (surface->pending, surface->sub.pending);
  else
    meta_wayland_surface_apply_pending_state (surface, surface->pending);
 }
@@ -1083,11 +1129,14 @@ meta_wayland_surface_set_window (MetaWaylandSurface *surface,
      g_signal_handlers_disconnect_by_func (surface->window,
                                            window_position_changed,
                                            surface);
+      g_signal_handlers_disconnect_by_func (meta_window_actor_from_window (surface->window),
+                                            window_actor_effects_completed,
+                                            surface);
    }

  surface->window = window;

-  clutter_actor_set_reactive (CLUTTER_ACTOR (surface->surface_actor), !!window);
+  clutter_actor_set_reactive (CLUTTER_ACTOR (meta_wayland_surface_get_actor (surface)), !!window);
  sync_drag_dest_funcs (surface);

  if (was_unmapped)
@@ -1099,6 +1148,10 @@ meta_wayland_surface_set_window (MetaWaylandSurface *surface,
                               "position-changed",
                               G_CALLBACK (window_position_changed),
                               surface, 0);
+      g_signal_connect_object (meta_window_actor_from_window (window),
+                               "effects-completed",
+                               G_CALLBACK (window_actor_effects_completed),
+                               surface, 0);
    }
 }

@@ -1111,16 +1164,6 @@ wl_surface_destructor (struct wl_resource *resource)

  g_signal_emit (surface, surface_signals[SURFACE_DESTROY], 0);

-  g_signal_handlers_disconnect_by_func (surface->surface_actor,
-                                        surface_actor_mapped_notify,
-                                        surface);
-  g_signal_handlers_disconnect_by_func (surface->surface_actor,
-                                        surface_actor_allocation_notify,
-                                        surface);
-  g_signal_handlers_disconnect_by_func (surface->surface_actor,
-                                        surface_actor_position_notify,
-                                        surface);
-
  g_clear_object (&surface->role);

  /* If we still have a window at the time of destruction, that means that
@@ -1146,8 +1189,6 @@ wl_surface_destructor (struct wl_resource *resource)
  if (surface->input_region)
    cairo_region_destroy (surface->input_region);

-  g_object_unref (surface->surface_actor);
-
  meta_wayland_compositor_destroy_frame_callbacks (compositor, surface);

  g_hash_table_foreach (surface->outputs_to_destroy_notify_id, surface_output_disconnect_signal, surface);
@@ -1169,30 +1210,6 @@ wl_surface_destructor (struct wl_resource *resource)
  meta_wayland_compositor_repick (compositor);
 }

-static void
-surface_actor_mapped_notify (MetaSurfaceActorWayland *surface_actor,
-                             GParamSpec              *pspec,
-                             MetaWaylandSurface      *surface)
-{
-  meta_wayland_surface_update_outputs_recursively (surface);
-}
-
-static void
-surface_actor_allocation_notify (MetaSurfaceActorWayland *surface_actor,
-                                 GParamSpec              *pspec,
-                                 MetaWaylandSurface      *surface)
-{
-  meta_wayland_surface_update_outputs_recursively (surface);
-}
-
-static void
-surface_actor_position_notify (MetaSurfaceActorWayland *surface_actor,
-                               GParamSpec              *pspec,
-                               MetaWaylandSurface      *surface)
-{
-  meta_wayland_surface_update_outputs_recursively (surface);
-}
-
 static void
 window_position_changed (MetaWindow         *window,
                         MetaWaylandSurface *surface)
@@ -1200,19 +1217,11 @@ window_position_changed (MetaWindow         *window,
  meta_wayland_surface_update_outputs_recursively (surface);
 }

-void
-meta_wayland_surface_create_surface_actor (MetaWaylandSurface *surface)
+static void
+window_actor_effects_completed (MetaWindowActor    *window_actor,
+                                MetaWaylandSurface *surface)
 {
-  MetaSurfaceActor *surface_actor;
-
-  surface_actor = meta_surface_actor_wayland_new (surface);
-  surface->surface_actor = g_object_ref_sink (surface_actor);
-}
-
-void
-meta_wayland_surface_clear_surface_actor (MetaWaylandSurface *surface)
-{
-  g_clear_object (&surface->surface_actor);
+  meta_wayland_surface_update_outputs_recursively (surface);
 }

 MetaWaylandSurface *
@@ -1229,28 +1238,15 @@ meta_wayland_surface_create (MetaWaylandCompositor *compositor,
  surface->resource = wl_resource_create (client, &wl_surface_interface, wl_resource_get_version (compositor_resource), id);
  wl_resource_set_implementation (surface->resource, &meta_wayland_wl_surface_interface, surface, wl_surface_destructor);

-  surface->surface_actor = g_object_ref_sink (meta_surface_actor_wayland_new (surface));
-
  wl_list_init (&surface->pending_frame_callback_list);

-  g_signal_connect_object (surface->surface_actor,
-                           "notify::allocation",
-                           G_CALLBACK (surface_actor_allocation_notify),
-                           surface, 0);
-  g_signal_connect_object (surface->surface_actor,
-                           "notify::position",
-                           G_CALLBACK (surface_actor_position_notify),
-                           surface, 0);
-  g_signal_connect_object (surface->surface_actor,
-                           "notify::mapped",
-                           G_CALLBACK (surface_actor_mapped_notify),
-                           surface, 0);
-
  sync_drag_dest_funcs (surface);

  surface->outputs_to_destroy_notify_id = g_hash_table_new (NULL, NULL);
  surface->shortcut_inhibited_seats = g_hash_table_new (NULL, NULL);

+  meta_wayland_compositor_notify_surface_id (compositor, id, surface);
+
  return surface;
 }

@@ -1433,7 +1429,7 @@ meta_wayland_surface_get_relative_coordinates (MetaWaylandSurface *surface,
  else
    {
      ClutterActor *actor =
-        CLUTTER_ACTOR (meta_surface_actor_get_texture (surface->surface_actor));
+        CLUTTER_ACTOR (meta_surface_actor_get_texture (meta_wayland_surface_get_actor (surface)));

      clutter_actor_transform_stage_point (actor, abs_x, abs_y, sx, sy);
      *sx /= surface->scale;
@@ -1449,7 +1445,7 @@ meta_wayland_surface_get_absolute_coordinates (MetaWaylandSurface *surface,
                                               float               *y)
 {
  ClutterActor *actor =
-    CLUTTER_ACTOR (meta_surface_actor_get_texture (surface->surface_actor));
+    CLUTTER_ACTOR (meta_surface_actor_get_texture (meta_wayland_surface_get_actor (surface)));
  ClutterVertex sv = {
    .x = sx * surface->scale,
    .y = sy * surface->scale,
@@ -1466,6 +1462,10 @@ static void
 meta_wayland_surface_init (MetaWaylandSurface *surface)
 {
  surface->pending = g_object_new (META_TYPE_WAYLAND_PENDING_STATE, NULL);
+
+  g_signal_connect (surface, "geometry-changed",
+                    G_CALLBACK (meta_wayland_surface_update_outputs_recursively),
+                    NULL);
 }

 static void
@@ -1512,6 +1512,13 @@ meta_wayland_surface_class_init (MetaWaylandSurfaceClass *klass)
                  0, NULL, NULL,
                  g_cclosure_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);
+  surface_signals[SURFACE_GEOMETRY_CHANGED] =
+    g_signal_new ("geometry-changed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
 }

 static void
@@ -1719,3 +1726,18 @@ meta_wayland_surface_is_shortcuts_inhibited (MetaWaylandSurface *surface,

  return g_hash_table_contains (surface->shortcut_inhibited_seats, seat);
 }
+
+MetaSurfaceActor *
+meta_wayland_surface_get_actor (MetaWaylandSurface *surface)
+{
+  if (!surface->role || !META_IS_WAYLAND_ACTOR_SURFACE (surface->role))
+    return NULL;
+
+  return meta_wayland_actor_surface_get_actor (META_WAYLAND_ACTOR_SURFACE (surface->role));
+}
+
+void
+meta_wayland_surface_notify_geometry_changed (MetaWaylandSurface *surface)
+{
+  g_signal_emit (surface, surface_signals[SURFACE_GEOMETRY_CHANGED], 0);
+}
--- a/src/wayland/meta-wayland-surface.h
+++ b/src/wayland/meta-wayland-surface.h
@@ -137,7 +137,6 @@ struct _MetaWaylandSurface
  /* Generic stuff */
  struct wl_resource *resource;
  MetaWaylandCompositor *compositor;
-  MetaSurfaceActor *surface_actor;
  MetaWaylandSurfaceRole *role;
  MetaWindow *window;
  cairo_region_t *input_region;
@@ -231,10 +230,6 @@ void                meta_wayland_surface_unref_buffer_use_count (MetaWaylandSurf
 void                meta_wayland_surface_set_window (MetaWaylandSurface *surface,
                                                     MetaWindow         *window);

-void                meta_wayland_surface_create_surface_actor (MetaWaylandSurface *surface);
-
-void                meta_wayland_surface_clear_surface_actor (MetaWaylandSurface *surface);
-
 void                meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
                                                           int                 new_x,
                                                           int                 new_y,
@@ -303,4 +298,8 @@ void                meta_wayland_surface_restore_shortcuts (MetaWaylandSurface *
 gboolean            meta_wayland_surface_is_shortcuts_inhibited (MetaWaylandSurface *surface,
                                                                 MetaWaylandSeat    *seat);

+MetaSurfaceActor *  meta_wayland_surface_get_actor (MetaWaylandSurface *surface);
+
+void                meta_wayland_surface_notify_geometry_changed (MetaWaylandSurface *surface);
+
 #endif
--- a/src/wayland/meta-wayland-tablet-tool.c
+++ b/src/wayland/meta-wayland-tablet-tool.c
@@ -632,10 +632,13 @@ meta_wayland_tablet_tool_get_relative_coordinates (MetaWaylandTabletTool *tool,
                                                   wl_fixed_t            *sx,
                                                   wl_fixed_t            *sy)
 {
+  MetaSurfaceActor *surface_actor;
  float xf, yf;

+  surface_actor = meta_wayland_surface_get_actor (surface);
+
  clutter_event_get_coords (event, &xf, &yf);
-  clutter_actor_transform_stage_point (CLUTTER_ACTOR (meta_surface_actor_get_texture (surface->surface_actor)),
+  clutter_actor_transform_stage_point (CLUTTER_ACTOR (meta_surface_actor_get_texture (surface_actor)),
                                       xf, yf, &xf, &yf);

  *sx = wl_fixed_from_double (xf) / surface->scale;
--- a/src/wayland/meta-wayland-xdg-shell.c
+++ b/src/wayland/meta-wayland-xdg-shell.c
@@ -608,6 +608,17 @@ is_new_size_hints_valid (MetaWindow              *window,
          (new_max_height == 0 || new_min_height <= new_max_height));
 }

+static inline gboolean
+did_geometry_change (MetaWaylandXdgSurface   *xdg_surface,
+                     MetaWaylandPendingState *pending)
+{
+  MetaWaylandXdgSurfacePrivate *priv =
+    meta_wayland_xdg_surface_get_instance_private (xdg_surface);
+
+  return pending->has_new_geometry &&
+         !meta_rectangle_equal (&priv->geometry, &pending->new_geometry);
+}
+
 static void
 meta_wayland_xdg_toplevel_commit (MetaWaylandSurfaceRole  *surface_role,
                                  MetaWaylandPendingState *pending)
@@ -621,6 +632,7 @@ meta_wayland_xdg_toplevel_commit (MetaWaylandSurfaceRole  *surface_role,
    meta_wayland_surface_role_get_surface (surface_role);
  MetaWindow *window;
  MetaRectangle window_geometry;
+  gboolean geometry_changed;

  if (!surface->buffer_ref.buffer && xdg_surface_priv->first_buffer_attached)
    {
@@ -630,6 +642,10 @@ meta_wayland_xdg_toplevel_commit (MetaWaylandSurfaceRole  *surface_role,

  window = surface->window;

+  /* This check must happen before chaining up, otherwise the new geometry
+   * is applied and it'll always return FALSE. */
+  geometry_changed = did_geometry_change (xdg_surface, pending);
+
  surface_role_class =
    META_WAYLAND_SURFACE_ROLE_CLASS (meta_wayland_xdg_toplevel_parent_class);
  surface_role_class->commit (surface_role, pending);
@@ -643,7 +659,7 @@ meta_wayland_xdg_toplevel_commit (MetaWaylandSurfaceRole  *surface_role,
  if (!pending->newly_attached)
    return;

-  if (pending->has_new_geometry)
+  if (geometry_changed || meta_window_wayland_needs_move_resize (window))
    {
      window_geometry = meta_wayland_xdg_surface_get_window_geometry (xdg_surface);
      meta_window_wayland_move_resize (window,
@@ -707,9 +723,8 @@ meta_wayland_xdg_toplevel_reset (MetaWaylandXdgSurface *xdg_surface)
  surface = meta_wayland_surface_role_get_surface (surface_role);

  meta_wayland_surface_destroy_window (surface);
-  meta_wayland_surface_clear_surface_actor (surface);

-  meta_wayland_surface_create_surface_actor (surface);
+  meta_wayland_actor_surface_reset_actor (META_WAYLAND_ACTOR_SURFACE (surface_role));
  window = meta_window_wayland_new (meta_get_display (), surface);
  meta_wayland_shell_surface_set_window (shell_surface, window);

--- a/src/wayland/meta-wayland.c
+++ b/src/wayland/meta-wayland.c
@@ -46,6 +46,7 @@
 #include "meta-wayland-inhibit-shortcuts.h"
 #include "meta-wayland-inhibit-shortcuts-dialog.h"
 #include "meta-xwayland-grab-keyboard.h"
+#include "meta-xwayland.h"

 static MetaWaylandCompositor _meta_wayland_compositor;
 static char *_display_name_override;
@@ -306,6 +307,8 @@ meta_wayland_compositor_init (MetaWaylandCompositor *compositor)
 {
  memset (compositor, 0, sizeof (MetaWaylandCompositor));
  wl_list_init (&compositor->frame_callbacks);
+
+  compositor->scheduled_surface_associations = g_hash_table_new (NULL, NULL);
 }

 void
@@ -482,3 +485,62 @@ meta_wayland_compositor_flush_clients (MetaWaylandCompositor *compositor)
 {
  wl_display_flush_clients (compositor->wayland_display);
 }
+
+static void on_scheduled_association_unmanaged (MetaWindow *window,
+                                                gpointer    user_data);
+
+static void
+meta_wayland_compositor_remove_surface_association (MetaWaylandCompositor *compositor,
+                                                    int                    id)
+{
+  MetaWindow *window;
+
+  window = g_hash_table_lookup (compositor->scheduled_surface_associations,
+                                GINT_TO_POINTER (id));
+  if (window)
+    {
+      g_signal_handlers_disconnect_by_func (window,
+                                            on_scheduled_association_unmanaged,
+                                            GINT_TO_POINTER (id));
+      g_hash_table_remove (compositor->scheduled_surface_associations,
+                           GINT_TO_POINTER (id));
+    }
+}
+
+static void
+on_scheduled_association_unmanaged (MetaWindow *window,
+                                    gpointer    user_data)
+{
+  MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
+
+  meta_wayland_compositor_remove_surface_association (compositor,
+                                                      GPOINTER_TO_INT (user_data));
+}
+
+void
+meta_wayland_compositor_schedule_surface_association (MetaWaylandCompositor *compositor,
+                                                      int                    id,
+                                                      MetaWindow            *window)
+{
+  g_signal_connect (window, "unmanaged",
+                    G_CALLBACK (on_scheduled_association_unmanaged),
+                    GINT_TO_POINTER (id));
+  g_hash_table_insert (compositor->scheduled_surface_associations,
+                       GINT_TO_POINTER (id), window);
+}
+
+void
+meta_wayland_compositor_notify_surface_id (MetaWaylandCompositor *compositor,
+                                           int                    id,
+                                           MetaWaylandSurface    *surface)
+{
+  MetaWindow *window;
+
+  window = g_hash_table_lookup (compositor->scheduled_surface_associations,
+                                GINT_TO_POINTER (id));
+  if (window)
+    {
+      meta_xwayland_associate_window_with_surface (window, surface);
+      meta_wayland_compositor_remove_surface_association (compositor, id);
+    }
+}
--- a/src/wayland/meta-wayland.h
+++ b/src/wayland/meta-wayland.h
@@ -65,5 +65,12 @@ gboolean                meta_wayland_compositor_is_shortcuts_inhibited (MetaWayl

 void                    meta_wayland_compositor_flush_clients (MetaWaylandCompositor *compositor);

+void                    meta_wayland_compositor_schedule_surface_association (MetaWaylandCompositor *compositor,
+                                                                              int                    id,
+                                                                              MetaWindow            *window);
+void                    meta_wayland_compositor_notify_surface_id (MetaWaylandCompositor *compositor,
+                                                                   int                    id,
+                                                                   MetaWaylandSurface    *surface);
+
 #endif

--- a/src/wayland/meta-window-wayland.c
+++ b/src/wayland/meta-window-wayland.c
@@ -48,6 +48,7 @@ struct _MetaWindowWayland
  int geometry_scale;

  MetaWaylandSerial pending_configure_serial;
+  gboolean has_pending_state_change;
  gboolean has_pending_move;
  int pending_move_x;
  int pending_move_y;
@@ -324,6 +325,9 @@ meta_window_wayland_move_resize_internal (MetaWindow                *window,
          window->buffer_rect.x = new_buffer_x;
          window->buffer_rect.y = new_buffer_y;
        }
+
+      if (flags & META_MOVE_RESIZE_WAYLAND_STATE_CHANGED)
+        *result |= META_MOVE_RESIZE_RESULT_STATE_CHANGED;
    }
  else
    {
@@ -336,6 +340,8 @@ meta_window_wayland_move_resize_internal (MetaWindow                *window,
          wl_window->pending_move_x = new_x;
          wl_window->pending_move_y = new_y;
        }
+
+      wl_window->has_pending_state_change = (flags & META_MOVE_RESIZE_STATE_CHANGED) != 0;
    }
 }

@@ -629,12 +635,9 @@ meta_window_wayland_new (MetaDisplay        *display,
 }

 static gboolean
-should_do_pending_move (MetaWindowWayland *wl_window,
-                        MetaWaylandSerial *acked_configure_serial)
+is_pending_ack_configure (MetaWindowWayland *wl_window,
+                          MetaWaylandSerial *acked_configure_serial)
 {
-  if (!wl_window->has_pending_move)
-    return FALSE;
-
  if (wl_window->pending_configure_serial.set)
    {
      /* If we're waiting for a configure and this isn't an ACK for
@@ -677,6 +680,7 @@ meta_window_wayland_move_resize (MetaWindow        *window,
  int gravity;
  MetaRectangle rect;
  MetaMoveResizeFlags flags;
+  gboolean pending_ack_configure;

  /* new_geom is in the logical pixel coordinate space, but MetaWindow wants its
   * rects to represent what in turn will end up on the stage, i.e. we need to
@@ -700,10 +704,12 @@ meta_window_wayland_move_resize (MetaWindow        *window,

  flags = META_MOVE_RESIZE_WAYLAND_RESIZE;

+  pending_ack_configure = is_pending_ack_configure (wl_window, acked_configure_serial);
+
  /* x/y are ignored when we're doing interactive resizing */
  if (!meta_grab_op_is_resizing (window->display->grab_op))
    {
-      if (wl_window->has_pending_move && should_do_pending_move (wl_window, acked_configure_serial))
+      if (wl_window->has_pending_move && pending_ack_configure)
        {
          rect.x = wl_window->pending_move_x;
          rect.y = wl_window->pending_move_y;
@@ -724,6 +730,12 @@ meta_window_wayland_move_resize (MetaWindow        *window,
        }
    }

+  if (wl_window->has_pending_state_change && pending_ack_configure)
+    {
+      flags |= META_MOVE_RESIZE_WAYLAND_STATE_CHANGED;
+      wl_window->has_pending_state_change = FALSE;
+    }
+
  wl_window->pending_configure_serial.set = FALSE;

  rect.width = new_geom.width;
@@ -903,3 +915,10 @@ meta_window_wayland_get_max_size (MetaWindow *window,
  scale_size (width, height, scale);
 }

+gboolean
+meta_window_wayland_needs_move_resize (MetaWindow *window)
+{
+  MetaWindowWayland *wl_window = META_WINDOW_WAYLAND (window);
+
+  return wl_window->has_pending_state_change || wl_window->has_pending_move;
+}
--- a/src/wayland/meta-window-wayland.h
+++ b/src/wayland/meta-window-wayland.h
@@ -78,5 +78,6 @@ void meta_window_wayland_get_max_size (MetaWindow *window,
                                       int        *width,
                                       int        *height);

+gboolean meta_window_wayland_needs_move_resize (MetaWindow *window);

 #endif
--- a/src/wayland/meta-xwayland.c
+++ b/src/wayland/meta-xwayland.c
@@ -26,6 +26,8 @@
 #include "meta-xwayland.h"
 #include "meta-xwayland-private.h"

+#include <meta/main.h>
+
 #include <glib.h>
 #include <glib-unix.h>
 #include <errno.h>
@@ -58,9 +60,9 @@ G_DEFINE_TYPE (MetaWaylandSurfaceRoleXWayland,
               meta_wayland_surface_role_xwayland,
               META_TYPE_WAYLAND_ACTOR_SURFACE)

-static void
-associate_window_with_surface (MetaWindow         *window,
-                               MetaWaylandSurface *surface)
+void
+meta_xwayland_associate_window_with_surface (MetaWindow          *window,
+                                             MetaWaylandSurface  *surface)
 {
  MetaDisplay *display = window->display;

@@ -108,58 +110,13 @@ associate_window_with_surface_id (MetaXWaylandManager *manager,
  if (resource)
    {
      MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
-      associate_window_with_surface (window, surface);
+      meta_xwayland_associate_window_with_surface (window, surface);
      return TRUE;
    }
  else
    return FALSE;
 }

-typedef struct {
-  MetaXWaylandManager *manager;
-  MetaWindow *window;
-  guint32 surface_id;
-  guint later_id;
-} AssociateWindowWithSurfaceOp;
-
-static void associate_window_with_surface_window_unmanaged (MetaWindow                   *window,
-                                                            AssociateWindowWithSurfaceOp *op);
-static void
-associate_window_with_surface_op_free (AssociateWindowWithSurfaceOp *op)
-{
-  if (op->later_id != 0)
-    meta_later_remove (op->later_id);
-  g_signal_handlers_disconnect_by_func (op->window,
-                                        (gpointer) associate_window_with_surface_window_unmanaged,
-                                        op);
-  g_free (op);
-}
-
-static void
-associate_window_with_surface_window_unmanaged (MetaWindow                   *window,
-                                                AssociateWindowWithSurfaceOp *op)
-{
-  associate_window_with_surface_op_free (op);
-}
-
-static gboolean
-associate_window_with_surface_later (gpointer user_data)
-{
-  AssociateWindowWithSurfaceOp *op = user_data;
-
-  op->later_id = 0;
-
-  if (!associate_window_with_surface_id (op->manager, op->window, op->surface_id))
-    {
-      /* Not here? Oh well... nothing we can do */
-      g_warning ("Unknown surface ID %d (from window %s)", op->surface_id, op->window->desc);
-    }
-
-  associate_window_with_surface_op_free (op);
-
-  return G_SOURCE_REMOVE;
-}
-
 void
 meta_xwayland_handle_wl_surface_id (MetaWindow *window,
                                    guint32     surface_id)
@@ -169,21 +126,11 @@ meta_xwayland_handle_wl_surface_id (MetaWindow *window,

  if (!associate_window_with_surface_id (manager, window, surface_id))
    {
-      /* No surface ID yet... it should arrive after the next
-       * iteration through the loop, so queue a later and see
-       * what happens.
+      /* No surface ID yet, schedule this association for whenever the
+       * surface is made known.
       */
-      AssociateWindowWithSurfaceOp *op = g_new0 (AssociateWindowWithSurfaceOp, 1);
-      op->manager = manager;
-      op->window = window;
-      op->surface_id = surface_id;
-      op->later_id = meta_later_add (META_LATER_BEFORE_REDRAW,
-                                     associate_window_with_surface_later,
-                                     op,
-                                     NULL);
-
-      g_signal_connect (op->window, "unmanaged",
-                        G_CALLBACK (associate_window_with_surface_window_unmanaged), op);
+      meta_wayland_compositor_schedule_surface_association (compositor,
+                                                            surface_id, window);
    }
 }

@@ -393,30 +340,34 @@ xserver_died (GObject      *source,
              gpointer      user_data)
 {
  GSubprocess *proc = G_SUBPROCESS (source);
-  GError *error = NULL;
+  g_autoptr (GError) error = NULL;

  if (!g_subprocess_wait_finish (proc, result, &error))
    {
-      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-        g_error ("Failed to finish waiting for Xwayland: %s", error->message);
-      g_clear_error (&error);
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        return;
+
+      g_warning ("Failed to finish waiting for Xwayland: %s", error->message);
    }
  else if (!g_subprocess_get_successful (proc))
-    g_error ("X Wayland crashed; aborting");
+    g_warning ("X Wayland crashed; exiting");
  else
    {
      /* For now we simply abort if we see the server exit.
       *
       * In the future X will only be loaded lazily for legacy X support
       * but for now it's a hard requirement. */
-      g_error ("Spurious exit of X Wayland server");
+      g_warning ("Spurious exit of X Wayland server");
    }
+
+  meta_exit (META_EXIT_ERROR);
 }

 static int
 x_io_error (Display *display)
 {
-  g_error ("Connection to xwayland lost");
+  g_warning ("Connection to xwayland lost");
+  meta_exit (META_EXIT_ERROR);

  return 0;
 }
--- a/src/wayland/meta-xwayland.h
+++ b/src/wayland/meta-xwayland.h
@@ -41,4 +41,8 @@ void
 meta_xwayland_handle_xwayland_grab (MetaWindow *window,
                                    gboolean    allow);

+void
+meta_xwayland_associate_window_with_surface (MetaWindow          *window,
+                                             MetaWaylandSurface  *surface);
+
 #endif /* META_XWAYLAND_H */
--- a/src/x11/window-x11.c
+++ b/src/x11/window-x11.c
@@ -1282,6 +1282,8 @@ meta_window_x11_move_resize_internal (MetaWindow                *window,
    *result |= META_MOVE_RESIZE_RESULT_MOVED;
  if (need_resize_client || need_resize_frame)
    *result |= META_MOVE_RESIZE_RESULT_RESIZED;
+  if (flags & META_MOVE_RESIZE_STATE_CHANGED)
+    *result |= META_MOVE_RESIZE_RESULT_STATE_CHANGED;

  update_gtk_edge_constraints (window);
 }