Merge ~3v1n0/ubuntu/+source/mutter:ubuntu/bionic into ~ubuntu-desktop/ubuntu/+source/mutter:ubuntu/bionic

[Marco Trevisan (Treviño)]

ce3f911... by Marco Trevisan (Treviño) on 2019-05-03

debian/patches: Ignore new symbols added in switch-config

No need to export new symbols for this one

[Daniel van Vugt (vanvugt)]

Looking good.

review: Approve

[Daniel van Vugt (vanvugt)]

It looks like this has landed. Please close this MP.

diff --git a/debian/changelog b/debian/changelog
index 99219d6..a1467bf 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,21 @@
+mutter (3.28.3+git20190124-0ubuntu18.04.3) UNRELEASED; urgency=medium
+
+  * d/p/monitor-manager-Don-t-use-switch-config-when-ensuring-con.patch,
+    d/p/monitor-manager-use-MonitorsConfig-to-track-switch_config.patch:
+    - Ensure switch display mode is cyclic (LP: #1772811)
+  * d/p/clutter-x11-Implement-keycode-remap-to-keysyms-on-virtual.patch,
+    d/p/clutter-x11-Consider-remapped-keys-when-guessing-the-keyc.patch:
+    - Implement keycode remap to keysyms on virtual key devices (LP: #1827029)
+
+  [ Daniel van Vugt ]
+  * d/p/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch,
+    d/p/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch:
+    - Add support for high frame rate displays (LP: #1763892)
+  * d/p/clutter-Smooth-out-master-clock-to-smooth-visuals.patch:
+    - Dropped
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Mon, 29 Apr 2019 23:29:24 -0500
+
 mutter (3.28.3+git20190124-0ubuntu18.04.2) bionic; urgency=medium
 
   * control: Add Breaks on budgie-desktop verions broken by this upload.
diff --git a/debian/patches/clutter-Smooth-out-master-clock-to-smooth-visuals.patch b/debian/patches/clutter-Smooth-out-master-clock-to-smooth-visuals.patch
 deleted file mode 100644
index 2239837..0000000
--- a/debian/patches/clutter-Smooth-out-master-clock-to-smooth-visuals.patch
+++ /dev/null
@@ -1,225 +0,0 @@
-From: Daniel van Vugt <[e-mail]>
-Date: Fri, 16 Feb 2018 02:50:59 -0600
-Subject: clutter: Smooth out master clock to smooth visuals
-
-Clutter's master clock was jittery because it included errors in cur_tick
-such as dispatch delays due to other sources. Dispatch could also occur up
-to 1ms early since GSource can only be timed to the millisecond. All of this
-could impact the visual smoothness of animations as they are displayed on
-the steady interval of the monitor, but spacially moving in less regular
-steps derived from the dispatch times.
-
-The simple fix is to ignore any jitter in dispatch timing. Try a little
-bit harder to use a precise interval that will better match the display
-hardware, and smoother visuals will follow.
-
-Bug: https://gitlab.gnome.org/GNOME/mutter/issues/25
-Forwarded: https://gitlab.gnome.org/GNOME/mutter/merge_requests/70
----
- clutter/clutter/clutter-master-clock-default.c | 134 +++++++++++++++++--------
- 1 file changed, 93 insertions(+), 41 deletions(-)
-
-diff --git a/clutter/clutter/clutter-master-clock-default.c b/clutter/clutter/clutter-master-clock-default.c
-index 7b2df0d..97b6d13 100644
---- a/clutter/clutter/clutter-master-clock-default.c
-+++ b/clutter/clutter/clutter-master-clock-default.c
-@@ -69,8 +69,10 @@ struct _ClutterMasterClockDefault
-   /* the previous state of the clock, in usecs, used to compute the delta */
-   gint64 prev_tick;
- 
-+  /* the ideal frame interval in usecs (inverse of your max refresh rate) */
-+  gint64 frame_interval;
-+
- #ifdef CLUTTER_ENABLE_DEBUG
--  gint64 frame_budget;
-   gint64 remaining_budget;
- #endif
- 
-@@ -264,6 +266,41 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
-     }
- }
- 
-+static gint64
-+estimate_next_presentation_time (ClutterMasterClockDefault *master_clock)
-+{
-+  gint64 frame_phase, now, now_phase, undershoot;
-+
-+  /* In future if this was updated from the backend's (maximum) refresh rate
-+   * then that would fix: https://bugzilla.gnome.org/show_bug.cgi?id=781296
-+   */
-+  master_clock->frame_interval = G_USEC_PER_SEC /
-+                                 clutter_get_default_frame_rate ();
-+
-+  now = g_source_get_time (master_clock->source);
-+  now_phase = now % master_clock->frame_interval;
-+
-+  /* To be precise we would like to use:
-+   *   frame_phase = a_recent_hardware_presentation_time % frame_interval;
-+   * where hardware_presentation_time must be using the same clock as
-+   * g_source_get_time. Unfortunately they're different clocks right now
-+   * so we can't.
-+   *   Alternatively, we could replace g_source_get_time in future with the
-+   * current time in the clutter/cogl presentation clock, but that function
-+   * also doesn't exist yet.
-+   *   Until we can get either of those, zero is fine. It just means latency
-+   * will be suboptimal by half a frame on average. We still get maximum
-+   * smoothness this way...
-+   */
-+  frame_phase = 0;
-+
-+  undershoot = frame_phase - now_phase;
-+  if (undershoot < 0)
-+    undershoot += master_clock->frame_interval;
-+
-+  return now + undershoot;
-+}
-+
- /*
-  * master_clock_next_frame_delay:
-  * @master_clock: a #ClutterMasterClock
-@@ -276,7 +313,8 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
- static gint
- master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
- {
--  gint64 now, next;
-+  gint64 now, target_presentation_time, ideal_render_start;  /* timestamps */
-+  gint64 ideal_prerender_time, lateness;  /* deltas */
-   gint swap_delay;
- 
-   if (!master_clock_is_running (master_clock))
-@@ -307,46 +345,45 @@ master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
-       return 0;
-     }
- 
--  if (master_clock->prev_tick == 0)
--    {
--      /* If we weren't previously running, then draw the next frame
--       * immediately
--       */
--      CLUTTER_NOTE (SCHEDULER, "draw the first frame immediately");
--      return 0;
--    }
--
--  /* Otherwise, wait at least 1/frame_rate seconds since we last
--   * started a frame
--   */
-   now = g_source_get_time (master_clock->source);
- 
--  next = master_clock->prev_tick;
--
--  /* If time has gone backwards then there's no way of knowing how
--     long we should wait so let's just dispatch immediately */
--  if (now <= next)
-+  /* As first preference, try to carry on smoothly from the previous frame,
-+   * even if that means we start rendering frame 2 before frame 1 has been
-+   * presented. This is why we ignore estimate_next_presentation_time here...
-+   */
-+  target_presentation_time = master_clock->prev_tick +
-+                             master_clock->frame_interval;
-+  ideal_prerender_time = master_clock->frame_interval;
-+  ideal_render_start = target_presentation_time - ideal_prerender_time;
-+  lateness = now - ideal_render_start;
-+
-+  /* If we just woke from idle then try to improve the smoothness of the first
-+   * two frames some more. Otherwise the first frame would appear too old
-+   * relative to the second frame.
-+   */
-+  if (lateness >= master_clock->frame_interval)
-     {
--      CLUTTER_NOTE (SCHEDULER, "Time has gone backwards");
--
--      return 0;
-+      target_presentation_time = estimate_next_presentation_time (master_clock);
-+      ideal_render_start = target_presentation_time - ideal_prerender_time;
-+      lateness = now - ideal_render_start;
-     }
- 
--  next += (1000000L / clutter_get_default_frame_rate ());
--
--  if (next <= now)
-+  if (lateness > 0)
-     {
--      CLUTTER_NOTE (SCHEDULER, "Less than %lu microsecs",
--                    1000000L / (gulong) clutter_get_default_frame_rate ());
--
-+      CLUTTER_NOTE (SCHEDULER, "No wait required. We're already late.");
-       return 0;
-     }
-   else
-     {
--      CLUTTER_NOTE (SCHEDULER, "Waiting %" G_GINT64_FORMAT " msecs",
--                   (next - now) / 1000);
--
--      return (next - now) / 1000;
-+      /* We +1 here to avoid premature dispatches that would otherwise occur
-+       * repeatedly during the 1ms before 'ideal_render_start'. We don't care
-+       * if this makes the final dispatch 1ms late because the smoothing
-+       * algorithm corrects that, and it's much better than attempting to
-+       * render more frames than the hardware can physically display...
-+       */
-+      gint millisec_delay = -lateness / 1000 + 1;
-+      CLUTTER_NOTE (SCHEDULER, "Waiting %dms", millisec_delay);
-+      return millisec_delay;
-     }
- }
- 
-@@ -532,16 +569,34 @@ clutter_clock_dispatch (GSource     *source,
-   ClutterMasterClockDefault *master_clock = clock_source->master_clock;
-   gboolean stages_updated = FALSE;
-   GSList *stages;
--
--  CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
-+  gint64 smooth_tick;
- 
-   _clutter_threads_acquire_lock ();
- 
-   /* Get the time to use for this frame */
--  master_clock->cur_tick = g_source_get_time (source);
-+  smooth_tick = estimate_next_presentation_time (master_clock);
-+  if (smooth_tick <= master_clock->prev_tick)
-+    {
-+      /* Ordinarily this will never happen. But after we fix bug 781296, it
-+       * could happen in the rare case when the ideal frame_interval changes,
-+       * such as video mode switching or hotplugging monitors. As such it is
-+       * not considered a bug (unless it's happening without mode switching
-+       * or hotplugging).
-+       */
-+      CLUTTER_NOTE (SCHEDULER, "Master clock [tick] was premature (skipped)");
-+      _clutter_threads_release_lock ();
-+      return G_SOURCE_CONTINUE;
-+    }
-+
-+  master_clock->cur_tick = smooth_tick;
-+  if (master_clock->prev_tick)
-+    CLUTTER_NOTE (SCHEDULER, "Master clock [tick] %+ldus",
-+                  (long) (master_clock->cur_tick - master_clock->prev_tick));
-+  else
-+    CLUTTER_NOTE (SCHEDULER, "Master clock [tick] startup");
- 
- #ifdef CLUTTER_ENABLE_DEBUG
--  master_clock->remaining_budget = master_clock->frame_budget;
-+  master_clock->remaining_budget = master_clock->frame_interval;
- #endif
- 
-   /* We need to protect ourselves against stages being destroyed during
-@@ -580,7 +635,7 @@ clutter_clock_dispatch (GSource     *source,
- 
-   _clutter_threads_release_lock ();
- 
--  return TRUE;
-+  return G_SOURCE_CONTINUE;
- }
- 
- static void
-@@ -612,10 +667,7 @@ clutter_master_clock_default_init (ClutterMasterClockDefault *self)
-   self->idle = FALSE;
-   self->ensure_next_iteration = FALSE;
-   self->paused = FALSE;
--
--#ifdef CLUTTER_ENABLE_DEBUG
--  self->frame_budget = G_USEC_PER_SEC / 60;
--#endif
-+  self->frame_interval = G_USEC_PER_SEC / 60; /* Will be refined at runtime */
- 
-   g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
-   g_source_set_can_recurse (source, FALSE);
diff --git a/debian/patches/clutter-x11-Consider-remapped-keys-when-guessing-the-keyc.patch b/debian/patches/clutter-x11-Consider-remapped-keys-when-guessing-the-keyc.patch
 new file mode 100644
index 0000000..e2d3140
--- /dev/null
+++ b/debian/patches/clutter-x11-Consider-remapped-keys-when-guessing-the-keyc.patch
@@ -0,0 +1,53 @@
+From: Andrea Azzarone <[e-mail]>
+Date: Tue, 22 Jan 2019 11:20:37 -0600
+Subject: clutter/x11: Consider remapped keys when guessing the keycode from
+ the keysym
+
+Since e3e933c4 a keyval can be temporarily remapped to an unused keycode. Due to
+some limitations in XTestFakeKeyEvent, the remapping has to be done in the first
+xkb group/layout. In case there are two or more keyboard layouts enabled and the
+selected keyboard layout is not the first, clutter_keymap_x11_keycode_for_keyval
+will fail to retrieve the correct keycode for a remapped keyval. Let's use the
+reserved_keycodes map in order to retrieve the correct keycode if needed.
+
+Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/443
+
+GNOME-Bug: https://gitlab.gnome.org/GNOME/mutter/issues/443
+Ubuntu-Bug: https://bugs.launchpad.net/ubuntu/+source/gnome-shell/+bug/1827029
+Origin: https://gitlab.gnome.org/GNOME/mutter/commit/24b4c82
+Applied-Upstream: 3.28.4
+---
+ clutter/clutter/x11/clutter-keymap-x11.c | 20 ++++++++++++++++++++
+ 1 file changed, 20 insertions(+)
+
+diff --git a/clutter/clutter/x11/clutter-keymap-x11.c b/clutter/clutter/x11/clutter-keymap-x11.c
+index 5dd40a9..f1bdf16 100644
+--- a/clutter/clutter/x11/clutter-keymap-x11.c
++++ b/clutter/clutter/x11/clutter-keymap-x11.c
+@@ -1005,6 +1005,26 @@ clutter_keymap_x11_keycode_for_keyval (ClutterKeymapX11 *keymap_x11,
+         }
+     }
+ 
++  if (!found)
++    {
++      GHashTableIter iter;
++      gpointer key, value;
++
++      g_hash_table_iter_init (&iter, keymap_x11->reserved_keycodes);
++      while (!found && g_hash_table_iter_next (&iter, &key, &value))
++        {
++          guint reserved_keycode = GPOINTER_TO_UINT (key);
++          guint reserved_keysym = GPOINTER_TO_UINT (value);
++
++          if (keyval == reserved_keysym)
++            {
++              *keycode_out = reserved_keycode;
++              *level_out = 0;
++              found = TRUE;
++            }
++        }
++    }
++
+   g_free (keys);
+   return found;
+ }
diff --git a/debian/patches/clutter-x11-Implement-keycode-remap-to-keysyms-on-virtual.patch b/debian/patches/clutter-x11-Implement-keycode-remap-to-keysyms-on-virtual.patch
 new file mode 100644
index 0000000..944e1ea
--- /dev/null
+++ b/debian/patches/clutter-x11-Implement-keycode-remap-to-keysyms-on-virtual.patch
@@ -0,0 +1,294 @@
+From: Andrea Azzarone <[e-mail]>
+Date: Fri, 13 Jul 2018 07:49:38 -0500
+Subject: clutter/x11: Implement keycode remap to keysyms on virtual key
+ devices
+
+Keycode lookup can fail for serveral reasons, e.g. if there is no combination of
+modifiers and keycodes that can produce the target keysym with the current
+keyboard layout.
+
+In case the keycode lookup fails, remap temporarily the keysym to an unused
+keycodes.
+
+Fixes: https://gitlab.gnome.org/GNOME/gnome-shell/issues/109
+
+GNOME-Bug: https://gitlab.gnome.org/GNOME/mutter/issues/109
+Ubuntu-Bug: https://bugs.launchpad.net/ubuntu/+source/gnome-shell/+bug/1827029
+Origin: https://gitlab.gnome.org/GNOME/mutter/commit/6198d389
+Applied-Upstream: 3.28.4
+---
+ clutter/clutter/x11/clutter-keymap-x11.c           | 167 +++++++++++++++++++++
+ clutter/clutter/x11/clutter-keymap-x11.h           |   6 +-
+ .../clutter/x11/clutter-virtual-input-device-x11.c |  19 ++-
+ 3 files changed, 186 insertions(+), 6 deletions(-)
+
+diff --git a/clutter/clutter/x11/clutter-keymap-x11.c b/clutter/clutter/x11/clutter-keymap-x11.c
+index c34e676..5dd40a9 100644
+--- a/clutter/clutter/x11/clutter-keymap-x11.c
++++ b/clutter/clutter/x11/clutter-keymap-x11.c
+@@ -79,6 +79,9 @@ struct _ClutterKeymapX11
+   guint current_cache_serial;
+   DirectionCacheEntry group_direction_cache[4];
+   int current_group;
++
++  GHashTable *reserved_keycodes;
++  GQueue *available_keycodes;
+ #endif
+ 
+   guint caps_lock_state : 1;
+@@ -441,16 +444,100 @@ clutter_keymap_x11_set_property (GObject      *gobject,
+     }
+ }
+ 
++#ifdef HAVE_XKB
++static void
++clutter_keymap_x11_refresh_reserved_keycodes (ClutterKeymapX11 *keymap_x11)
++{
++  Display *dpy = clutter_x11_get_default_display ();
++  GHashTableIter iter;
++  gpointer key, value;
++
++  g_hash_table_iter_init (&iter, keymap_x11->reserved_keycodes);
++  while (g_hash_table_iter_next (&iter, &key, &value))
++    {
++      guint reserved_keycode = GPOINTER_TO_UINT (key);
++      guint reserved_keysym = GPOINTER_TO_UINT (value);
++      guint actual_keysym = XkbKeycodeToKeysym (dpy, reserved_keycode, 0, 0);
++
++      /* If an available keycode is no longer mapped to the stored keysym, then
++       * the keycode should not be considered available anymore and should be
++       * removed both from the list of available and reserved keycodes.
++       */
++      if (reserved_keysym != actual_keysym)
++        {
++          g_hash_table_iter_remove (&iter);
++          g_queue_remove (keymap_x11->available_keycodes, key);
++        }
++    }
++}
++
++static gboolean
++clutter_keymap_x11_replace_keycode (ClutterKeymapX11 *keymap_x11,
++                                    KeyCode           keycode,
++                                    KeySym            keysym)
++{
++  if (CLUTTER_BACKEND_X11 (keymap_x11->backend)->use_xkb)
++    {
++      Display *dpy = clutter_x11_get_default_display ();
++      XkbDescPtr xkb = get_xkb (keymap_x11);
++      XkbMapChangesRec changes;
++
++      XFlush (dpy);
++
++      xkb->device_spec = XkbUseCoreKbd;
++      memset (&changes, 0, sizeof(changes));
++
++      if (keysym != NoSymbol)
++        {
++          int types[XkbNumKbdGroups] = { XkbOneLevelIndex };
++          XkbChangeTypesOfKey (xkb, keycode, 1, XkbGroup1Mask, types, &changes);
++          XkbKeySymEntry (xkb, keycode, 0, 0) = keysym;
++        }
++      else
++        {
++          /* Reset to NoSymbol */
++          XkbChangeTypesOfKey (xkb, keycode, 0, XkbGroup1Mask, NULL, &changes);
++        }
++
++      changes.changed = XkbKeySymsMask | XkbKeyTypesMask;
++      changes.first_key_sym = keycode;
++      changes.num_key_syms = 1;
++      changes.first_type = 0;
++      changes.num_types = xkb->map->num_types;
++      XkbChangeMap (dpy, xkb, &changes);
++
++      XFlush (dpy);
++
++      return TRUE;
++    }
++
++  return FALSE;
++}
++#endif
++
+ static void
+ clutter_keymap_x11_finalize (GObject *gobject)
+ {
+   ClutterKeymapX11 *keymap;
+   ClutterEventTranslator *translator;
++  GHashTableIter iter;
++  gpointer key, value;
+ 
+   keymap = CLUTTER_KEYMAP_X11 (gobject);
+   translator = CLUTTER_EVENT_TRANSLATOR (keymap);
+ 
+ #ifdef HAVE_XKB
++  clutter_keymap_x11_refresh_reserved_keycodes (keymap);
++  g_hash_table_iter_init (&iter, keymap->reserved_keycodes);
++  while (g_hash_table_iter_next (&iter, &key, &value))
++    {
++      guint keycode = GPOINTER_TO_UINT (key);
++      clutter_keymap_x11_replace_keycode (keymap, keycode, NoSymbol);
++    }
++
++  g_hash_table_destroy (keymap->reserved_keycodes);
++  g_queue_free (keymap->available_keycodes);
++
+   _clutter_backend_remove_event_translator (keymap->backend, translator);
+ 
+   if (keymap->xkb_desc != NULL)
+@@ -460,6 +547,7 @@ clutter_keymap_x11_finalize (GObject *gobject)
+   G_OBJECT_CLASS (clutter_keymap_x11_parent_class)->finalize (gobject);
+ }
+ 
++
+ static void
+ clutter_keymap_x11_class_init (ClutterKeymapX11Class *klass)
+ {
+@@ -483,6 +571,11 @@ clutter_keymap_x11_init (ClutterKeymapX11 *keymap)
+ {
+   keymap->current_direction = PANGO_DIRECTION_NEUTRAL;
+   keymap->current_group = -1;
++
++#ifdef HAVE_XKB
++  keymap->reserved_keycodes = g_hash_table_new (NULL, NULL);
++  keymap->available_keycodes = g_queue_new ();
++#endif
+ }
+ 
+ static ClutterTranslateReturn
+@@ -766,6 +859,80 @@ clutter_keymap_x11_get_entries_for_keyval (ClutterKeymapX11  *keymap_x11,
+     }
+ }
+ 
++#ifdef HAVE_XKB
++static guint
++clutter_keymap_x11_get_available_keycode (ClutterKeymapX11 *keymap_x11)
++{
++  if (CLUTTER_BACKEND_X11 (keymap_x11->backend)->use_xkb)
++    {
++      clutter_keymap_x11_refresh_reserved_keycodes (keymap_x11);
++
++      if (g_hash_table_size (keymap_x11->reserved_keycodes) < 5)
++        {
++          Display *dpy = clutter_x11_get_default_display ();
++          XkbDescPtr xkb = get_xkb (keymap_x11);
++          guint i;
++
++          for (i = xkb->max_key_code; i >= xkb->min_key_code; --i)
++            {
++              if (XkbKeycodeToKeysym (dpy, i, 0, 0) == NoSymbol)
++                return i;
++            }
++        }
++
++      return GPOINTER_TO_UINT (g_queue_pop_head (keymap_x11->available_keycodes));
++    }
++
++  return 0;
++}
++#endif
++
++gboolean clutter_keymap_x11_reserve_keycode (ClutterKeymapX11 *keymap_x11,
++                                             guint             keyval,
++                                             guint            *keycode_out)
++{
++  g_return_val_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap_x11), FALSE);
++  g_return_val_if_fail (keyval != 0, FALSE);
++  g_return_val_if_fail (keycode_out != NULL, FALSE);
++
++#ifdef HAVE_XKB
++  *keycode_out = clutter_keymap_x11_get_available_keycode (keymap_x11);
++
++  if (*keycode_out == NoSymbol)
++    {
++      g_warning ("Cannot reserve a keycode for keyval %d: no available keycode", keyval);
++      return FALSE;
++    }
++
++  if (!clutter_keymap_x11_replace_keycode (keymap_x11, *keycode_out, keyval))
++    {
++      g_warning ("Failed to remap keycode %d to keyval %d", *keycode_out, keyval);
++      return FALSE;
++    }
++
++  g_hash_table_insert (keymap_x11->reserved_keycodes, GUINT_TO_POINTER (*keycode_out), GUINT_TO_POINTER (keyval));
++  g_queue_remove (keymap_x11->available_keycodes, GUINT_TO_POINTER (*keycode_out));
++
++  return TRUE;
++#else
++  return FALSE;
++#endif
++}
++
++void clutter_keymap_x11_release_keycode_if_needed (ClutterKeymapX11 *keymap_x11,
++                                                   guint             keycode)
++{
++  g_return_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap_x11));
++
++#ifdef HAVE_XKB
++  if (!g_hash_table_contains (keymap_x11->reserved_keycodes, GUINT_TO_POINTER (keycode)) ||
++      g_queue_index (keymap_x11->available_keycodes, GUINT_TO_POINTER (keycode)) != -1)
++    return;
++
++  g_queue_push_tail (keymap_x11->available_keycodes, GUINT_TO_POINTER (keycode));
++#endif
++}
++
+ void
+ clutter_keymap_x11_latch_modifiers (ClutterKeymapX11 *keymap_x11,
+                                     uint32_t          level,
+diff --git a/clutter/clutter/x11/clutter-keymap-x11.h b/clutter/clutter/x11/clutter-keymap-x11.h
+index 4b5b403..4decb44 100644
+--- a/clutter/clutter/x11/clutter-keymap-x11.h
++++ b/clutter/clutter/x11/clutter-keymap-x11.h
+@@ -58,7 +58,11 @@ gboolean clutter_keymap_x11_keycode_for_keyval (ClutterKeymapX11 *keymap_x11,
+ void     clutter_keymap_x11_latch_modifiers (ClutterKeymapX11 *keymap_x11,
+                                              uint32_t          level,
+                                              gboolean          enable);
+-
++gboolean clutter_keymap_x11_reserve_keycode (ClutterKeymapX11 *keymap_x11,
++                                             guint             keyval,
++                                             guint            *keycode_out);
++void     clutter_keymap_x11_release_keycode_if_needed (ClutterKeymapX11 *keymap_x11,
++                                                       guint             keycode);
+ G_END_DECLS
+ 
+ #endif /* __CLUTTER_KEYMAP_X11_H__ */
+diff --git a/clutter/clutter/x11/clutter-virtual-input-device-x11.c b/clutter/clutter/x11/clutter-virtual-input-device-x11.c
+index e16ba3f..cab26c3 100644
+--- a/clutter/clutter/x11/clutter-virtual-input-device-x11.c
++++ b/clutter/clutter/x11/clutter-virtual-input-device-x11.c
+@@ -143,8 +143,13 @@ clutter_virtual_input_device_x11_notify_keyval (ClutterVirtualInputDevice *virtu
+ 
+   if (!clutter_keymap_x11_keycode_for_keyval (keymap, keyval, &keycode, &level))
+     {
+-      g_warning ("No keycode found for keyval %x in current group", keyval);
+-      return;
++      level = 0;
++
++      if (!clutter_keymap_x11_reserve_keycode (keymap, keyval, &keycode))
++        {
++          g_warning ("No keycode found for keyval %x in current group", keyval);
++          return;
++        }
+     }
+ 
+   if (!_clutter_keymap_x11_get_is_modifier (keymap, keycode) &&
+@@ -155,9 +160,13 @@ clutter_virtual_input_device_x11_notify_keyval (ClutterVirtualInputDevice *virtu
+                      (KeyCode) keycode,
+                      key_state == CLUTTER_KEY_STATE_PRESSED, 0);
+ 
+-  if (!_clutter_keymap_x11_get_is_modifier (keymap, keycode) &&
+-      key_state == CLUTTER_KEY_STATE_RELEASED)
+-    clutter_keymap_x11_latch_modifiers (keymap, level, FALSE);
++
++  if (key_state == CLUTTER_KEY_STATE_RELEASED)
++    {
++      if (!_clutter_keymap_x11_get_is_modifier (keymap, keycode))
++        clutter_keymap_x11_latch_modifiers (keymap, level, FALSE);
++      clutter_keymap_x11_release_keycode_if_needed (keymap, keycode);
++    }
+ }
+ 
+ static void
diff --git a/debian/patches/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch b/debian/patches/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
 new file mode 100644
index 0000000..1e5958e
--- /dev/null
+++ b/debian/patches/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
@@ -0,0 +1,372 @@
+From: Daniel van Vugt <[e-mail]>
+Date: Fri, 3 May 2019 11:31:08 -0500
+Subject: renderer-native: Add hardware presentation timing
+
+Add support for getting hardware presentation times from KMS (Wayland
+sessions). Also implement cogl_get_clock_time which is required to compare
+and judge the age of presentation timestamps.
+
+For single monitor systems this is straightforward. For multi-monitor
+systems though we have to choose a display to sync to. The compositor
+already partially solves this for us in the case of only one display
+updating because it will only use the subset of monitors that are
+changing. In the case of multiple monitors consuming the same frame
+concurrently however, we choose the fastest one (in use at the time).
+
+Patch 1 of 2
+
+Origin: https://gitlab.gnome.org/vanvugt/mutter/commits/add-vsync-3.28
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=781296
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1763892
+Applied-Upstream: https://gitlab.gnome.org/vanvugt/mutter/commit/e9e4b2b7
+Forwarded: yes
+Last-Update: 2019-03-13
+---
+ src/Makefile.am                            | 25 ++++++++++-
+ src/backends/native/meta-gpu-kms.c         | 69 +++++++++++++++++++++++++++---
+ src/backends/native/meta-gpu-kms.h         |  3 ++
+ src/backends/native/meta-renderer-native.c | 38 +++++++++++++++-
+ src/meta-marshal.list                      |  1 +
+ 5 files changed, 128 insertions(+), 8 deletions(-)
+ create mode 100644 src/meta-marshal.list
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index bcb3505..13862e9 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -51,6 +51,8 @@ mutter_built_sources = \
+ 	$(dbus_login1_built_sources)		\
+ 	meta/meta-enum-types.h			\
+ 	meta-enum-types.c			\
++	meta-marshal.c	        		\
++	meta-marshal.h		        	\
+ 	$(NULL)
+ 
+ if HAVE_REMOTE_DESKTOP
+@@ -653,6 +655,7 @@ EXTRA_DIST +=					\
+ 	libmutter.pc.in				\
+ 	meta-enum-types.h.in			\
+ 	meta-enum-types.c.in			\
++	meta-marshal.list			\
+ 	org.freedesktop.login1.xml		\
+ 	org.gnome.Mutter.DisplayConfig.xml	\
+ 	org.gnome.Mutter.IdleMonitor.xml	\
+@@ -666,7 +669,10 @@ BUILT_SOURCES =					\
+ 	$(libmutterinclude_built_headers)
+ 
+ MUTTER_STAMP_FILES = stamp-meta-enum-types.h
+-CLEANFILES += $(MUTTER_STAMP_FILES)
++CLEANFILES +=					\
++	$(MUTTER_STAMP_FILES)			\
++	meta-marshal.c	        		\
++	meta-marshal.h
+ 
+ meta/meta-enum-types.h: stamp-meta-enum-types.h Makefile
+ 	@true
+@@ -760,3 +766,20 @@ endef
+ 	$(AM_V_GEN)$(WAYLAND_SCANNER) code $< $@
+ %-server-protocol.h : $(srcdir)/wayland/protocol/%.xml
+ 	$(AM_V_GEN)$(WAYLAND_SCANNER) server-header $< $@
++
++meta_marshal_opts = --prefix=meta_marshal --internal
++
++meta-marshal.h: meta-marshal.list
++	$(AM_V_GEN)$(GLIB_GENMARSHAL) \
++		--header \
++		$(meta_marshal_opts) \
++		--output=$@ \
++		$<
++
++meta-marshal.c: meta-marshal.list meta-marshal.h
++	$(AM_V_GEN)$(GLIB_GENMARSHAL) \
++		--include-header=meta-marshal.h \
++		$(meta_marshal_opts) \
++		--body \
++		--output=$@ \
++		$<
+diff --git a/src/backends/native/meta-gpu-kms.c b/src/backends/native/meta-gpu-kms.c
+index 815caf5..02649c5 100644
+--- a/src/backends/native/meta-gpu-kms.c
++++ b/src/backends/native/meta-gpu-kms.c
+@@ -27,6 +27,7 @@
+ #include <errno.h>
+ #include <poll.h>
+ #include <string.h>
++#include <time.h>
+ #include <xf86drm.h>
+ #include <xf86drmMode.h>
+ 
+@@ -51,6 +52,7 @@ typedef struct _MetaGpuKmsFlipClosureContainer
+ {
+   GClosure *flip_closure;
+   MetaGpuKms *gpu_kms;
++  MetaCrtc *crtc;
+ } MetaGpuKmsFlipClosureContainer;
+ 
+ struct _MetaGpuKms
+@@ -61,6 +63,8 @@ struct _MetaGpuKms
+   char *file_path;
+   GSource *source;
+ 
++  clockid_t clock_id;
++
+   drmModeConnector **connectors;
+   unsigned int n_connectors;
+ 
+@@ -166,18 +170,26 @@ meta_gpu_kms_apply_crtc_mode (MetaGpuKms *gpu_kms,
+ 
+ static void
+ invoke_flip_closure (GClosure   *flip_closure,
+-                     MetaGpuKms *gpu_kms)
++                     MetaGpuKms *gpu_kms,
++                     MetaCrtc   *crtc,
++                     int64_t     page_flip_time_ns)
+ {
+   GValue params[] = {
+     G_VALUE_INIT,
+-    G_VALUE_INIT
++    G_VALUE_INIT,
++    G_VALUE_INIT,
++    G_VALUE_INIT,
+   };
+ 
+   g_value_init (&params[0], G_TYPE_POINTER);
+   g_value_set_pointer (&params[0], flip_closure);
+   g_value_init (&params[1], G_TYPE_OBJECT);
+   g_value_set_object (&params[1], gpu_kms);
+-  g_closure_invoke (flip_closure, NULL, 2, params, NULL);
++  g_value_init (&params[2], G_TYPE_OBJECT);
++  g_value_set_object (&params[2], crtc);
++  g_value_init (&params[3], G_TYPE_INT64);
++  g_value_set_int64 (&params[3], page_flip_time_ns);
++  g_closure_invoke (flip_closure, NULL, 4, params, NULL);
+   g_closure_unref (flip_closure);
+ }
+ 
+@@ -217,6 +229,7 @@ meta_gpu_kms_is_crtc_active (MetaGpuKms *gpu_kms,
+ 
+ MetaGpuKmsFlipClosureContainer *
+ meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms,
++                                MetaCrtc   *crtc,
+                                 GClosure   *flip_closure)
+ {
+   MetaGpuKmsFlipClosureContainer *closure_container;
+@@ -224,7 +237,8 @@ meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms,
+   closure_container = g_new0 (MetaGpuKmsFlipClosureContainer, 1);
+   *closure_container = (MetaGpuKmsFlipClosureContainer) {
+     .flip_closure = flip_closure,
+-    .gpu_kms = gpu_kms
++    .gpu_kms = gpu_kms,
++    .crtc = crtc
+   };
+ 
+   return closure_container;
+@@ -264,6 +278,7 @@ meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms,
+       int kms_fd = meta_gpu_kms_get_fd (gpu_kms);
+ 
+       closure_container = meta_gpu_kms_wrap_flip_closure (gpu_kms,
++                                                          crtc,
+                                                           flip_closure);
+ 
+       ret = drmModePageFlip (kms_fd,
+@@ -297,6 +312,23 @@ meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms,
+   return TRUE;
+ }
+ 
++static int64_t
++timespec_to_nanoseconds (const struct timespec *ts)
++{
++  const int64_t one_billion = 1000000000;
++
++  return ((int64_t) ts->tv_sec) * one_billion + ts->tv_nsec;
++}
++
++static int64_t
++timeval_to_nanoseconds (const struct timeval *tv)
++{
++  int64_t usec = ((int64_t) tv->tv_sec) * G_USEC_PER_SEC + tv->tv_usec;
++  int64_t nsec = usec * 1000;
++
++  return nsec;
++}
++
+ static void
+ page_flip_handler (int           fd,
+                    unsigned int  frame,
+@@ -307,8 +339,12 @@ page_flip_handler (int           fd,
+   MetaGpuKmsFlipClosureContainer *closure_container = user_data;
+   GClosure *flip_closure = closure_container->flip_closure;
+   MetaGpuKms *gpu_kms = closure_container->gpu_kms;
++  struct timeval page_flip_time = {sec, usec};
+ 
+-  invoke_flip_closure (flip_closure, gpu_kms);
++  invoke_flip_closure (flip_closure,
++                       gpu_kms,
++                       closure_container->crtc,
++                       timeval_to_nanoseconds (&page_flip_time));
+   meta_gpu_kms_flip_closure_container_free (closure_container);
+ }
+ 
+@@ -381,6 +417,17 @@ meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms)
+   return gpu_kms->file_path;
+ }
+ 
++int64_t
++_meta_gpu_kms_get_current_time_ns (MetaGpuKms *gpu_kms)
++{
++  struct timespec ts;
++
++  if (clock_gettime (gpu_kms->clock_id, &ts))
++    return 0;
++
++  return timespec_to_nanoseconds (&ts);
++}
++
+ void
+ meta_gpu_kms_set_power_save_mode (MetaGpuKms *gpu_kms,
+                                   uint64_t    state)
+@@ -680,6 +727,17 @@ init_crtcs (MetaGpuKms       *gpu_kms,
+   meta_gpu_take_crtcs (gpu, crtcs);
+ }
+ 
++static void
++init_frame_clock (MetaGpuKms *gpu_kms)
++{
++  uint64_t uses_monotonic;
++
++  if (drmGetCap (gpu_kms->fd, DRM_CAP_TIMESTAMP_MONOTONIC, &uses_monotonic) != 0)
++    uses_monotonic = 0;
++
++  gpu_kms->clock_id = uses_monotonic ? CLOCK_MONOTONIC : CLOCK_REALTIME;
++}
++
+ static void
+ init_outputs (MetaGpuKms       *gpu_kms,
+               MetaKmsResources *resources)
+@@ -809,6 +867,7 @@ meta_gpu_kms_read_current (MetaGpu  *gpu,
+   init_modes (gpu_kms, resources.resources);
+   init_crtcs (gpu_kms, &resources);
+   init_outputs (gpu_kms, &resources);
++  init_frame_clock (gpu_kms);
+ 
+   meta_kms_resources_release (&resources);
+ 
+diff --git a/src/backends/native/meta-gpu-kms.h b/src/backends/native/meta-gpu-kms.h
+index 01c3f2c..c12246c 100644
+--- a/src/backends/native/meta-gpu-kms.h
++++ b/src/backends/native/meta-gpu-kms.h
+@@ -81,6 +81,8 @@ int meta_gpu_kms_get_fd (MetaGpuKms *gpu_kms);
+ 
+ const char * meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms);
+ 
++int64_t _meta_gpu_kms_get_current_time_ns (MetaGpuKms *gpu_kms);
++
+ void meta_gpu_kms_get_max_buffer_size (MetaGpuKms *gpu_kms,
+                                        int        *max_width,
+                                        int        *max_height);
+@@ -97,6 +99,7 @@ gboolean meta_drm_mode_equal (const drmModeModeInfo *one,
+ float meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode);
+ 
+ MetaGpuKmsFlipClosureContainer * meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms,
++                                                                 MetaCrtc   *crtc,
+                                                                  GClosure   *flip_closure);
+ 
+ void meta_gpu_kms_flip_closure_container_free (MetaGpuKmsFlipClosureContainer *closure_container);
+diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
+index 470da88..0fd104b 100644
+--- a/src/backends/native/meta-renderer-native.c
++++ b/src/backends/native/meta-renderer-native.c
+@@ -61,6 +61,7 @@
+ #include "backends/native/meta-monitor-manager-kms.h"
+ #include "backends/native/meta-renderer-native.h"
+ #include "backends/native/meta-renderer-native-gles3.h"
++#include "meta-marshal.h"
+ #include "cogl/cogl.h"
+ #include "core/boxes-private.h"
+ 
+@@ -1157,6 +1158,8 @@ meta_onscreen_native_swap_drm_fb (CoglOnscreen *onscreen)
+ static void
+ on_crtc_flipped (GClosure         *closure,
+                  MetaGpuKms       *gpu_kms,
++                 MetaCrtc         *crtc,
++                 int64_t           page_flip_time_ns,
+                  MetaRendererView *view)
+ {
+   ClutterStageView *stage_view = CLUTTER_STAGE_VIEW (view);
+@@ -1167,6 +1170,24 @@ on_crtc_flipped (GClosure         *closure,
+   MetaOnscreenNative *onscreen_native = onscreen_egl->platform;
+   MetaRendererNative *renderer_native = onscreen_native->renderer_native;
+   MetaGpuKms *render_gpu = onscreen_native->render_gpu;
++  CoglFrameInfo *frame_info;
++  float refresh_rate;
++
++  frame_info = g_queue_peek_tail (&onscreen->pending_frame_infos);
++  refresh_rate = crtc && crtc->current_mode ?
++                 crtc->current_mode->refresh_rate :
++                 0.0f;
++
++  /* Only keep the frame info for the fastest CRTC in use, which may not be
++   * the first one to complete a flip. By only telling the compositor about the
++   * fastest monitor(s) we direct it to produce new frames fast enough to
++   * satisfy all monitors.
++   */
++  if (refresh_rate >= frame_info->refresh_rate)
++    {
++      frame_info->presentation_time = page_flip_time_ns;
++      frame_info->refresh_rate = refresh_rate;
++    }
+ 
+   if (gpu_kms != render_gpu)
+     {
+@@ -1297,7 +1318,9 @@ flip_egl_stream (MetaOnscreenNative *onscreen_native,
+     return FALSE;
+ 
+   closure_container =
+-    meta_gpu_kms_wrap_flip_closure (onscreen_native->render_gpu, flip_closure);
++    meta_gpu_kms_wrap_flip_closure (onscreen_native->render_gpu,
++                                    NULL,
++                                    flip_closure);
+ 
+   acquire_attribs = (EGLAttrib[]) {
+     EGL_DRM_FLIP_EVENT_DATA_NV,
+@@ -1540,7 +1563,7 @@ meta_onscreen_native_flip_crtcs (CoglOnscreen *onscreen)
+   flip_closure = g_cclosure_new (G_CALLBACK (on_crtc_flipped),
+                                  g_object_ref (view),
+                                  (GClosureNotify) flip_closure_destroyed);
+-  g_closure_set_marshal (flip_closure, g_cclosure_marshal_VOID__OBJECT);
++  g_closure_set_marshal (flip_closure, meta_marshal_VOID__OBJECT_OBJECT_INT64);
+ 
+   /* Either flip the CRTC's of the monitor info, if we are drawing just part
+    * of the stage, or all of the CRTC's if we are drawing the whole stage.
+@@ -2673,6 +2696,15 @@ meta_renderer_native_create_offscreen (MetaRendererNative    *renderer,
+   return fb;
+ }
+ 
++static int64_t
++meta_renderer_native_get_clock_time (CoglContext *context)
++{
++  CoglRenderer *cogl_renderer = cogl_context_get_renderer (context);
++  MetaGpuKms *gpu_kms = cogl_renderer->custom_winsys_user_data;
++
++  return _meta_gpu_kms_get_current_time_ns (gpu_kms);
++}
++
+ static const CoglWinsysVtable *
+ get_native_cogl_winsys_vtable (CoglRenderer *cogl_renderer)
+ {
+@@ -2701,6 +2733,8 @@ get_native_cogl_winsys_vtable (CoglRenderer *cogl_renderer)
+       vtable.onscreen_swap_buffers_with_damage =
+         meta_onscreen_native_swap_buffers_with_damage;
+ 
++      vtable.context_get_clock_time = meta_renderer_native_get_clock_time;
++
+       vtable_inited = TRUE;
+     }
+ 
+diff --git a/src/meta-marshal.list b/src/meta-marshal.list
+new file mode 100644
+index 0000000..c1f4781
+--- /dev/null
++++ b/src/meta-marshal.list
+@@ -0,0 +1 @@
++VOID:OBJECT,OBJECT,INT64
diff --git a/debian/patches/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch b/debian/patches/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
 new file mode 100644
index 0000000..9a6a64d
--- /dev/null
+++ b/debian/patches/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
@@ -0,0 +1,53 @@
+From: Daniel van Vugt <[e-mail]>
+Date: Fri, 3 May 2019 11:31:08 -0500
+Subject: renderer-native: Advertise _FEATURE_SWAP_THROTTLE
+
+Because it is implemented and always on. By advertising this fact
+the master clock is able to sync to the native refresh rate instead
+of always using the fallback of 60.00Hz.
+
+Patch 2 of 2
+
+Origin: https://gitlab.gnome.org/vanvugt/mutter/commits/add-vsync-3.28
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=781296
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1763892
+Applied-Upstream: https://gitlab.gnome.org/vanvugt/mutter/commit/e8c27603
+Forwarded: yes
+Last-Update: 2019-03-13
+---
+ src/backends/native/meta-renderer-native.c | 15 +++++++++++++--
+ 1 file changed, 13 insertions(+), 2 deletions(-)
+
+diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
+index 0fd104b..dce7981 100644
+--- a/src/backends/native/meta-renderer-native.c
++++ b/src/backends/native/meta-renderer-native.c
+@@ -1997,6 +1997,13 @@ meta_renderer_native_init_egl_context (CoglContext *cogl_context,
+                   COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN,
+                   TRUE);
+ 
++  /* COGL_WINSYS_FEATURE_SWAP_THROTTLE is always true for this renderer
++   * because we have the call to wait_for_pending_flips on every frame.
++   */
++  COGL_FLAGS_SET (cogl_context->winsys_features,
++                  COGL_WINSYS_FEATURE_SWAP_THROTTLE,
++                  TRUE);
++
+ #ifdef HAVE_EGL_DEVICE
+   if (renderer_gpu_data->mode == META_RENDERER_NATIVE_MODE_EGL_DEVICE)
+     COGL_FLAGS_SET (cogl_context->features,
+@@ -2625,8 +2632,12 @@ meta_renderer_native_create_onscreen (MetaRendererNative   *renderer_native,
+     }
+ 
+   onscreen = cogl_onscreen_new (context, width, height);
+-  cogl_onscreen_set_swap_throttled (onscreen,
+-                                    _clutter_get_sync_to_vblank ());
++
++  /* We have wait_for_pending_flips hardcoded, so throttling always. */
++  cogl_onscreen_set_swap_throttled (onscreen, TRUE);
++  if (!_clutter_get_sync_to_vblank ())
++    g_warning ("Request to disable sync-to-vblank is being ignored. "
++               "MetaRendererNative does not support disabling it.");
+ 
+   if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error))
+     {
diff --git a/debian/patches/monitor-manager-Don-t-use-switch-config-when-ensuring-con.patch b/debian/patches/monitor-manager-Don-t-use-switch-config-when-ensuring-con.patch
 new file mode 100644
index 0000000..5512752
--- /dev/null
+++ b/debian/patches/monitor-manager-Don-t-use-switch-config-when-ensuring-con.patch
@@ -0,0 +1,37 @@
+From: =?utf-8?q?Jonas_=C3=85dahl?= <[e-mail]>
+Date: Thu, 11 Oct 2018 08:16:26 -0500
+Subject: monitor-manager: Don't use switch-config when ensuring configuration
+
+Switch-configs are only to be used in certain circumstances (see
+meta_monitor_manager_can_switch_config()) so when ensuring
+configuration and attempting to create a linear configuration, use the
+linear configuration constructor function directly without going via the
+switch config method, otherwise we might incorrectly fall back to the
+fallback configuration (only enable primary monitor).
+
+This is a regression introduced by 6267732bec97773.
+
+Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/342
+
+Ubuntu-Bug: https://bugs.launchpad.net/ubuntu/+source/mutter/+bug/1772811
+Origin: https://gitlab.gnome.org/GNOME/mutter/merge_requests/262
+Applied-Upstream: yes, 3.32.0
+---
+ src/backends/meta-monitor-manager.c | 4 +---
+ 1 file changed, 1 insertion(+), 3 deletions(-)
+
+diff --git a/src/backends/meta-monitor-manager.c b/src/backends/meta-monitor-manager.c
+index fde61eb..39ed813 100644
+--- a/src/backends/meta-monitor-manager.c
++++ b/src/backends/meta-monitor-manager.c
+@@ -582,9 +582,7 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
+       g_clear_object (&config);
+     }
+ 
+-  config =
+-    meta_monitor_config_manager_create_for_switch_config (manager->config_manager,
+-                                                          META_MONITOR_SWITCH_CONFIG_ALL_LINEAR);
++  config = meta_monitor_config_manager_create_linear (manager->config_manager);
+   if (config)
+     {
+       if (!meta_monitor_manager_apply_monitors_config (manager,
diff --git a/debian/patches/monitor-manager-use-MonitorsConfig-to-track-switch_config.patch b/debian/patches/monitor-manager-use-MonitorsConfig-to-track-switch_config.patch
 new file mode 100644
index 0000000..a791f59
--- /dev/null
+++ b/debian/patches/monitor-manager-use-MonitorsConfig-to-track-switch_config.patch
@@ -0,0 +1,198 @@
+From: Daniel Drake <[e-mail]>
+Date: Wed, 29 Aug 2018 19:34:53 -0500
+Subject: monitor-manager: use MonitorsConfig to track switch_config
+
+When constructing MetaMonitorsConfig objects, store which type
+of switch_config they are for (or UNKNOWN if it is not such
+type of config).
+
+Stop unconditionally setting current_switch_config to UNKNOWN when
+handling monitors changed events. Instead, set it to the switch_config
+type stored in the MonitorsConfig in the codepath that updates logical
+state. In addition to being called in the hotplug case along the same
+code flow that generates monitors changed events, this is also called
+in the coldplug case where a secondary monitor was connected before
+mutter was started.
+
+When creating the default linear display config, create it as a
+switch_config so that internal state gets updated to represent
+linear mode when this config is used.
+
+The previous behaviour of unconditionally resetting current_switch_config
+to UNKNOWN was breaking the internal state machine for display config
+switching, causing misbehaviour in gnome-shell's switchMonitor UI when
+using display switch hotkeys. The lack of internal tracking when the
+displays are already in the default "Join Displays" linear mode was
+then causing the first display switch hotkey press to do nothing
+(it would attempt to select "Join Displays" mode, but that was already
+active).
+
+Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/281
+https://gitlab.gnome.org/GNOME/mutter/merge_requests/213
+
+Ubuntu-Bug: https://bugs.launchpad.net/ubuntu/+source/mutter/+bug/1772811
+Origin: https://gitlab.gnome.org/GNOME/mutter/merge_requests/213
+Applied-Upstream: yes, 3.30.1
+---
+ src/backends/meta-monitor-config-manager.c | 36 +++++++++++++++++++++++++-----
+ src/backends/meta-monitor-config-manager.h |  7 ++++++
+ src/backends/meta-monitor-manager.c        | 25 ++++++++++++++++-----
+ 3 files changed, 56 insertions(+), 12 deletions(-)
+
+diff --git a/src/backends/meta-monitor-config-manager.c b/src/backends/meta-monitor-config-manager.c
+index 197892b..ce61547 100644
+--- a/src/backends/meta-monitor-config-manager.c
++++ b/src/backends/meta-monitor-config-manager.c
+@@ -1007,6 +1007,7 @@ meta_monitor_config_manager_create_for_switch_config (MetaMonitorConfigManager
+                                                       MetaMonitorSwitchConfigType  config_type)
+ {
+   MetaMonitorManager *monitor_manager = config_manager->monitor_manager;
++  MetaMonitorsConfig *config;
+ 
+   if (!meta_monitor_manager_can_switch_config (monitor_manager))
+     return NULL;
+@@ -1014,18 +1015,27 @@ meta_monitor_config_manager_create_for_switch_config (MetaMonitorConfigManager
+   switch (config_type)
+     {
+     case META_MONITOR_SWITCH_CONFIG_ALL_MIRROR:
+-      return create_for_switch_config_all_mirror (config_manager);
++      config = create_for_switch_config_all_mirror (config_manager);
++      break;
+     case META_MONITOR_SWITCH_CONFIG_ALL_LINEAR:
+-      return meta_monitor_config_manager_create_linear (config_manager);
++      config = meta_monitor_config_manager_create_linear (config_manager);
++      break;
+     case META_MONITOR_SWITCH_CONFIG_EXTERNAL:
+-      return create_for_switch_config_external (config_manager);
++      config = create_for_switch_config_external (config_manager);
++      break;
+     case META_MONITOR_SWITCH_CONFIG_BUILTIN:
+-      return create_for_switch_config_builtin (config_manager);
++      config = create_for_switch_config_builtin (config_manager);
++      break;
+     case META_MONITOR_SWITCH_CONFIG_UNKNOWN:
++    default:
+       g_warn_if_reached ();
+-      break;
++      return NULL;
+     }
+-  return NULL;
++
++  if (config)
++    _meta_monitors_config_set_switch_config (config, config_type);
++
++  return config;
+ }
+ 
+ void
+@@ -1217,6 +1227,19 @@ meta_monitors_config_key_equal (gconstpointer data_a,
+   return TRUE;
+ }
+ 
++MetaMonitorSwitchConfigType
++_meta_monitors_config_get_switch_config (MetaMonitorsConfig *config)
++{
++  return config->switch_config;
++}
++
++void
++_meta_monitors_config_set_switch_config (MetaMonitorsConfig          *config,
++                                         MetaMonitorSwitchConfigType  switch_config)
++{
++  config->switch_config = switch_config;
++}
++
+ MetaMonitorsConfig *
+ meta_monitors_config_new_full (GList                        *logical_monitor_configs,
+                                GList                        *disabled_monitor_specs,
+@@ -1232,6 +1255,7 @@ meta_monitors_config_new_full (GList                        *logical_monitor_con
+                                               disabled_monitor_specs);
+   config->layout_mode = layout_mode;
+   config->flags = flags;
++  config->switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
+ 
+   return config;
+ }
+diff --git a/src/backends/meta-monitor-config-manager.h b/src/backends/meta-monitor-config-manager.h
+index 269d8e1..4ac0b1d 100644
+--- a/src/backends/meta-monitor-config-manager.h
++++ b/src/backends/meta-monitor-config-manager.h
+@@ -69,6 +69,8 @@ struct _MetaMonitorsConfig
+   MetaMonitorsConfigFlag flags;
+ 
+   MetaLogicalMonitorLayoutMode layout_mode;
++
++  MetaMonitorSwitchConfigType switch_config;
+ };
+ 
+ #define META_TYPE_MONITORS_CONFIG (meta_monitors_config_get_type ())
+@@ -124,6 +126,11 @@ MetaMonitorsConfig * meta_monitors_config_new (MetaMonitorManager           *mon
+                                                MetaLogicalMonitorLayoutMode  layout_mode,
+                                                MetaMonitorsConfigFlag        flags);
+ 
++MetaMonitorSwitchConfigType _meta_monitors_config_get_switch_config (MetaMonitorsConfig *config);
++
++void _meta_monitors_config_set_switch_config (MetaMonitorsConfig          *config,
++                                              MetaMonitorSwitchConfigType  switch_config);
++
+ unsigned int meta_monitors_config_key_hash (gconstpointer config_key);
+ 
+ gboolean meta_monitors_config_key_equal (gconstpointer config_key_a,
+diff --git a/src/backends/meta-monitor-manager.c b/src/backends/meta-monitor-manager.c
+index ec18600..fde61eb 100644
+--- a/src/backends/meta-monitor-manager.c
++++ b/src/backends/meta-monitor-manager.c
+@@ -582,7 +582,9 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
+       g_clear_object (&config);
+     }
+ 
+-  config = meta_monitor_config_manager_create_linear (manager->config_manager);
++  config =
++    meta_monitor_config_manager_create_for_switch_config (manager->config_manager,
++                                                          META_MONITOR_SWITCH_CONFIG_ALL_LINEAR);
+   if (config)
+     {
+       if (!meta_monitor_manager_apply_monitors_config (manager,
+@@ -2652,8 +2654,6 @@ meta_monitor_manager_read_current_state (MetaMonitorManager *manager)
+ static void
+ meta_monitor_manager_notify_monitors_changed (MetaMonitorManager *manager)
+ {
+-  manager->current_switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
+-
+   meta_backend_monitors_changed (manager->backend);
+ 
+   g_signal_emit (manager, signals[MONITORS_CHANGED_INTERNAL], 0);
+@@ -2710,10 +2710,17 @@ meta_monitor_manager_update_logical_state (MetaMonitorManager *manager,
+                                            MetaMonitorsConfig *config)
+ {
+   if (config)
+-    manager->layout_mode = config->layout_mode;
++    {
++      manager->layout_mode = config->layout_mode;
++      manager->current_switch_config =
++        _meta_monitors_config_get_switch_config (config);
++    }
+   else
+-    manager->layout_mode =
+-      meta_monitor_manager_get_default_layout_mode (manager);
++    {
++      manager->layout_mode =
++        meta_monitor_manager_get_default_layout_mode (manager);
++      manager->current_switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
++    }
+ 
+   meta_monitor_manager_rebuild_logical_monitors (manager, config);
+ }
+@@ -2755,6 +2762,12 @@ void
+ meta_monitor_manager_update_logical_state_derived (MetaMonitorManager *manager,
+                                                    MetaMonitorsConfig *config)
+ {
++  if (config)
++    manager->current_switch_config =
++      _meta_monitors_config_get_switch_config (config);
++  else
++    manager->current_switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
++
+   manager->layout_mode = META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
+ 
+   meta_monitor_manager_rebuild_logical_monitors_derived (manager, config);
diff --git a/debian/patches/series b/debian/patches/series
index 198db5a..8ff6307 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,8 +1,13 @@
 theme-use-gtk_render_icon_suface-to-paint-button-icon.patch
 theme-load-icons-as-Gtk-does-with-fallback-and-RTL-suppor.patch
-clutter-Smooth-out-master-clock-to-smooth-visuals.patch
 clutter-Fix-offscreen-effect-painting-of-clones.patch
 bgo768531_workaround-startup-notifications.patch
+monitor-manager-use-MonitorsConfig-to-track-switch_config.patch
+monitor-manager-Don-t-use-switch-config-when-ensuring-con.patch
+clutter-x11-Implement-keycode-remap-to-keysyms-on-virtual.patch
+clutter-x11-Consider-remapped-keys-when-guessing-the-keyc.patch
+lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
+lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
 debian/synaptics-support.patch
 debian/skip-failing-tests.patch
 debian/skip-failing-tests-325.patch