screensaver: Do more to acquire a modal grab attempt when locking.

cinnamon-screensaver made muultiple attempts to acquire a modal
'grab' when activating, including using xdo to cancel ui toolkit
popups.

- Add an asynchronous pushScreensaverModal to do the same.
- Screensaver service 'response' is delayed until this ultimately
  succeeds or fails.
- Suspend inhibitor state is held during this time also.

Author: mtwebster

js/ui/main.js

@@ -1318,6 +1318,40 @@ function _findModal(actor) {
     return -1;
 }
 
+function _completeModalSetup(actor, mode) {
+    if (modalCount == 0)
+        Meta.disable_unredirect_for_display(global.display);
+
+    global.set_stage_input_mode(Cinnamon.StageInputMode.FULLSCREEN);
+
+    actionMode = mode;
+
+    modalCount += 1;
+    let actorDestroyId = actor.connect('destroy', function() {
+        let index = _findModal(actor);
+        if (index >= 0)
+            popModal(actor);
+    });
+
+    let record = {
+        actor: actor,
+        focus: global.stage.get_key_focus(),
+        destroyId: actorDestroyId,
+        actionMode: mode
+    };
+    if (record.focus != null) {
+        record.focusDestroyId = record.focus.connect('destroy', function() {
+            record.focus = null;
+            record.focusDestroyId = null;
+        });
+    }
+    modalActorFocusStack.push(record);
+
+    global.stage.set_key_focus(actor);
+
+    layoutManager.updateChrome(true);
+}
+
 /**
  * pushModal:
  * @actor (Clutter.Actor): actor which will be given keyboard focus
@@ -1356,38 +1390,46 @@ function pushModal(actor, timestamp, options, mode) {
             log('pushModal: invocation of begin_modal failed');
             return false;
         }
-        Meta.disable_unredirect_for_display(global.display);
     }
 
-    global.set_stage_input_mode(Cinnamon.StageInputMode.FULLSCREEN);
-
-    actionMode = mode;
+    _completeModalSetup(actor, mode);
+    return true;
+}
 
-    modalCount += 1;
-    let actorDestroyId = actor.connect('destroy', function() {
-        let index = _findModal(actor);
-        if (index >= 0)
-            popModal(actor);
-    });
+/**
+ * pushScreensaverModal:
+ * @actor (Clutter.Actor): actor which will be given keyboard focus.
+ * @timestamp (number): optional X server timestamp.
+ * @mode (Cinnamon.ActionMode): the action mode for the modal grab.
+ * @callback (function): called with (success) when the grab completes.
+ *
+ * Like pushModal(), but uses begin_modal_with_retry() to asynchronously
+ * retry the grab on X11, using libxdo to break stuck grabs from popup
+ * menus. The callback is called with true on success, false on failure.
+ */
+function pushScreensaverModal(actor, timestamp, mode, callback) {
+    if (timestamp == undefined)
+        timestamp = global.get_current_time();
 
-    let record = {
-        actor: actor,
-        focus: global.stage.get_key_focus(),
-        destroyId: actorDestroyId,
-        actionMode: mode
-    };
-    if (record.focus != null) {
-        record.focusDestroyId = record.focus.connect('destroy', function() {
-            record.focus = null;
-            record.focusDestroyId = null;
-        });
-    }
-    modalActorFocusStack.push(record);
+    log('pushScreensaverModal: requesting modal grab with retry');
 
-    global.stage.set_key_focus(actor);
+    global.begin_modal_with_retry(timestamp, 0,
+        (obj, success) => {
+            if (!success) {
+                log('pushScreensaverModal: failed to acquire modal grab after retries');
+                callback(false);
+                return;
+            }
 
-    layoutManager.updateChrome(true);
-    return true;
+            try {
+                _completeModalSetup(actor, mode);
+                callback(true);
+            } catch (e) {
+                global.logError(`pushScreensaverModal: error during modal setup: ${e.message}`);
+                global.end_modal(global.get_current_time());
+                callback(false);
+            }
+        });
 }
 
 /**

js/ui/screensaver/screenShield.js

@@ -129,6 +129,7 @@ var ScreenShield = GObject.registerClass({
         this._widgetLoadIdleId = 0;
         this._infoPanel = null;
         this._inhibitor = null;
+        this._activationPending = false;
 
         this._nameBlocker = new NameBlocker.NameBlocker();
 
@@ -356,19 +357,24 @@ var ScreenShield = GObject.registerClass({
     }
 
     lock(immediate = false, awayMessage = null) {
-        if (this.isLocked())
+        if (this.isLocked() || this._activationPending) {
+            _log('ScreenShield: Already locked or activation pending, ignoring lock request');
             return;
+        }
 
         this._awayMessage = awayMessage;
 
         _log(`ScreenShield: Locking screen (immediate=${immediate})`);
 
         if (this._state === State.HIDDEN) {
-            this.activate(immediate);
+            this.activate(immediate, () => {
+                this._stopLockDelay();
+                this._setLocked(true);
+            });
+        } else {
+            this._stopLockDelay();
+            this._setLocked(true);
         }
-
-        this._stopLockDelay();
-        this._setLocked(true);
     }
 
     _setLocked(locked) {
@@ -397,9 +403,9 @@ var ScreenShield = GObject.registerClass({
         this._hideShield(true);
     }
 
-    activate(immediate = false) {
-        if (this._state !== State.HIDDEN) {
-            _log('ScreenShield: Already active');
+    activate(immediate = false, callback = null) {
+        if (this._state !== State.HIDDEN || this._activationPending) {
+            _log('ScreenShield: Already active or activation pending');
             return;
         }
 
@@ -409,11 +415,34 @@ var ScreenShield = GObject.registerClass({
         this._lastMotionY = -1;
         this._activationTime = GLib.get_monotonic_time();
 
-        if (!Main.pushModal(this, global.get_current_time(), 0, Cinnamon.ActionMode.LOCK_SCREEN)) {
-            global.logError('ScreenShield: Failed to acquire modal grab');
-            return;
-        }
+        this._activationPending = true;
+        _log('ScreenShield: requesting screensaver modal grab');
+        Main.pushScreensaverModal(this, global.get_current_time(), Cinnamon.ActionMode.LOCK_SCREEN,
+            (success) => {
+                this._activationPending = false;
+
+                if (!success) {
+                    global.logError('ScreenShield: Failed to acquire modal grab');
+                    this._syncInhibitor();
+                    return;
+                }
 
+                _log('ScreenShield: modal grab acquired, finishing activation');
+
+                try {
+                    this._finishActivation(immediate);
+
+                    if (callback)
+                        callback();
+                } catch (e) {
+                    global.logError(`ScreenShield: error during activation: ${e.message}`);
+                    Main.popModal(this);
+                    this._syncInhibitor();
+                }
+            });
+    }
+
+    _finishActivation(immediate) {
         this._setState(State.SHOWN);
 
         this._createBackgrounds();
@@ -495,6 +524,12 @@ var ScreenShield = GObject.registerClass({
             return;
         }
 
+        if (this._activationPending) {
+            _log('ScreenShield: Cancelling pending activation');
+            global.end_modal(global.get_current_time());
+            return;
+        }
+
         this._stopLockDelay();
         this._hideShield(false);
     }
@@ -552,7 +587,8 @@ var ScreenShield = GObject.registerClass({
     _syncInhibitor() {
         let lockEnabled = this._settings.get_boolean('lock-enabled');
         let lockDisabled = Main.lockdownSettings.get_boolean('disable-lock-screen');
-        let shouldInhibit = this._state === State.HIDDEN && lockEnabled && !lockDisabled;
+        let shouldInhibit = (this._state === State.HIDDEN || this._activationPending) &&
+                            lockEnabled && !lockDisabled;
 
         if (shouldInhibit && !this._inhibitor) {
             _log('ScreenShield: Acquiring sleep inhibitor');
@@ -563,7 +599,7 @@ var ScreenShield = GObject.registerClass({
                 }
 
                 // Re-check after async - conditions may have changed
-                let stillNeeded = this._state === State.HIDDEN &&
+                let stillNeeded = (this._state === State.HIDDEN || this._activationPending) &&
                                   this._settings.get_boolean('lock-enabled') &&
                                   !Main.lockdownSettings.get_boolean('disable-lock-screen');
                 if (stillNeeded) {

src/cinnamon-global-private.h

@@ -20,6 +20,7 @@
 #endif
 
 #include <meta/meta-plugin.h>
+#include <xdo.h>
 
 
 #include "cinnamon-enum-types.h"
@@ -31,6 +32,16 @@
 
 #include <cjs/gjs.h>
 
+typedef struct {
+    CinnamonGlobal                *global;
+    guint32                        timestamp;
+    MetaModalOptions               options;
+    gint                           attempt;
+    gboolean                       tried_xdo;
+    CinnamonModalCallback          callback;
+    gpointer                       user_data;
+} ModalRetryData;
+
 struct _CinnamonGlobal {
   GObject parent;
 
@@ -64,6 +75,10 @@ struct _CinnamonGlobal {
   gboolean has_modal;
 
   guint notif_service_id;
+
+  xdo_t *xdo;
+  guint modal_retry_source_id;
+  ModalRetryData *modal_retry_data;
 };
 
 void _cinnamon_global_init            (const char *first_property_name,