Merge lp:~3v1n0/gnome-shell/bionic-patches-picks into lp:~ubuntu-desktop/gnome-shell/ubuntu

[Marco Trevisan (Treviño)]

debian: cherry-pick patches from upstream or proposed

 · https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/3
 · https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/4
 · https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/51
 · https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/8
 · https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/70
 · https://bugzilla.gnome.org/show_bug.cgi?id=788882

See https://trello.com/c/EHbKYYWh/315-cherry-pick-gnome-shell-fixes-to-ubuntu

Patch-queue git branch: https://gitlab.gnome.org/3v1n0/gnome-shell/commits/ubuntu-3-28-1 (review could be easier at https://gitlab.gnome.org/3v1n0/gnome-shell/commit/7128763f8f)

[Jeremy Bícha (jbicha)]

I am very concerned with the decision to add 11 more patches to bionic's gnome-shell. I am concerned that this could make updating to 3.28.2 difficult (or the 3.30 series) if too much code is changed before these patches are accepted in to GNOME.

You could at least help reduce this number by following up on the patches that have already been applied to upstream master to see if they can be pushed to the gnome-3-28 branch.

Please also try to be more persistent with getting upstream review of the remaining patches.

I encourage you to talk to Debian's smcv to see if he would be interested in taking some of these patches in to Debian.

One minor note. The patch rename wasn't done in this merge proposal. Maybe that was missed when exporting your work from git.

review: Approve

[Marco Trevisan (Treviño) (3v1n0)]

2018-04-17 13:15 GMT-05:00 Jeremy Bicha <email address hidden>:
> I am very concerned with the decision to add 11 more patches to bionic's gnome-shell. I am concerned that this
> could make updating to 3.28.2 difficult (or the 3.30 series) if too much code is changed before these patches
> are accepted in to GNOME.

Considering how the pace at gnome-shell development is currently, I
think this won't be really a problem.
Plus, I've linked the git repo I've used to generate all this, and
using patch-queue, you know that rebasing won't really be an issue.
In any, case I can take care of it. Although I hope some of these
patch will merge (where's it's not already the case).

> You could at least help reduce this number by following up on the patches that have already been applied to upstream master
> to see if they can be pushed to the gnome-3-28 branch.

There's not gnome-3-28 branch yet, thus everything that here has been
cherry-picked from master, will be in 3.28.X.

> Please also try to be more persistent with getting upstream review of the remaining patches.

Eh, true, but I also don't like to bother people :).

> I encourage you to talk to Debian's smcv to see if he would be interested in taking some of these patches in to Debian.

Yeah, I already planned to propose some of them to salsa too.

> One minor note. The patch rename wasn't done in this merge proposal. Maybe that was missed when exporting your work from git.

Oh, well spotted. Thanks.

=== modified file 'debian/changelog'
--- debian/changelog	2018-04-14 01:50:15 +0000
+++ debian/changelog	2018-04-17 10:30:40 +0000
@@ -1,10 +1,36 @@
 gnome-shell (3.28.1-0ubuntu1) UNRELEASED; urgency=medium
 
+  [ Jeremy Bicha ]
   * New upstream release
   * Drop obsolete patches:
     - 27-nm-libexec-path.patch
     - fix-wayland-vbox-crash.patch
 
+  [ Marco Trevisan (Treviño) ]
+  * ui-Theme-lookup-should-respect-XDG_DATA_DIRS.patch:
+    - Renamed from ubuntu_theme_lookup_xdg.patch and cherry-picked from
+      upstream
+  * StIcon-only-compute-shadow-pipeline-when-the-texture-is-p.patch:
+    - Don't try to compute shadows on not allocated icons (LP: #1723378)
+  * js-fix-invalid-access-errors.patch:
+    - Fix javascript errors (LP: #1747566)
+  * popupMenu-Fix-wrong-call-to-clutter_actor_add_child.patch:
+    - Cherry-pick from upstream
+  * shell-ignore-invalid-window-monitor-index.patch:
+    - Fix crash on accessing on invalid monitor windows (LP: #1724439)
+  * volume-Add-back-sound-feedback-on-scroll.patch:
+    - Fix regression causing missing feedback on volume slider scroll
+  * workspace-fix-repositioned-windows-in-activities.patch:
+    - Ensure windows thumbnails coordinates are correct (LP: #1653153)
+  * workspaceThumbnail-initialize-porthole-based-on-workArea.patch:
+    workspaceThumbnail-only-update-_porthole-if-the-overview-.patch:
+    workspaceThumbnail-rebuild-thumbnails-if-workareas-size-c.patch:
+    - Cherry-picks from upstream, avoid unneeded computations in activities
+  * st-texture-cache-Cancel-sliced-image-loading-on-target-ac.patch:
+    - Fix possible crash on cache loading
+  * st-texture-cache-Don-t-add-NULL-textures-to-cache.patch:
+    - Fix crash when deleting NULL textures from cash (LP: #1754445)
+
  -- Jeremy Bicha <[e-mail]>  Fri, 13 Apr 2018 21:40:17 -0400
 
 gnome-shell (3.28.0-0ubuntu5) bionic; urgency=medium
 
=== added file 'debian/patches/StIcon-only-compute-shadow-pipeline-when-the-texture-is-p.patch'
--- debian/patches/StIcon-only-compute-shadow-pipeline-when-the-texture-is-p.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/StIcon-only-compute-shadow-pipeline-when-the-texture-is-p.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,134 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Wed, 18 Oct 2017 05:32:22 -0500
+Subject: StIcon: only compute shadow pipeline when the texture is properly
+ allocated
+
+Creating the shadow pipeline requires the actor to be allocated in order
+to get its dimensions, however in the current state we just compute it
+even if this is not the case.
+This causes _st_create_shadow_pipeline_from_actor (when getting the allocation
+box) to trigger an allocation cycle, which might lead to a convolution to
+st_icon_finish_update causing breakage on data as soon as we return from it.
+
+Generating it at paint if not done before, it's a way for avoiding this.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=788908
+
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=788908
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/gnome-shell/+bug/1723378
+Forwarded: yes, https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/3
+---
+ src/st/st-icon.c | 48 +++++++++++++++++++++++++++++++++++++-----------
+ 1 file changed, 37 insertions(+), 11 deletions(-)
+
+diff --git a/src/st/st-icon.c b/src/st/st-icon.c
+index 192df60..332e5b2 100644
+--- a/src/st/st-icon.c
++++ b/src/st/st-icon.c
+@@ -56,12 +56,15 @@ struct _StIconPrivate
+ 
+   CoglPipeline *shadow_pipeline;
+   StShadow     *shadow_spec;
++  ClutterSize   shadow_size;
+ };
+ 
+ G_DEFINE_TYPE_WITH_PRIVATE (StIcon, st_icon, ST_TYPE_WIDGET)
+ 
+ static void st_icon_update               (StIcon *icon);
+ static gboolean st_icon_update_icon_size (StIcon *icon);
++static void st_icon_update_shadow_pipeline (StIcon *icon);
++static void st_icon_clean_shadow_pipeline (StIcon *icon);
+ 
+ #define DEFAULT_ICON_SIZE 48
+ 
+@@ -164,18 +167,31 @@ st_icon_paint (ClutterActor *actor)
+ 
+   if (priv->icon_texture)
+     {
+-      if (priv->shadow_pipeline)
+-        {
++      if (priv->shadow_spec)
++       {
+           ClutterActorBox allocation;
+           float width, height;
+ 
+           clutter_actor_get_allocation_box (priv->icon_texture, &allocation);
+           clutter_actor_box_get_size (&allocation, &width, &height);
+ 
+-          _st_paint_shadow_with_opacity (priv->shadow_spec,
+-                                         priv->shadow_pipeline,
+-                                         &allocation,
+-                                         clutter_actor_get_paint_opacity (priv->icon_texture));
++          if (priv->shadow_pipeline == NULL ||
++              priv->shadow_size.width != width ||
++              priv->shadow_size.height != height)
++            {
++              st_icon_update_shadow_pipeline (ST_ICON (actor));
++
++              if (priv->shadow_pipeline)
++                clutter_size_init (&priv->shadow_size, width, height);
++            }
++
++          if (priv->shadow_pipeline)
++            {
++              _st_paint_shadow_with_opacity (priv->shadow_spec,
++                                            priv->shadow_pipeline,
++                                            &allocation,
++                                            clutter_actor_get_paint_opacity (priv->icon_texture));
++            }
+         }
+ 
+       clutter_actor_paint (priv->icon_texture);
+@@ -189,7 +205,7 @@ st_icon_style_changed (StWidget *widget)
+   StThemeNode *theme_node = st_widget_get_theme_node (widget);
+   StIconPrivate *priv = self->priv;
+ 
+-  g_clear_pointer (&priv->shadow_pipeline, cogl_object_unref);
++  st_icon_clean_shadow_pipeline (self);
+   g_clear_pointer (&priv->shadow_spec, st_shadow_unref);
+ 
+   priv->shadow_spec = st_theme_node_get_shadow (theme_node, "icon-shadow");
+@@ -268,21 +284,31 @@ st_icon_init (StIcon *self)
+ }
+ 
+ static void
+-st_icon_update_shadow_pipeline (StIcon *icon)
++st_icon_clean_shadow_pipeline (StIcon *icon)
+ {
+   StIconPrivate *priv = icon->priv;
+ 
+   g_clear_pointer (&priv->shadow_pipeline, cogl_object_unref);
++  clutter_size_init (&priv->shadow_size, 0, 0);
++}
++
++static void
++st_icon_update_shadow_pipeline (StIcon *icon)
++{
++  StIconPrivate *priv = icon->priv;
++
++  st_icon_clean_shadow_pipeline (icon);
+ 
+   if (priv->shadow_spec)
+-   priv->shadow_pipeline = _st_create_shadow_pipeline_from_actor (priv->shadow_spec, priv->icon_texture);
++    priv->shadow_pipeline = _st_create_shadow_pipeline_from_actor (priv->shadow_spec, priv->icon_texture);
+ }
+ 
+ static void
+ on_pixbuf_changed (ClutterTexture *texture,
+                    StIcon         *icon)
+ {
+-  st_icon_update_shadow_pipeline (icon);
++  st_icon_clean_shadow_pipeline (icon);
++  clutter_actor_queue_redraw (CLUTTER_ACTOR (icon));
+ }
+ 
+ static void
+@@ -307,7 +333,7 @@ st_icon_finish_update (StIcon *icon)
+       /* Remove the temporary ref we added */
+       g_object_unref (priv->icon_texture);
+ 
+-      st_icon_update_shadow_pipeline (icon);
++      st_icon_clean_shadow_pipeline (icon);
+ 
+       /* "pixbuf-change" is actually a misnomer for "texture-changed" */
+       g_signal_connect_object (priv->icon_texture, "pixbuf-change",
 
=== added file 'debian/patches/js-fix-invalid-access-errors.patch'
--- debian/patches/js-fix-invalid-access-errors.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/js-fix-invalid-access-errors.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,564 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Mon, 4 Dec 2017 19:41:50 -0600
+Subject: js: fix invalid-access errors
+
+tweener: Save handlers on target and remove them on destroy
+
+Saving handlers we had using the wrapper as a property of the object and delete
+them when resetting the object state.
+Without doing this an handler could be called on a destroyed target when this
+happens on the onComplete callback.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=791233
+
+dnd: Nullify _dragActor after we've destroyed it, and avoid invalid access
+
+We need to avoid that we use the _dragActor instance after that it has
+been destroyed or we'll get errors. We now set it to null when this
+happens, protecting any access to that.
+
+Add a DragState enum-like object to keep track of the state
+instead of using booleans.
+
+Remove duplicated handler on 'destroy' and just use a generic one.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=791233
+
+workspaceThumbnail: Disconnect from window signals on destruction
+
+Avoid to try to destroy the window clone content more than once
+when a window is destroyed, and do it in proper order.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=791233
+
+workspaceThumbnail: Remove WindowClone's from _windows when destroyed
+
+A WindowClone might be destroyed earlier than its MetaWindow counterpart
+as its WindowActor could be destroyed earlier, thus when happens it's safer
+to remove the clone from the windows list, without waiting for the workspace
+to request to do so.
+
+WindowClone now emits a 'destroy' signals earlier enough and this now
+triggers a _doRemoveWindow on WorkspaceThumbnail which will lead
+to the proper cleanup; keeping track of the signal connections, in
+order to avoid callback loops (not really harmful in this case, but
+good practice).
+
+https://bugzilla.gnome.org/show_bug.cgi?id=791233
+
+workspace: Disconnect from window signals on destruction
+
+Avoid to try to destroy the window clone content more than once
+when a window is destroyed, and do it in proper order.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=791233
+
+workspace: Remove WindowClone's from _windows when destroyed
+
+A WindowClone might be destroyed earlier than its MetaWindow counterpart
+as its WindowActor could be destroyed earlier, thus when happens it's safer
+to remove the clone from the windows list, without waiting for the workspace
+to request to do so.
+
+WindowClone now emits a 'destroy' signals earlier enough and this now
+triggers a _doRemoveWindow on WorkspaceThumbnail which will lead
+to the proper cleanup; keeping track of the signal connections, in
+order to avoid callback loops (not really harmful in this case, but
+good practice).
+
+https://bugzilla.gnome.org/show_bug.cgi?id=791233
+
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=791233
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/bionic/+source/gnome-shell/+bug/1747566
+Forwarded: yes, https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/4
+---
+ js/ui/dnd.js                | 65 +++++++++++++++++++++++++++------------------
+ js/ui/tweener.js            | 64 +++++++++++++++++++++++++++++++++++---------
+ js/ui/workspace.js          | 35 +++++++++++++++++-------
+ js/ui/workspaceThumbnail.js | 33 +++++++++++++++++------
+ 4 files changed, 140 insertions(+), 57 deletions(-)
+
+diff --git a/js/ui/dnd.js b/js/ui/dnd.js
+index a38607c..431c60d 100644
+--- a/js/ui/dnd.js
++++ b/js/ui/dnd.js
+@@ -27,6 +27,12 @@ var DragMotionResult = {
+     CONTINUE:  3
+ };
+ 
++var DragState = {
++    INIT:      0,
++    DRAGGING:  1,
++    CANCELLED: 2,
++};
++
+ var DRAG_CURSOR_MAP = {
+     0: Meta.Cursor.DND_UNSUPPORTED_TARGET,
+     1: Meta.Cursor.DND_COPY,
+@@ -78,6 +84,8 @@ var _Draggable = new Lang.Class({
+                                         dragActorOpacity: undefined });
+ 
+         this.actor = actor;
++        this._dragState = DragState.INIT;
++
+         if (!params.manualMode) {
+             this.actor.connect('button-press-event',
+                                this._onButtonPress.bind(this));
+@@ -88,7 +96,7 @@ var _Draggable = new Lang.Class({
+         this.actor.connect('destroy', () => {
+             this._actorDestroyed = true;
+ 
+-            if (this._dragInProgress && this._dragCancellable)
++            if (this._dragState == DragState.DRAGGING && this._dragCancellable)
+                 this._cancelDrag(global.get_current_time());
+             this.disconnectAll();
+         });
+@@ -100,7 +108,6 @@ var _Draggable = new Lang.Class({
+         this._dragActorOpacity = params.dragActorOpacity;
+ 
+         this._buttonDown = false; // The mouse button has been pressed and has not yet been released.
+-        this._dragInProgress = false; // The drag has been started, and has not been dropped or cancelled yet.
+         this._animationInProgress = false; // The drag is over and the item is in the process of animating to its original position (snapping back or reverting).
+         this._dragCancellable = true;
+ 
+@@ -206,9 +213,10 @@ var _Draggable = new Lang.Class({
+             (event.type() == Clutter.EventType.TOUCH_END &&
+              global.display.is_pointer_emulating_sequence(event.get_event_sequence()))) {
+             this._buttonDown = false;
+-            if (this._dragInProgress) {
++            if (this._dragState == DragState.DRAGGING) {
+                 return this._dragActorDropped(event);
+-            } else if (this._dragActor != null && !this._animationInProgress) {
++            } else if ((this._dragActor != null || this._dragState == DragState.CANCELLED) &&
++                       !this._animationInProgress) {
+                 // Drag must have been cancelled with Esc.
+                 this._dragComplete();
+                 return Clutter.EVENT_STOP;
+@@ -222,14 +230,14 @@ var _Draggable = new Lang.Class({
+         } else if (event.type() == Clutter.EventType.MOTION ||
+                    (event.type() == Clutter.EventType.TOUCH_UPDATE &&
+                     global.display.is_pointer_emulating_sequence(event.get_event_sequence()))) {
+-            if (this._dragInProgress) {
++            if (this._dragActor && this._dragState == DragState.DRAGGING) {
+                 return this._updateDragPosition(event);
+-            } else if (this._dragActor == null) {
++            } else if (this._dragActor == null && this._dragState != DragState.CANCELLED) {
+                 return this._maybeStartDrag(event);
+             }
+         // We intercept KEY_PRESS event so that we can process Esc key press to cancel
+         // dragging and ignore all other key presses.
+-        } else if (event.type() == Clutter.EventType.KEY_PRESS && this._dragInProgress) {
++        } else if (event.type() == Clutter.EventType.KEY_PRESS && this._dragState == DragState.DRAGGING) {
+             let symbol = event.get_key_symbol();
+             if (symbol == Clutter.Escape) {
+                 this._cancelDrag(event.get_time());
+@@ -265,7 +273,7 @@ var _Draggable = new Lang.Class({
+      */
+     startDrag(stageX, stageY, time, sequence) {
+         currentDraggable = this;
+-        this._dragInProgress = true;
++        this._dragState = DragState.DRAGGING;
+ 
+         // Special-case St.Button: the pointer grab messes with the internal
+         // state, so force a reset to a reasonable state here
+@@ -342,6 +350,13 @@ var _Draggable = new Lang.Class({
+             Shell.util_set_hidden_from_pick(this._dragActor, true);
+         }
+ 
++        this._dragActorDestroyId = this._dragActor.connect('destroy', () => {
++            // Cancel ongoing animation (if any)
++            this._finishAnimation();
++
++            this._dragActor = null;
++            this._dragState = DragState.CANCELLED;
++        });
+         this._dragOrigOpacity = this._dragActor.opacity;
+         if (this._dragActorOpacity != undefined)
+             this._dragActor.opacity = this._dragActorOpacity;
+@@ -500,7 +515,7 @@ var _Draggable = new Lang.Class({
+                                                 event.get_time())) {
+                     // If it accepted the drop without taking the actor,
+                     // handle it ourselves.
+-                    if (this._dragActor.get_parent() == Main.uiGroup) {
++                    if (this._dragActor && this._dragActor.get_parent() == Main.uiGroup) {
+                         if (this._restoreOnSuccess) {
+                             this._restoreDragActor(event.get_time());
+                             return true;
+@@ -508,7 +523,7 @@ var _Draggable = new Lang.Class({
+                             this._dragActor.destroy();
+                     }
+ 
+-                    this._dragInProgress = false;
++                    this._dragState = DragState.INIT;
+                     global.screen.set_cursor(Meta.Cursor.DEFAULT);
+                     this.emit('drag-end', event.get_time(), true);
+                     this._dragComplete();
+@@ -557,20 +572,22 @@ var _Draggable = new Lang.Class({
+ 
+     _cancelDrag(eventTime) {
+         this.emit('drag-cancelled', eventTime);
+-        this._dragInProgress = false;
+-        let [snapBackX, snapBackY, snapBackScale] = this._getRestoreLocation();
++        let wasCancelled = (this._dragState == DragState.CANCELLED);
++        this._dragState = DragState.CANCELLED;
+ 
+-        if (this._actorDestroyed) {
++        if (this._actorDestroyed || wasCancelled) {
+             global.screen.set_cursor(Meta.Cursor.DEFAULT);
+             if (!this._buttonDown)
+                 this._dragComplete();
+             this.emit('drag-end', eventTime, false);
+-            if (!this._dragOrigParent)
++            if (!this._dragOrigParent && this._dragActor)
+                 this._dragActor.destroy();
+ 
+             return;
+         }
+ 
++        let [snapBackX, snapBackY, snapBackScale] = this._getRestoreLocation();
++
+         this._animateDragEnd(eventTime,
+                              { x: snapBackX,
+                                y: snapBackY,
+@@ -581,7 +598,7 @@ var _Draggable = new Lang.Class({
+     },
+ 
+     _restoreDragActor(eventTime) {
+-        this._dragInProgress = false;
++        this._dragState = DragState.INIT;
+         let [restoreX, restoreY, restoreScale] = this._getRestoreLocation();
+ 
+         // fade the actor back in at its original location
+@@ -596,12 +613,6 @@ var _Draggable = new Lang.Class({
+     _animateDragEnd(eventTime, params) {
+         this._animationInProgress = true;
+ 
+-        // finish animation if the actor gets destroyed
+-        // during it
+-        this._dragActorDestroyId =
+-            this._dragActor.connect('destroy',
+-                                    this._finishAnimation.bind(this));
+-
+         params['opacity']          = this._dragOrigOpacity;
+         params['transition']       = 'easeOutQuad';
+         params['onComplete']       = this._onAnimationComplete;
+@@ -624,9 +635,6 @@ var _Draggable = new Lang.Class({
+     },
+ 
+     _onAnimationComplete(dragActor, eventTime) {
+-        dragActor.disconnect(this._dragActorDestroyId);
+-        this._dragActorDestroyId = 0;
+-
+         if (this._dragOrigParent) {
+             Main.uiGroup.remove_child(this._dragActor);
+             this._dragOrigParent.add_actor(this._dragActor);
+@@ -641,7 +649,7 @@ var _Draggable = new Lang.Class({
+     },
+ 
+     _dragComplete() {
+-        if (!this._actorDestroyed)
++        if (!this._actorDestroyed && this._dragActor)
+             Shell.util_set_hidden_from_pick(this._dragActor, false);
+ 
+         this._ungrabEvents();
+@@ -652,7 +660,12 @@ var _Draggable = new Lang.Class({
+             this._updateHoverId = 0;
+         }
+ 
+-        this._dragActor = undefined;
++        if (this._dragActor) {
++            this._dragActor.disconnect(this._dragActorDestroyId);
++            this._dragActor = null;
++        }
++
++        this._dragState = DragState.INIT;
+         currentDraggable = null;
+     }
+ });
+diff --git a/js/ui/tweener.js b/js/ui/tweener.js
+index 1a85e2f..663b97b 100644
+--- a/js/ui/tweener.js
++++ b/js/ui/tweener.js
+@@ -69,30 +69,68 @@ function _getTweenState(target) {
+     return target.__ShellTweenerState;
+ }
+ 
++function _ensureHandlers(target) {
++    if (!target.__ShellTweenerHandlers)
++        target.__ShellTweenerHandlers = {};
++    return target.__ShellTweenerHandlers;
++}
++
+ function _resetTweenState(target) {
+     let state = target.__ShellTweenerState;
+ 
+     if (state) {
+-        if (state.destroyedId)
++        if (state.destroyedId) {
+             state.actor.disconnect(state.destroyedId);
++            delete state.destroyedId;
++        }
+     }
+ 
++    _removeHandler(target, 'onComplete', _tweenCompleted);
+     target.__ShellTweenerState = {};
+ }
+ 
+ function _addHandler(target, params, name, handler) {
+-    if (params[name]) {
+-        let oldHandler = params[name];
+-        let oldScope = params[name + 'Scope'];
+-        let oldParams = params[name + 'Params'];
+-        let eventScope = oldScope ? oldScope : target;
+-
+-        params[name] = () => {
+-            oldHandler.apply(eventScope, oldParams);
+-            handler(target);
+-        };
+-    } else
+-        params[name] = () => { handler(target); };
++    let wrapperNeeded = false;
++    let tweenerHandlers = _ensureHandlers(target);
++
++    if (!(name in tweenerHandlers))
++    {
++        tweenerHandlers[name] = [];
++        wrapperNeeded = true;
++    }
++
++    let handlers = tweenerHandlers[name];
++    handlers.push(handler);
++
++    if (wrapperNeeded) {
++        if (params[name]) {
++            let oldHandler = params[name];
++            let oldScope = params[name + 'Scope'];
++            let oldParams = params[name + 'Params'];
++            let eventScope = oldScope ? oldScope : target;
++
++            params[name] = () => {
++                oldHandler.apply(eventScope, oldParams);
++                handlers.forEach((h) => h(target));
++            };
++        } else {
++            params[name] = () => { handlers.forEach((h) => h(target)); };
++        }
++    }
++}
++
++function _removeHandler(target, name, handler) {
++    let tweenerHandlers = _ensureHandlers(target);
++
++    if (name in tweenerHandlers) {
++        let handlers = tweenerHandlers[name];
++        let handlerIndex = handlers.indexOf(handler);
++
++        while (handlerIndex > -1) {
++            handlers.splice(handlerIndex, 1);
++            handlerIndex = handlers.indexOf(handler);
++        }
++    }
+ }
+ 
+ function _actorDestroyed(target) {
+diff --git a/js/ui/workspace.js b/js/ui/workspace.js
+index 1e121b7..8836537 100644
+--- a/js/ui/workspace.js
++++ b/js/ui/workspace.js
+@@ -139,14 +139,8 @@ var WindowClone = new Lang.Class({
+ 
+         this._windowClone._updateId = this.metaWindow.connect('size-changed',
+             this._onRealWindowSizeChanged.bind(this));
+-        this._windowClone._destroyId =
+-            this.realWindow.connect('destroy', () => {
+-                // First destroy the clone and then destroy everything
+-                // This will ensure that we never see it in the
+-                // _disconnectSignals loop
+-                this._windowClone.destroy();
+-                this.destroy();
+-            });
++        this._windowClone._destroyId = this.realWindow.connect('destroy',
++            this.destroy.bind(this));
+ 
+         this._updateAttachedDialogs();
+         this._computeBoundingBox();
+@@ -310,6 +304,14 @@ var WindowClone = new Lang.Class({
+     },
+ 
+     destroy() {
++        this.emit('destroy');
++
++        // First destroy the clone and then destroy everything
++        // This will ensure that we never see it in the _disconnectSignals loop
++        this.metaWindow.disconnect(this._windowClone._updateId);
++        this.realWindow.disconnect(this._windowClone._destroyId);
++        this._windowClone.destroy();
++
+         this.actor.destroy();
+     },
+ 
+@@ -1131,6 +1133,7 @@ var Workspace = new Lang.Class({
+         // Create clones for windows that should be
+         // visible in the Overview
+         this._windows = [];
++        this._windowsDestroyedIds = [];
+         this._windowOverlays = [];
+         for (let i = 0; i < windows.length; i++) {
+             if (this._isOverviewWindow(windows[i])) {
+@@ -1428,7 +1431,7 @@ var Workspace = new Lang.Class({
+         return GLib.SOURCE_REMOVE;
+     },
+ 
+-    _doRemoveWindow(metaWin) {
++    _doRemoveWindow(metaWin, {cloneDestroy}={cloneDestroy: true}) {
+         let win = metaWin.get_compositor_private();
+ 
+         // find the position of the window in our list
+@@ -1438,8 +1441,10 @@ var Workspace = new Lang.Class({
+             return;
+ 
+         let clone = this._windows[index];
++        clone.disconnect(this._windowsDestroyedIds[index]);
+ 
+         this._windows.splice(index, 1);
++        this._windowsDestroyedIds.splice(index, 1);
+         this._windowOverlays.splice(index, 1);
+ 
+         // If metaWin.get_compositor_private() returned non-NULL, that
+@@ -1457,7 +1462,9 @@ var Workspace = new Lang.Class({
+                 scale: stageWidth / clone.actor.width
+             };
+         }
+-        clone.destroy();
++
++        if (cloneDestroy)
++            clone.destroy();
+ 
+ 
+         // We need to reposition the windows; to avoid shuffling windows
+@@ -1800,7 +1807,11 @@ var Workspace = new Lang.Class({
+             this._actualGeometryLater = 0;
+         }
+ 
++        for (let index = 0; index < this._windows.length; ++index)
++            this._windows[index].disconnect(this._windowsDestroyedIds[index]);
++
+         this._windows = [];
++        this._windowsDestroyedIds = [];
+     },
+ 
+     // Sets this.leavingOverview flag to false.
+@@ -1848,6 +1859,9 @@ var Workspace = new Lang.Class({
+         clone.connect('size-changed', () => {
+             this._recalculateWindowPositions(WindowPositionFlags.NONE);
+         });
++        let cloneDestroyedId = clone.connect('destroy', () => {
++            this._doRemoveWindow(clone.metaWindow, {cloneDestroy: false});
++        });
+ 
+         this.actor.add_actor(clone.actor);
+ 
+@@ -1864,6 +1878,7 @@ var Workspace = new Lang.Class({
+             clone.setStackAbove(this._windows[this._windows.length - 1].actor);
+ 
+         this._windows.push(clone);
++        this._windowsDestroyedIds.push(cloneDestroyedId);
+         this._windowOverlays.push(overlay);
+ 
+         return [clone, overlay];
+diff --git a/js/ui/workspaceThumbnail.js b/js/ui/workspaceThumbnail.js
+index c1b4bdd..0c72e74 100644
+--- a/js/ui/workspaceThumbnail.js
++++ b/js/ui/workspaceThumbnail.js
+@@ -70,12 +70,7 @@ var WindowClone = new Lang.Class({
+ 
+         this.clone._updateId = this.metaWindow.connect('position-changed',
+                                                        this._onPositionChanged.bind(this));
+-        this.clone._destroyId = this.realWindow.connect('destroy', () => {
+-            // First destroy the clone and then destroy everything
+-            // This will ensure that we never see it in the _disconnectSignals loop
+-            this.clone.destroy();
+-            this.destroy();
+-        });
++        this.clone._destroyId = this.realWindow.connect('destroy', this.destroy.bind(this));
+         this._onPositionChanged();
+ 
+         this.actor.connect('button-release-event',
+@@ -142,6 +137,14 @@ var WindowClone = new Lang.Class({
+     },
+ 
+     destroy() {
++        this.emit('destroy');
++
++        // First destroy the clone and then destroy everything
++        // This will ensure that we never see it in the _disconnectSignals loop
++        this.metaWindow.disconnect(this.clone._updateId);
++        this.realWindow.disconnect(this.clone._destroyId);
++        this.clone.destroy();
++
+         this.actor.destroy();
+     },
+ 
+@@ -285,6 +288,7 @@ var WorkspaceThumbnail = new Lang.Class({
+ 
+         // Create clones for windows that should be visible in the Overview
+         this._windows = [];
++        this._windowsDestroyedIds = [];
+         this._allWindows = [];
+         this._minimizedChangedIds = [];
+         for (let i = 0; i < windows.length; i++) {
+@@ -371,7 +375,7 @@ var WorkspaceThumbnail = new Lang.Class({
+         return this._collapseFraction;
+     },
+ 
+-    _doRemoveWindow(metaWin) {
++    _doRemoveWindow(metaWin, {cloneDestroy}={cloneDestroy: true}) {
+         let win = metaWin.get_compositor_private();
+ 
+         // find the position of the window in our list
+@@ -381,9 +385,13 @@ var WorkspaceThumbnail = new Lang.Class({
+             return;
+ 
+         let clone = this._windows[index];
++        clone.disconnect(this._windowsDestroyedIds[index]);
++
+         this._windows.splice(index, 1);
++        this._windowsDestroyedIds.splice(index, 1);
+ 
+-        clone.destroy();
++        if (cloneDestroy)
++            clone.destroy();
+     },
+ 
+     _doAddWindow(metaWin) {
+@@ -502,7 +510,11 @@ var WorkspaceThumbnail = new Lang.Class({
+           this._bgManager = null;
+         }
+ 
++        for (let index = 0; index < this._windows.length; ++index)
++            this._windows[index].disconnect(this._windowsDestroyedIds[index]);
++
+         this._windows = [];
++        this._windowsDestroyedIds = [];
+         this.actor = null;
+     },
+ 
+@@ -535,6 +547,10 @@ var WorkspaceThumbnail = new Lang.Class({
+         clone.connect('drag-end', () => {
+             Main.overview.endWindowDrag(clone.metaWindow);
+         });
++        let cloneDestroyedId = clone.connect('destroy', () => {
++            this._doRemoveWindow(clone.metaWindow, {cloneDestroy: false});
++        });
++
+         this._contents.add_actor(clone.actor);
+ 
+         if (this._windows.length == 0)
+@@ -543,6 +559,7 @@ var WorkspaceThumbnail = new Lang.Class({
+             clone.setStackAbove(this._windows[this._windows.length - 1].actor);
+ 
+         this._windows.push(clone);
++        this._windowsDestroyedIds.push(cloneDestroyedId);
+ 
+         return clone;
+     },
 
=== added file 'debian/patches/popupMenu-Fix-wrong-call-to-clutter_actor_add_child.patch'
--- debian/patches/popupMenu-Fix-wrong-call-to-clutter_actor_add_child.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/popupMenu-Fix-wrong-call-to-clutter_actor_add_child.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,28 @@
+From: Mario Sanchez Prada <[e-mail]>
+Date: Mon, 16 Apr 2018 05:47:57 -0500
+Subject: popupMenu: Fix wrong call to clutter_actor_add_child()
+
+Specify the horizontal alignment via the x_align property when creating
+the StIcon, since this function expects one argument, not two.
+
+Origin: https://gitlab.gnome.org/GNOME/gnome-shell/commit/cdbc99e
+---
+ js/ui/popupMenu.js | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/js/ui/popupMenu.js b/js/ui/popupMenu.js
+index 67b928c..83194d7 100644
+--- a/js/ui/popupMenu.js
++++ b/js/ui/popupMenu.js
+@@ -394,8 +394,9 @@ var PopupImageMenuItem = new Lang.Class({
+     _init(text, icon, params) {
+         this.parent(params);
+ 
+-        this._icon = new St.Icon({ style_class: 'popup-menu-icon' });
+-        this.actor.add_child(this._icon, { align: St.Align.END });
++        this._icon = new St.Icon({ style_class: 'popup-menu-icon',
++                                   x_align: Clutter.ActorAlign.END });
++        this.actor.add_child(this._icon);
+         this.label = new St.Label({ text: text });
+         this.actor.add_child(this.label);
+         this.actor.label_actor = this.label;
 
=== modified file 'debian/patches/series'
--- debian/patches/series	2018-04-14 01:50:15 +0000
+++ debian/patches/series	2018-04-17 10:30:40 +0000
@@ -11,5 +11,16 @@
 ubuntu_background_login.patch
 ubuntu_gdm_alternatives.patch
 ubuntu_block_mode_extension_update.patch
-ubuntu_theme_lookup_xdg.patch
+ui-Theme-lookup-should-respect-XDG_DATA_DIRS.patch
 workaround_crasher_fractional_scaling.patch
+shell-ignore-invalid-window-monitor-index.patch
+workspaceThumbnail-only-update-_porthole-if-the-overview-.patch
+workspaceThumbnail-rebuild-thumbnails-if-workareas-size-c.patch
+workspaceThumbnail-initialize-porthole-based-on-workArea.patch
+popupMenu-Fix-wrong-call-to-clutter_actor_add_child.patch
+StIcon-only-compute-shadow-pipeline-when-the-texture-is-p.patch
+volume-Add-back-sound-feedback-on-scroll.patch
+js-fix-invalid-access-errors.patch
+workspace-fix-repositioned-windows-in-activities.patch
+st-texture-cache-Cancel-sliced-image-loading-on-target-ac.patch
+st-texture-cache-Don-t-add-NULL-textures-to-cache.patch
 
=== added file 'debian/patches/shell-ignore-invalid-window-monitor-index.patch'
--- debian/patches/shell-ignore-invalid-window-monitor-index.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/shell-ignore-invalid-window-monitor-index.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,98 @@
+From: Sam Spilsbury <[e-mail]>
+Date: Wed, 11 Oct 2017 05:42:04 -0500
+Subject: shell: ignore invalid window monitor index
+
+windowMenu: Check if monitorIndex is valid before using it
+
+Calling meta_window_get_monitor on an unmanaged window may return
+-1, so we need to check the return value.
+
+Fixes https://bugzilla.gnome.org/show_bug.cgi?id=788882
+
+keyboard: Handle case where keyboardMonitor is unset
+
+This may be the case where keyboardIndex is -1, which may be the
+case where either the keyboard monitor hasn't been set yet, or
+the keyboard is being unmanaged and meta_window_get_monitor
+returns -1
+
+https://bugzilla.gnome.org/show_bug.cgi?id=788882
+
+layout: Remove focusMonitor, as it is unused
+
+It also uses focusIndex to determine which monitor to
+return and may occassionally return undefined if focusIndex
+was -1.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=788882
+
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=788882
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/gnome-shell/+bug/1724439
+Forwarded: yes
+---
+ js/ui/keyboard.js   | 8 ++++++++
+ js/ui/layout.js     | 4 ----
+ js/ui/windowMenu.js | 7 ++++---
+ 3 files changed, 12 insertions(+), 7 deletions(-)
+
+diff --git a/js/ui/keyboard.js b/js/ui/keyboard.js
+index e13c7b7..14f6e7b 100644
+--- a/js/ui/keyboard.js
++++ b/js/ui/keyboard.js
+@@ -939,6 +939,12 @@ var Keyboard = new Lang.Class({
+         if (this.actor == null)
+             return;
+         let monitor = Main.layoutManager.keyboardMonitor;
++
++        // monitor may be null here if the underlying keyboard monitor
++        // index was still unset.
++        if (!monitor)
++            return;
++
+         let maxHeight = monitor.height / 3;
+         this.actor.width = monitor.width;
+         this.actor.height = maxHeight;
+@@ -1001,6 +1007,8 @@ var Keyboard = new Lang.Class({
+         if (!this._enabled)
+             return;
+ 
++       
++
+         this._clearShowIdle();
+         this._keyboardRequested = true;
+ 
+diff --git a/js/ui/layout.js b/js/ui/layout.js
+index 3d53bd4..cf0dad0 100644
+--- a/js/ui/layout.js
++++ b/js/ui/layout.js
+@@ -564,10 +564,6 @@ var LayoutManager = new Lang.Class({
+         return i;
+     },
+ 
+-    get focusMonitor() {
+-        return this.monitors[this.focusIndex];
+-    },
+-
+     set keyboardIndex(v) {
+         this._keyboardIndex = v;
+         this._updateKeyboardBox();
+diff --git a/js/ui/windowMenu.js b/js/ui/windowMenu.js
+index f0e564b..9bd7d19 100644
+--- a/js/ui/windowMenu.js
++++ b/js/ui/windowMenu.js
+@@ -128,11 +128,12 @@ var WindowMenu = new Lang.Class({
+ 
+         let screen = global.screen;
+         let nMonitors = screen.get_n_monitors();
+-        if (nMonitors > 1) {
++        let monitorIndex = window.get_monitor();
++        // meta_window_get_monitor can return -1, so handle that case
++        // appropriately.
++        if (nMonitors > 1 && monitorIndex >= 0) {
+             this.addMenuItem(new PopupMenu.PopupSeparatorMenuItem());
+ 
+-            let monitorIndex = window.get_monitor();
+-
+             let dir = Meta.ScreenDirection.UP;
+             let upMonitorIndex =
+                 screen.get_monitor_neighbor_index(monitorIndex, dir);
 
=== added file 'debian/patches/st-texture-cache-Cancel-sliced-image-loading-on-target-ac.patch'
--- debian/patches/st-texture-cache-Cancel-sliced-image-loading-on-target-ac.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/st-texture-cache-Cancel-sliced-image-loading-on-target-ac.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,118 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Wed, 29 Nov 2017 19:48:02 -0600
+Subject: st-texture-cache: Cancel sliced image loading on target actor
+ destroy
+
+It might happen that the target clutter actor that we return on call
+of st_texture_cache_load_sliced_image might be destroyed while the
+loading task is still running. To protect from this, let's connect
+to "destroy" signal and when this happens we use a cancellable to
+stop the task.
+
+This allows to safely reuse the return value of this function to
+cancel the execution and avoiding that load_callback is called
+even for a request that is not anymore under our control.
+
+Forwarded: yes, https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/5
+---
+ src/st/st-texture-cache.c | 30 ++++++++++++++++++++++++++----
+ 1 file changed, 26 insertions(+), 4 deletions(-)
+
+diff --git a/src/st/st-texture-cache.c b/src/st/st-texture-cache.c
+index e8a832d..13b019e 100644
+--- a/src/st/st-texture-cache.c
++++ b/src/st/st-texture-cache.c
+@@ -1019,6 +1019,7 @@ typedef struct {
+   gint   grid_width, grid_height;
+   gint   scale_factor;
+   ClutterActor *actor;
++  GCancellable *cancellable;
+   GFunc load_callback;
+   gpointer load_callback_data;
+ } AsyncImageData;
+@@ -1029,10 +1030,21 @@ on_data_destroy (gpointer data)
+   AsyncImageData *d = (AsyncImageData *)data;
+   g_object_unref (d->gfile);
+   g_object_unref (d->actor);
++  g_object_unref (d->cancellable);
+   g_free (d);
+ }
+ 
+ static void
++on_sliced_image_actor_destroyed (ClutterActor *actor,
++                                 gpointer data)
++{
++  GTask *task = data;
++  GCancellable *cancellable = g_task_get_cancellable (task);
++
++  g_cancellable_cancel (cancellable);
++}
++
++static void
+ on_sliced_image_loaded (GObject *source_object,
+                         GAsyncResult *res,
+                         gpointer user_data)
+@@ -1042,7 +1054,7 @@ on_sliced_image_loaded (GObject *source_object,
+   GTask *task = G_TASK (res);
+   GList *list, *pixbufs;
+ 
+-  if (g_task_had_error (task))
++  if (g_task_had_error (task) || g_cancellable_is_cancelled (data->cancellable))
+     return;
+ 
+   pixbufs = g_task_propagate_pointer (task, NULL);
+@@ -1056,6 +1068,10 @@ on_sliced_image_loaded (GObject *source_object,
+ 
+   g_list_free_full (pixbufs, g_object_unref);
+ 
++  g_signal_handlers_disconnect_by_func (data->actor,
++                                        on_sliced_image_actor_destroyed,
++                                        task);
++
+   if (data->load_callback != NULL)
+     data->load_callback (cache, data->load_callback_data);
+ }
+@@ -1093,7 +1109,7 @@ load_sliced_image (GTask        *result,
+   gchar *buffer = NULL;
+   gsize length;
+ 
+-  g_assert (!cancellable);
++  g_assert (cancellable);
+ 
+   data = task_data;
+   g_assert (data);
+@@ -1101,7 +1117,7 @@ load_sliced_image (GTask        *result,
+   loader = gdk_pixbuf_loader_new ();
+   g_signal_connect (loader, "size-prepared", G_CALLBACK (on_loader_size_prepared), data);
+ 
+-  if (!g_file_load_contents (data->gfile, NULL, &buffer, &length, NULL, &error))
++  if (!g_file_load_contents (data->gfile, cancellable, &buffer, &length, NULL, &error))
+     {
+       g_warning ("Failed to open sliced image: %s", error->message);
+       goto out;
+@@ -1169,6 +1185,7 @@ st_texture_cache_load_sliced_image (StTextureCache *cache,
+   AsyncImageData *data;
+   GTask *result;
+   ClutterActor *actor = clutter_actor_new ();
++  GCancellable *cancellable = g_cancellable_new ();
+ 
+   data = g_new0 (AsyncImageData, 1);
+   data->grid_width = grid_width;
+@@ -1176,11 +1193,16 @@ st_texture_cache_load_sliced_image (StTextureCache *cache,
+   data->scale_factor = scale;
+   data->gfile = g_object_ref (file);
+   data->actor = actor;
++  data->cancellable = cancellable;
+   data->load_callback = load_callback;
+   data->load_callback_data = user_data;
+   g_object_ref (G_OBJECT (actor));
+ 
+-  result = g_task_new (cache, NULL, on_sliced_image_loaded, data);
++  result = g_task_new (cache, cancellable, on_sliced_image_loaded, data);
++
++  g_signal_connect (actor, "destroy",
++                    G_CALLBACK (on_sliced_image_actor_destroyed), result);
++
+   g_task_set_task_data (result, data, on_data_destroy);
+   g_task_run_in_thread (result, load_sliced_image);
+ 
 
=== added file 'debian/patches/st-texture-cache-Don-t-add-NULL-textures-to-cache.patch'
--- debian/patches/st-texture-cache-Don-t-add-NULL-textures-to-cache.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/st-texture-cache-Don-t-add-NULL-textures-to-cache.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,92 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Tue, 17 Apr 2018 04:43:34 -0500
+Subject: st-texture-cache: Don't add NULL textures to cache
+
+This might cause a crash when cleaning up the cache as the hash table has
+cogl_object_unref as DestroyNotify function but that assumes that
+the passed object is a valid CoglObject.
+
+st-texture-cache: Save cairo surfaces to a different map
+
+The default keyed_surface is meant to handle CoglTextures thus we can't
+add cairo surfaces to it, as the DestroyNotify function won't handle them.
+
+Then the quicker way is to just add another Hash table for handling
+such types of textures, with proper destroy function.
+
+Forwarded: yes, https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/79
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/210
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/gnome-shell/+bug/1754445
+---
+ src/st/st-texture-cache.c | 16 ++++++++++++++--
+ 1 file changed, 14 insertions(+), 2 deletions(-)
+
+diff --git a/src/st/st-texture-cache.c b/src/st/st-texture-cache.c
+index 13b019e..168473b 100644
+--- a/src/st/st-texture-cache.c
++++ b/src/st/st-texture-cache.c
+@@ -37,6 +37,7 @@ struct _StTextureCachePrivate
+ 
+   /* Things that were loaded with a cache policy != NONE */
+   GHashTable *keyed_cache; /* char * -> CoglTexture* */
++  GHashTable *surfaces_keyed_cache; /* char * -> cairo_surface_t* */
+ 
+   /* Presently this is used to de-duplicate requests for GIcons and async URIs. */
+   GHashTable *outstanding_requests; /* char * -> AsyncTextureLoadData * */
+@@ -145,6 +146,10 @@ st_texture_cache_init (StTextureCache *self)
+ 
+   self->priv->keyed_cache = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                                    g_free, cogl_object_unref);
++  self->priv->surfaces_keyed_cache = g_hash_table_new_full (g_str_hash,
++                                                            g_str_equal,
++                                                            g_free,
++                                                            (GDestroyNotify) cairo_surface_destroy);
+   self->priv->outstanding_requests = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                                             g_free, NULL);
+   self->priv->file_monitors = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal,
+@@ -166,6 +171,7 @@ st_texture_cache_dispose (GObject *object)
+     }
+ 
+   g_clear_pointer (&self->priv->keyed_cache, g_hash_table_destroy);
++  g_clear_pointer (&self->priv->surfaces_keyed_cache, g_hash_table_destroy);
+   g_clear_pointer (&self->priv->outstanding_requests, g_hash_table_destroy);
+   g_clear_pointer (&self->priv->file_monitors, g_hash_table_destroy);
+ 
+@@ -520,6 +526,8 @@ finish_texture_load (AsyncTextureLoadData *data,
+     goto out;
+ 
+   texdata = pixbuf_to_cogl_texture (pixbuf);
++  if (!texdata)
++    goto out;
+ 
+   if (data->policy != ST_TEXTURE_CACHE_POLICY_NONE)
+     {
+@@ -1295,6 +1303,9 @@ st_texture_cache_load_file_sync_to_cogl_texture (StTextureCache *cache,
+       texdata = pixbuf_to_cogl_texture (pixbuf);
+       g_object_unref (pixbuf);
+ 
++      if (!texdata)
++        goto out;
++
+       if (policy == ST_TEXTURE_CACHE_POLICY_FOREVER)
+         {
+           cogl_object_ref (texdata);
+@@ -1326,7 +1337,7 @@ st_texture_cache_load_file_sync_to_cairo_surface (StTextureCache        *cache,
+ 
+   key = g_strdup_printf (CACHE_PREFIX_FILE_FOR_CAIRO "%u", g_file_hash (file));
+ 
+-  surface = g_hash_table_lookup (cache->priv->keyed_cache, key);
++  surface = g_hash_table_lookup (cache->priv->surfaces_keyed_cache, key);
+ 
+   if (surface == NULL)
+     {
+@@ -1340,7 +1351,8 @@ st_texture_cache_load_file_sync_to_cairo_surface (StTextureCache        *cache,
+       if (policy == ST_TEXTURE_CACHE_POLICY_FOREVER)
+         {
+           cairo_surface_reference (surface);
+-          g_hash_table_insert (cache->priv->keyed_cache, g_strdup (key), surface);
++          g_hash_table_insert (cache->priv->surfaces_keyed_cache,
++                               g_strdup (key), surface);
+         }
+     }
+   else
 
=== added file 'debian/patches/volume-Add-back-sound-feedback-on-scroll.patch'
--- debian/patches/volume-Add-back-sound-feedback-on-scroll.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/volume-Add-back-sound-feedback-on-scroll.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,106 @@
+From: =?utf-8?q?Florian_M=C3=BCllner?= <[e-mail]>
+Date: Fri, 23 Feb 2018 16:58:22 -0600
+Subject: volume: Add back sound feedback on scroll
+
+Commit 8d4855f1008 accidentally removed the volume change feedback
+for scroll events. Add it back to be consistent again with moving
+the slider via arrow keys, slider drags/clicks and gsd's media keys
+handling.
+
+https://gitlab.gnome.org/GNOME/gnome-shell/issues/53
+
+volume: Only emit sound feedback after volume changes
+
+gnome-settings-daemon doesn't play the volume change sound when
+the volume stayed the same (that is, it is already at its maximum
+or minimum). This looks like the right thing to do, so copy its
+behavior.
+
+https://gitlab.gnome.org/GNOME/gnome-shell/issues/53
+
+slider: Stop emulating drags in key handling
+
+Emitting ::drag-end after changing the slider value via arrow keys
+was a cheap way to make the sound feedback work for keyboard input.
+But now that the volume indicator plays the sound on ::value-changed
+as well, we can stop doing that - after all, key presses aren't drags.
+
+Besides that, this will make the limiting of feedback to actual volume
+changes from the previous commit work for key events as well.
+
+https://gitlab.gnome.org/GNOME/gnome-shell/issues/53
+
+Bug-GNOME: https://gitlab.gnome.org/GNOME/gnome-shell/issues/53
+Forwarded: yes, https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/51
+---
+ js/ui/slider.js        |  2 --
+ js/ui/status/volume.js | 19 ++++++++++++++++++-
+ 2 files changed, 18 insertions(+), 3 deletions(-)
+
+diff --git a/js/ui/slider.js b/js/ui/slider.js
+index 9853929..30295b4 100644
+--- a/js/ui/slider.js
++++ b/js/ui/slider.js
+@@ -232,9 +232,7 @@ var Slider = new Lang.Class({
+             let delta = key == Clutter.KEY_Right ? 0.1 : -0.1;
+             this._value = Math.max(0, Math.min(this._value + delta, 1));
+             this.actor.queue_repaint();
+-            this.emit('drag-begin');
+             this.emit('value-changed', this._value);
+-            this.emit('drag-end');
+             return Clutter.EVENT_STOP;
+         }
+         return Clutter.EVENT_PROPAGATE;
+diff --git a/js/ui/status/volume.js b/js/ui/status/volume.js
+index 65c4c42..c0f9cf3 100644
+--- a/js/ui/status/volume.js
++++ b/js/ui/status/volume.js
+@@ -4,6 +4,7 @@ const Clutter = imports.gi.Clutter;
+ const Lang = imports.lang;
+ const Gio = imports.gi.Gio;
+ const Gvc = imports.gi.Gvc;
++const Mainloop = imports.mainloop;
+ const St = imports.gi.St;
+ const Signals = imports.signals;
+ 
+@@ -36,9 +37,16 @@ var StreamSlider = new Lang.Class({
+ 
+         this.item = new PopupMenu.PopupBaseMenuItem({ activate: false });
+ 
++        this._inDrag = false;
++        this._notifyVolumeChangeId = 0;
++
+         this._slider = new Slider.Slider(0);
++        this._slider.connect('drag-begin', () => { this._inDrag = true; });
+         this._slider.connect('value-changed', this._sliderChanged.bind(this));
+-        this._slider.connect('drag-end', this._notifyVolumeChange.bind(this));
++        this._slider.connect('drag-end', () => {
++            this._inDrag = false;
++            this._notifyVolumeChange();
++        });
+ 
+         this._icon = new St.Icon({ style_class: 'popup-menu-icon' });
+         this.item.actor.add(this._icon);
+@@ -135,6 +143,7 @@ var StreamSlider = new Lang.Class({
+ 
+         let volume = value * this._get_control_max_volume();
+         let prevMuted = this._stream.is_muted;
++        let prevVolume = this._stream.volume;
+         if (volume < 1) {
+             this._stream.volume = 0;
+             if (!prevMuted)
+@@ -145,6 +154,14 @@ var StreamSlider = new Lang.Class({
+                 this._stream.change_is_muted(false);
+         }
+         this._stream.push_volume();
++
++        let volumeChanged = this._stream.volume != prevVolume;
++        if (volumeChanged && !this._notifyVolumeChangeId && !this._inDrag)
++            this._notifyVolumeChangeId = Mainloop.timeout_add(30, () => {
++                this._notifyVolumeChange();
++                this._notifyVolumeChangeId = 0;
++                return GLib.SOURCE_REMOVE;
++            });
+     },
+ 
+     _notifyVolumeChange() {
 
=== added file 'debian/patches/workspace-fix-repositioned-windows-in-activities.patch'
--- debian/patches/workspace-fix-repositioned-windows-in-activities.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/workspace-fix-repositioned-windows-in-activities.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,148 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 19 Jan 2018 08:00:10 -0600
+Subject: workspace: fix repositioned windows in activities
+
+workspace: Recompute bounding box on window 'position-changed'
+
+We need to update the clone position if window size changed
+also, rename meta window 'size-changed' callback accordingly.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=792681
+
+workspaceThumbnail: Sync clone position changes with actor
+
+We need to update the clone position if window actor (not the meta window)
+position changed.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=792681
+
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=776588
+Bug-Ubuntu: https://bugs.launchpad.net/gnome-shell/+bug/1653153
+Forwarded: yes, https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/8
+---
+ js/ui/workspace.js          | 28 +++++++++++++++-------------
+ js/ui/workspaceThumbnail.js |  9 ++++-----
+ 2 files changed, 19 insertions(+), 18 deletions(-)
+
+diff --git a/js/ui/workspace.js b/js/ui/workspace.js
+index 8836537..f06b78e 100644
+--- a/js/ui/workspace.js
++++ b/js/ui/workspace.js
+@@ -137,8 +137,10 @@ var WindowClone = new Lang.Class({
+         this._dragSlot = [0, 0, 0, 0];
+         this._stackAbove = null;
+ 
+-        this._windowClone._updateId = this.metaWindow.connect('size-changed',
+-            this._onRealWindowSizeChanged.bind(this));
++        this._windowClone._sizeChangedId = this.metaWindow.connect('size-changed',
++            this._onMetaWindowSizeChanged.bind(this));
++        this._windowClone._posChangedId = this.metaWindow.connect('position-changed',
++            this._computeBoundingBox.bind(this));
+         this._windowClone._destroyId = this.realWindow.connect('destroy',
+             this.destroy.bind(this));
+ 
+@@ -200,8 +202,7 @@ var WindowClone = new Lang.Class({
+ 
+     addAttachedDialog(win) {
+         this._doAddAttachedDialog(win, win.get_compositor_private());
+-        this._computeBoundingBox();
+-        this.emit('size-changed');
++        this._onMetaWindowSizeChanged();
+     },
+ 
+     hasAttachedDialogs() {
+@@ -210,15 +211,14 @@ var WindowClone = new Lang.Class({
+ 
+     _doAddAttachedDialog(metaWin, realWin) {
+         let clone = new Clutter.Clone({ source: realWin });
+-        clone._updateId = metaWin.connect('size-changed', () => {
+-            this._computeBoundingBox();
+-            this.emit('size-changed');
+-        });
++        clone._sizeChangedId = metaWin.connect('size-changed',
++            this._onMetaWindowSizeChanged.bind(this));
++        clone._posChangedId = metaWin.connect('position-changed',
++            this._onMetaWindowSizeChanged.bind(this));
+         clone._destroyId = realWin.connect('destroy', () => {
+             clone.destroy();
+ 
+-            this._computeBoundingBox();
+-            this.emit('size-changed');
++            this._onMetaWindowSizeChanged.bind(this);
+         });
+         this.actor.add_child(clone);
+     },
+@@ -308,7 +308,8 @@ var WindowClone = new Lang.Class({
+ 
+         // First destroy the clone and then destroy everything
+         // This will ensure that we never see it in the _disconnectSignals loop
+-        this.metaWindow.disconnect(this._windowClone._updateId);
++        this.metaWindow.disconnect(this._windowClone._sizeChangedId);
++        this.metaWindow.disconnect(this._windowClone._posChangedId);
+         this.realWindow.disconnect(this._windowClone._destroyId);
+         this._windowClone.destroy();
+ 
+@@ -323,12 +324,13 @@ var WindowClone = new Lang.Class({
+             else
+                 realWindow = child.source;
+ 
+-            realWindow.meta_window.disconnect(child._updateId);
++            realWindow.meta_window.disconnect(child._sizeChangedId);
++            realWindow.meta_window.disconnect(child._posChangedId);
+             realWindow.disconnect(child._destroyId);
+         });
+     },
+ 
+-    _onRealWindowSizeChanged() {
++    _onMetaWindowSizeChanged() {
+         this._computeBoundingBox();
+         this.emit('size-changed');
+     },
+diff --git a/js/ui/workspaceThumbnail.js b/js/ui/workspaceThumbnail.js
+index 0c72e74..4db8c19 100644
+--- a/js/ui/workspaceThumbnail.js
++++ b/js/ui/workspaceThumbnail.js
+@@ -68,7 +68,7 @@ var WindowClone = new Lang.Class({
+         this.realWindow = realWindow;
+         this.metaWindow = realWindow.meta_window;
+ 
+-        this.clone._updateId = this.metaWindow.connect('position-changed',
++        this.clone._updateId = this.realWindow.connect('notify::position',
+                                                        this._onPositionChanged.bind(this));
+         this.clone._destroyId = this.realWindow.connect('destroy', this.destroy.bind(this));
+         this._onPositionChanged();
+@@ -141,7 +141,7 @@ var WindowClone = new Lang.Class({
+ 
+         // First destroy the clone and then destroy everything
+         // This will ensure that we never see it in the _disconnectSignals loop
+-        this.metaWindow.disconnect(this.clone._updateId);
++        this.realWindow.disconnect(this.clone._updateId);
+         this.realWindow.disconnect(this.clone._destroyId);
+         this.clone.destroy();
+ 
+@@ -156,7 +156,7 @@ var WindowClone = new Lang.Class({
+         let clone = new Clutter.Clone({ source: realDialog });
+         this._updateDialogPosition(realDialog, clone);
+ 
+-        clone._updateId = metaDialog.connect('position-changed', dialog => {
++        clone._updateId = metaDialog.connect('notify::position', dialog => {
+             this._updateDialogPosition(dialog, clone);
+         });
+         clone._destroyId = realDialog.connect('destroy', () => {
+@@ -174,7 +174,6 @@ var WindowClone = new Lang.Class({
+     },
+ 
+     _onPositionChanged() {
+-        let rect = this.metaWindow.get_frame_rect();
+         this.actor.set_position(this.realWindow.x, this.realWindow.y);
+     },
+ 
+@@ -182,7 +181,7 @@ var WindowClone = new Lang.Class({
+         this.actor.get_children().forEach(child => {
+             let realWindow = child.source;
+ 
+-            realWindow.meta_window.disconnect(child._updateId);
++            realWindow.disconnect(child._updateId);
+             realWindow.disconnect(child._destroyId);
+         });
+     },
 
=== added file 'debian/patches/workspaceThumbnail-initialize-porthole-based-on-workArea.patch'
--- debian/patches/workspaceThumbnail-initialize-porthole-based-on-workArea.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/workspaceThumbnail-initialize-porthole-based-on-workArea.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,36 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 19 Jan 2018 10:37:20 -0600
+Subject: workspaceThumbnail: initialize porthole based on workArea
+
+https://bugzilla.gnome.org/show_bug.cgi?id=792687
+
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=792687
+Origin: https://gitlab.gnome.org/GNOME/gnome-shell/commit/b99e304
+---
+ js/ui/workspaceThumbnail.js | 6 ++----
+ 1 file changed, 2 insertions(+), 4 deletions(-)
+
+diff --git a/js/ui/workspaceThumbnail.js b/js/ui/workspaceThumbnail.js
+index 3dffd12..c1b4bdd 100644
+--- a/js/ui/workspaceThumbnail.js
++++ b/js/ui/workspaceThumbnail.js
+@@ -275,8 +275,8 @@ var WorkspaceThumbnail = new Lang.Class({
+ 
+         this._createBackground();
+ 
+-        let monitor = Main.layoutManager.primaryMonitor;
+-        this.setPorthole(monitor.x, monitor.y, monitor.width, monitor.height);
++        let workArea = Main.layoutManager.getWorkAreaForMonitor(this.monitorIndex);
++        this.setPorthole(workArea.x, workArea.y, workArea.width, workArea.height);
+ 
+         let windows = global.get_window_actors().filter(actor => {
+             let win = actor.meta_window;
+@@ -321,8 +321,6 @@ var WorkspaceThumbnail = new Lang.Class({
+     },
+ 
+     setPorthole(x, y, width, height) {
+-        this._portholeX = x;
+-        this._portholeY = y;
+         this.actor.set_size(width, height);
+         this._contents.set_position(-x, -y);
+     },
 
=== added file 'debian/patches/workspaceThumbnail-only-update-_porthole-if-the-overview-.patch'
--- debian/patches/workspaceThumbnail-only-update-_porthole-if-the-overview-.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/workspaceThumbnail-only-update-_porthole-if-the-overview-.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,29 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 19 Jan 2018 09:31:01 -0600
+Subject: workspaceThumbnail: only update _porthole if the overview is visible
+
+Otherwise it happens that porthole is computed again after that the
+overlay is hidden (triggered by a layout reallocation) and thus not
+regenerated again afterwards.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=792687
+
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=792687
+Origin: https://gitlab.gnome.org/GNOME/gnome-shell/commit/5fcf40b
+---
+ js/ui/workspaceThumbnail.js | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/js/ui/workspaceThumbnail.js b/js/ui/workspaceThumbnail.js
+index 7d5d2c0..5565a1e 100644
+--- a/js/ui/workspaceThumbnail.js
++++ b/js/ui/workspaceThumbnail.js
+@@ -1159,7 +1159,7 @@ var ThumbnailsBox = new Lang.Class({
+     // The "porthole" is the portion of the screen that we show in the
+     // workspaces
+     _ensurePorthole() {
+-        if (!Main.layoutManager.primaryMonitor)
++        if (!Main.layoutManager.primaryMonitor || !Main.overview.visible)
+             return false;
+ 
+         if (!this._porthole)
 
=== added file 'debian/patches/workspaceThumbnail-rebuild-thumbnails-if-workareas-size-c.patch'
--- debian/patches/workspaceThumbnail-rebuild-thumbnails-if-workareas-size-c.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/workspaceThumbnail-rebuild-thumbnails-if-workareas-size-c.patch	2018-04-17 10:30:40 +0000
@@ -0,0 +1,64 @@
+From: =?utf-8?b?Ik1hcmNvIFRyZXZpc2FuIChUcmV2acOxbyki?= <[e-mail]>
+Date: Fri, 19 Jan 2018 09:39:13 -0600
+Subject: workspaceThumbnail: rebuild thumbnails if workareas size changed
+
+https://bugzilla.gnome.org/show_bug.cgi?id=792687
+
+Origin: https://gitlab.gnome.org/GNOME/gnome-shell/commit/c29bd46
+Bug-GNOME: https://bugzilla.gnome.org/show_bug.cgi?id=792687
+---
+ js/ui/workspaceThumbnail.js | 21 ++++++++++++++++-----
+ 1 file changed, 16 insertions(+), 5 deletions(-)
+
+diff --git a/js/ui/workspaceThumbnail.js b/js/ui/workspaceThumbnail.js
+index 5565a1e..3dffd12 100644
+--- a/js/ui/workspaceThumbnail.js
++++ b/js/ui/workspaceThumbnail.js
+@@ -675,11 +675,7 @@ var ThumbnailsBox = new Lang.Class({
+         this._settings.connect('changed::dynamic-workspaces',
+             this._updateSwitcherVisibility.bind(this));
+ 
+-        Main.layoutManager.connect('monitors-changed', () => {
+-            this._destroyThumbnails();
+-            if (Main.overview.visible)
+-                this._createThumbnails();
+-        });
++        Main.layoutManager.connect('monitors-changed', this._rebuildThumbnails.bind(this));
+     },
+ 
+     _updateSwitcherVisibility() {
+@@ -872,6 +868,9 @@ var ThumbnailsBox = new Lang.Class({
+             Main.overview.connect('windows-restacked',
+                                   this._syncStacking.bind(this));
+ 
++        this._workareasChangedId =
++            global.screen.connect('workareas-changed', this._rebuildThumbnails.bind(this));
++
+         this._targetScale = 0;
+         this._scale = 0;
+         this._pendingScaleUpdate = false;
+@@ -901,12 +900,24 @@ var ThumbnailsBox = new Lang.Class({
+             this._syncStackingId = 0;
+         }
+ 
++        if (this._workareasChangedId > 0) {
++            global.screen.disconnect(this._workareasChangedId);
++            this._workareasChangedId = 0;
++        }
++
+         for (let w = 0; w < this._thumbnails.length; w++)
+             this._thumbnails[w].destroy();
+         this._thumbnails = [];
+         this._porthole = null;
+     },
+ 
++    _rebuildThumbnails() {
++        this._destroyThumbnails();
++
++        if (Main.overview.visible)
++            this._createThumbnails();
++    },
++
+     _workspacesChanged() {
+         let validThumbnails =
+             this._thumbnails.filter(t => t.state <= ThumbnailState.NORMAL);