gnome-shell/login-screen-extensions.patch

From e7fe96d918ef75f59448664d7583eb51735be64d Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Tue, 10 Aug 2021 13:25:57 -0400
Subject: [PATCH 1/3] extensionSystem: Get rid of _enabled boolean optimization

At the moment a session mode either allows extensions or it doesn't.
If it allows extensions, then the entire available list of
configured extensions get enabled as soon as the session mode is
entered.

Since enabling or disabling extensions is an all or nothing situation,
the code tracks whether extensions are already enabled when entering
the session mode, and if so, avoids iterating through the extension list
needlessly. It does this using a boolean named _enabled.

In the future, the extensions themselves will be given some say on
whether or not they should be enabled in a given session mode. This
means, the configured extension list may contain extensions that
shouldn't be enabled for a given session mode, and the _enabled boolean
will no longer be appropriated.

This commit drops the _enabled boolean optimization.
---
 js/ui/extensionSystem.js | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/js/ui/extensionSystem.js b/js/ui/extensionSystem.js
index 6b624fca0..9a8f1c9a2 100644
--- a/js/ui/extensionSystem.js
+++ b/js/ui/extensionSystem.js
@@ -1,56 +1,55 @@
 // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
 /* exported init connect disconnect */
 
 const { GLib, Gio, GObject, Shell, St } = imports.gi;
 const ByteArray = imports.byteArray;
 const Signals = imports.signals;
 
 const ExtensionDownloader = imports.ui.extensionDownloader;
 const ExtensionUtils = imports.misc.extensionUtils;
 const FileUtils = imports.misc.fileUtils;
 const Main = imports.ui.main;
 const MessageTray = imports.ui.messageTray;
 
 const { ExtensionState, ExtensionType } = ExtensionUtils;
 
 const ENABLED_EXTENSIONS_KEY = 'enabled-extensions';
 const DISABLED_EXTENSIONS_KEY = 'disabled-extensions';
 const DISABLE_USER_EXTENSIONS_KEY = 'disable-user-extensions';
 const EXTENSION_DISABLE_VERSION_CHECK_KEY = 'disable-extension-version-validation';
 
 const UPDATE_CHECK_TIMEOUT = 24 * 60 * 60; // 1 day in seconds
 
 var ExtensionManager = class {
     constructor() {
         this._initialized = false;
-        this._enabled = false;
         this._updateNotified = false;
 
         this._extensions = new Map();
         this._unloadedExtensions = new Map();
         this._enabledExtensions = [];
         this._extensionOrder = [];
 
         Main.sessionMode.connect('updated', this._sessionUpdated.bind(this));
     }
 
     init() {
         // The following file should exist for a period of time when extensions
         // are enabled after start. If it exists, then the systemd unit will
         // disable extensions should gnome-shell crash.
         // Should the file already exist from a previous login, then this is OK.
         let disableFilename = GLib.build_filenamev([GLib.get_user_runtime_dir(), 'gnome-shell-disable-extensions']);
         let disableFile = Gio.File.new_for_path(disableFilename);
         try {
             disableFile.create(Gio.FileCreateFlags.REPLACE_DESTINATION, null);
         } catch (e) {
             log('Failed to create file %s: %s'.format(disableFilename, e.message));
         }
 
         GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 60, () => {
             disableFile.delete(null);
             return GLib.SOURCE_REMOVE;
         });
 
         this._installExtensionUpdates();
         this._sessionUpdated();
@@ -563,85 +562,76 @@ var ExtensionManager = class {
 
         this._enabledExtensions = this._getEnabledExtensions();
 
         let perUserDir = Gio.File.new_for_path(global.userdatadir);
         FileUtils.collectFromDatadirs('extensions', true, (dir, info) => {
             let fileType = info.get_file_type();
             if (fileType != Gio.FileType.DIRECTORY)
                 return;
             let uuid = info.get_name();
             let existing = this.lookup(uuid);
             if (existing) {
                 log('Extension %s already installed in %s. %s will not be loaded'.format(uuid, existing.path, dir.get_path()));
                 return;
             }
 
             let extension;
             let type = dir.has_prefix(perUserDir)
                 ? ExtensionType.PER_USER
                 : ExtensionType.SYSTEM;
             try {
                 extension = this.createExtensionObject(uuid, dir, type);
             } catch (e) {
                 logError(e, 'Could not load extension %s'.format(uuid));
                 return;
             }
             this.loadExtension(extension);
         });
     }
 
     _enableAllExtensions() {
-        if (this._enabled)
-            return;
-
         if (!this._initialized) {
             this._loadExtensions();
             this._initialized = true;
         } else {
             this._enabledExtensions.forEach(uuid => {
                 this._callExtensionEnable(uuid);
             });
         }
-        this._enabled = true;
     }
 
     _disableAllExtensions() {
-        if (!this._enabled)
-            return;
-
         if (this._initialized) {
             this._extensionOrder.slice().reverse().forEach(uuid => {
                 this._callExtensionDisable(uuid);
             });
         }
-
-        this._enabled = false;
     }
 
     _sessionUpdated() {
         // For now sessionMode.allowExtensions controls extensions from both the
         // 'enabled-extensions' preference and the sessionMode.enabledExtensions
         // property; it might make sense to make enabledExtensions independent
         // from allowExtensions in the future
         if (Main.sessionMode.allowExtensions) {
             // Take care of added or removed sessionMode extensions
             this._onEnabledExtensionsChanged();
             this._enableAllExtensions();
         } else {
             this._disableAllExtensions();
         }
     }
 };
 Signals.addSignalMethods(ExtensionManager.prototype);
 
 const ExtensionUpdateSource = GObject.registerClass(
 class ExtensionUpdateSource extends MessageTray.Source {
     _init() {
         let appSys = Shell.AppSystem.get_default();
         this._app = appSys.lookup_app('org.gnome.Extensions.desktop');
 
         super._init(this._app.get_name());
     }
 
     getIcon() {
         return this._app.app_info.get_icon();
     }
-- 
2.31.1


From c96d908167b8bb088454e0e839d1c2d6e3638676 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Sat, 28 Aug 2021 13:54:39 -0400
Subject: [PATCH 2/3] extensionSystem: Allow extensions to run on the login
 screen

At the moment it's not realy possible to extend the login screen to do
things it doesn't have built-in support for. This means in order
to support niche use cases, those cases have to change the main
code base. For instance, oVirt and Vmware deployments want to be able
to automaticaly log in guest VMs when a user pre-authenticates through a
console on a management host. To support those use cases, we added
code to the login screen directly, even though most machines will never
be associated with oVirt or Vmware management hosts.

We also get requests from e.g. government users that need certain features
at the login screen that wouldn't get used much outside of government
deployments. For instance, we've gotten requests that a machine contains
prominently displays that it has "Top Secret" information.

All of these use cases seem like they would better handled via
extensions that could be installed in the specific deployments. The
problem is extensions only run in the user session, and get
disabled at the login screen automatically.

This commit changes that. Now extensions can specify in their metadata
via a new sessionModes property, which modes that want to run in. For
backward compatibility, if an extension doesn't specify which session
modes it works in, its assumed the extension only works in the user
session.
---
 js/ui/extensionSystem.js | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/js/ui/extensionSystem.js b/js/ui/extensionSystem.js
index 9a8f1c9a2..bbf322ee7 100644
--- a/js/ui/extensionSystem.js
+++ b/js/ui/extensionSystem.js
@@ -47,120 +47,142 @@ var ExtensionManager = class {
         }
 
         GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 60, () => {
             disableFile.delete(null);
             return GLib.SOURCE_REMOVE;
         });
 
         this._installExtensionUpdates();
         this._sessionUpdated();
 
         GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, UPDATE_CHECK_TIMEOUT, () => {
             ExtensionDownloader.checkForUpdates();
             return GLib.SOURCE_CONTINUE;
         });
         ExtensionDownloader.checkForUpdates();
     }
 
     get updatesSupported() {
         const appSys = Shell.AppSystem.get_default();
         return appSys.lookup_app('org.gnome.Extensions.desktop') !== null;
     }
 
     lookup(uuid) {
         return this._extensions.get(uuid);
     }
 
     getUuids() {
         return [...this._extensions.keys()];
     }
 
+    _extensionSupportsSessionMode(uuid) {
+        const extension = this.lookup(uuid);
+        if (!extension)
+            return false;
+
+        if (extension.sessionModes.includes(Main.sessionMode.currentMode))
+            return true;
+        if (extension.sessionModes.includes(Main.sessionMode.parentMode))
+            return true;
+        return false;
+    }
+
+    _sessionModeCanUseExtension(uuid) {
+        if (!Main.sessionMode.allowExtensions)
+            return false;
+
+        if (!this._extensionSupportsSessionMode(uuid))
+            return false;
+
+        return true;
+    }
+
     _callExtensionDisable(uuid) {
         let extension = this.lookup(uuid);
         if (!extension)
             return;
 
         if (extension.state != ExtensionState.ENABLED)
             return;
 
         // "Rebase" the extension order by disabling and then enabling extensions
         // in order to help prevent conflicts.
 
         // Example:
         //   order = [A, B, C, D, E]
         //   user disables C
         //   this should: disable E, disable D, disable C, enable D, enable E
 
         let orderIdx = this._extensionOrder.indexOf(uuid);
         let order = this._extensionOrder.slice(orderIdx + 1);
         let orderReversed = order.slice().reverse();
 
         for (let i = 0; i < orderReversed.length; i++) {
             let otherUuid = orderReversed[i];
             try {
                 this.lookup(otherUuid).stateObj.disable();
             } catch (e) {
                 this.logExtensionError(otherUuid, e);
             }
         }
 
         try {
             extension.stateObj.disable();
         } catch (e) {
             this.logExtensionError(uuid, e);
         }
 
         if (extension.stylesheet) {
             let theme = St.ThemeContext.get_for_stage(global.stage).get_theme();
             theme.unload_stylesheet(extension.stylesheet);
             delete extension.stylesheet;
         }
 
         for (let i = 0; i < order.length; i++) {
             let otherUuid = order[i];
             try {
                 this.lookup(otherUuid).stateObj.enable();
             } catch (e) {
                 this.logExtensionError(otherUuid, e);
             }
         }
 
         this._extensionOrder.splice(orderIdx, 1);
 
         if (extension.state != ExtensionState.ERROR) {
             extension.state = ExtensionState.DISABLED;
             this.emit('extension-state-changed', extension);
         }
     }
 
     _callExtensionEnable(uuid) {
-        if (!Main.sessionMode.allowExtensions)
+        if (!this._sessionModeCanUseExtension(uuid))
             return;
 
         let extension = this.lookup(uuid);
         if (!extension)
             return;
 
         if (extension.state == ExtensionState.INITIALIZED)
             this._callExtensionInit(uuid);
 
         if (extension.state != ExtensionState.DISABLED)
             return;
 
         let stylesheetNames = ['%s.css'.format(global.session_mode), 'stylesheet.css'];
         let theme = St.ThemeContext.get_for_stage(global.stage).get_theme();
         for (let i = 0; i < stylesheetNames.length; i++) {
             try {
                 let stylesheetFile = extension.dir.get_child(stylesheetNames[i]);
                 theme.load_stylesheet(stylesheetFile);
                 extension.stylesheet = stylesheetFile;
                 break;
             } catch (e) {
                 if (e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.NOT_FOUND))
                     continue; // not an error
                 this.logExtensionError(uuid, e);
                 return;
             }
         }
 
         try {
             extension.stateObj.enable();
@@ -288,60 +310,61 @@ var ExtensionManager = class {
         } catch (e) {
             throw new Error('Failed to load metadata.json: %s'.format(e.toString()));
         }
         let meta;
         try {
             meta = JSON.parse(metadataContents);
         } catch (e) {
             throw new Error('Failed to parse metadata.json: %s'.format(e.toString()));
         }
 
         let requiredProperties = ['uuid', 'name', 'description', 'shell-version'];
         for (let i = 0; i < requiredProperties.length; i++) {
             let prop = requiredProperties[i];
             if (!meta[prop])
                 throw new Error('missing "%s" property in metadata.json'.format(prop));
         }
 
         if (uuid != meta.uuid)
             throw new Error('uuid "%s" from metadata.json does not match directory name "%s"'.format(meta.uuid, uuid));
 
         let extension = {
             metadata: meta,
             uuid: meta.uuid,
             type,
             dir,
             path: dir.get_path(),
             error: '',
             hasPrefs: dir.get_child('prefs.js').query_exists(null),
             hasUpdate: false,
             canChange: false,
+            sessionModes: meta['session-modes'] ? meta['session-modes'] : [ 'user' ],
         };
         this._extensions.set(uuid, extension);
 
         return extension;
     }
 
     _canLoad(extension) {
         if (!this._unloadedExtensions.has(extension.uuid))
             return true;
 
         const version = this._unloadedExtensions.get(extension.uuid);
         return extension.metadata.version === version;
     }
 
     loadExtension(extension) {
         // Default to error, we set success as the last step
         extension.state = ExtensionState.ERROR;
 
         let checkVersion = !global.settings.get_boolean(EXTENSION_DISABLE_VERSION_CHECK_KEY);
 
         if (checkVersion && ExtensionUtils.isOutOfDate(extension)) {
             extension.state = ExtensionState.OUT_OF_DATE;
         } else if (!this._canLoad(extension)) {
             this.logExtensionError(extension.uuid, new Error(
                 'A different version was loaded previously. You need to log out for changes to take effect.'));
         } else {
             let enabled = this._enabledExtensions.includes(extension.uuid);
             if (enabled) {
                 if (!this._callExtensionInit(extension.uuid))
                     return;
@@ -372,61 +395,61 @@ var ExtensionManager = class {
         // If we did install an importer, it is now cached and it's
         // impossible to load a different version
         if (type === ExtensionType.PER_USER && extension.imports)
             this._unloadedExtensions.set(uuid, extension.metadata.version);
 
         this._extensions.delete(uuid);
         return true;
     }
 
     reloadExtension(oldExtension) {
         // Grab the things we'll need to pass to createExtensionObject
         // to reload it.
         let { uuid, dir, type } = oldExtension;
 
         // Then unload the old extension.
         this.unloadExtension(oldExtension);
 
         // Now, recreate the extension and load it.
         let newExtension;
         try {
             newExtension = this.createExtensionObject(uuid, dir, type);
         } catch (e) {
             this.logExtensionError(uuid, e);
             return;
         }
 
         this.loadExtension(newExtension);
     }
 
     _callExtensionInit(uuid) {
-        if (!Main.sessionMode.allowExtensions)
+        if (!this._sessionModeCanUseExtension(uuid))
             return false;
 
         let extension = this.lookup(uuid);
         if (!extension)
             throw new Error("Extension was not properly created. Call createExtensionObject first");
 
         let dir = extension.dir;
         let extensionJs = dir.get_child('extension.js');
         if (!extensionJs.query_exists(null)) {
             this.logExtensionError(uuid, new Error('Missing extension.js'));
             return false;
         }
 
         let extensionModule;
         let extensionState = null;
 
         ExtensionUtils.installImporter(extension);
         try {
             extensionModule = extension.imports.extension;
         } catch (e) {
             this.logExtensionError(uuid, e);
             return false;
         }
 
         if (extensionModule.init) {
             try {
                 extensionState = extensionModule.init(extension);
             } catch (e) {
                 this.logExtensionError(uuid, e);
                 return false;
@@ -461,67 +484,69 @@ var ExtensionManager = class {
             : ENABLED_EXTENSIONS_KEY;
 
         extension.canChange =
             !hasError &&
             global.settings.is_writable(changeKey) &&
             (isMode || !modeOnly);
     }
 
     _getEnabledExtensions() {
         let extensions = this._getModeExtensions();
 
         if (!global.settings.get_boolean(DISABLE_USER_EXTENSIONS_KEY))
             extensions = extensions.concat(global.settings.get_strv(ENABLED_EXTENSIONS_KEY));
 
         // filter out 'disabled-extensions' which takes precedence
         let disabledExtensions = global.settings.get_strv(DISABLED_EXTENSIONS_KEY);
         return extensions.filter(item => !disabledExtensions.includes(item));
     }
 
     _onUserExtensionsEnabledChanged() {
         this._onEnabledExtensionsChanged();
         this._onSettingsWritableChanged();
     }
 
     _onEnabledExtensionsChanged() {
         let newEnabledExtensions = this._getEnabledExtensions();
 
         // Find and enable all the newly enabled extensions: UUIDs found in the
         // new setting, but not in the old one.
         newEnabledExtensions
-            .filter(uuid => !this._enabledExtensions.includes(uuid))
+            .filter(uuid => !this._enabledExtensions.includes(uuid) &&
+                             this._extensionSupportsSessionMode(uuid))
             .forEach(uuid => this._callExtensionEnable(uuid));
 
         // Find and disable all the newly disabled extensions: UUIDs found in the
         // old setting, but not in the new one.
         this._extensionOrder
-            .filter(uuid => !newEnabledExtensions.includes(uuid))
+            .filter(uuid => !newEnabledExtensions.includes(uuid) ||
+                            !this._extensionSupportsSessionMode(uuid))
             .reverse().forEach(uuid => this._callExtensionDisable(uuid));
 
         this._enabledExtensions = newEnabledExtensions;
     }
 
     _onSettingsWritableChanged() {
         for (let extension of this._extensions.values()) {
             this._updateCanChange(extension);
             this.emit('extension-state-changed', extension);
         }
     }
 
     _onVersionValidationChanged() {
         // Disabling extensions modifies the order array, so use a copy
         let extensionOrder = this._extensionOrder.slice();
 
         // Disable enabled extensions in the reverse order first to avoid
         // the "rebasing" done in _callExtensionDisable...
         extensionOrder.slice().reverse().forEach(uuid => {
             this._callExtensionDisable(uuid);
         });
 
         // ...and then reload and enable extensions in the correct order again.
         [...this._extensions.values()].sort((a, b) => {
             return extensionOrder.indexOf(a.uuid) - extensionOrder.indexOf(b.uuid);
         }).forEach(extension => this.reloadExtension(extension));
     }
 
     _installExtensionUpdates() {
         if (!this.updatesSupported)
-- 
2.31.1


From 407c537a5cd14c9e9494d954f27eacfa1589aed5 Mon Sep 17 00:00:00 2001
From: Ray Strode <rstrode@redhat.com>
Date: Tue, 10 Aug 2021 15:31:00 -0400
Subject: [PATCH 3/3] sessionMode: Allow extensions at the login and unlock
 screens

Now extensions can specify which session modes they work in,
but specifying the login screen or unlock screen session modes in
an extensions metadata still won't work, because those session
modes disallow extensions.

This commit fixes that.
---
 js/ui/sessionMode.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/js/ui/sessionMode.js b/js/ui/sessionMode.js
index 4d4fb2444..0534fd1d4 100644
--- a/js/ui/sessionMode.js
+++ b/js/ui/sessionMode.js
@@ -16,76 +16,78 @@ const _modes = {
     'restrictive': {
         parentMode: null,
         stylesheetName: 'gnome-shell.css',
         themeResourceName: 'gnome-shell-theme.gresource',
         hasOverview: false,
         showCalendarEvents: false,
         showWelcomeDialog: false,
         allowSettings: false,
         allowExtensions: false,
         allowScreencast: false,
         enabledExtensions: [],
         hasRunDialog: false,
         hasWorkspaces: false,
         hasWindows: false,
         hasNotifications: false,
         hasWmMenus: false,
         isLocked: false,
         isGreeter: false,
         isPrimary: false,
         unlockDialog: null,
         components: [],
         panel: {
             left: [],
             center: [],
             right: [],
         },
         panelStyle: null,
     },
 
     'gdm': {
+        allowExtensions: true,
         hasNotifications: true,
         isGreeter: true,
         isPrimary: true,
         unlockDialog: imports.gdm.loginDialog.LoginDialog,
         components: Config.HAVE_NETWORKMANAGER
             ? ['networkAgent', 'polkitAgent']
             : ['polkitAgent'],
         panel: {
             left: [],
             center: ['dateMenu'],
             right: ['dwellClick', 'a11y', 'keyboard', 'aggregateMenu'],
         },
         panelStyle: 'login-screen',
     },
 
     'unlock-dialog': {
+        allowExtensions: true,
         isLocked: true,
         unlockDialog: undefined,
         components: ['polkitAgent', 'telepathyClient'],
         panel: {
             left: [],
             center: [],
             right: ['dwellClick', 'a11y', 'keyboard', 'aggregateMenu'],
         },
         panelStyle: 'unlock-screen',
     },
 
     'user': {
         hasOverview: true,
         showCalendarEvents: true,
         showWelcomeDialog: true,
         allowSettings: true,
         allowExtensions: true,
         allowScreencast: true,
         hasRunDialog: true,
         hasWorkspaces: true,
         hasWindows: true,
         hasWmMenus: true,
         hasNotifications: true,
         isLocked: false,
         isPrimary: true,
         unlockDialog: imports.ui.unlockDialog.UnlockDialog,
         components: Config.HAVE_NETWORKMANAGER
             ? ['networkAgent', 'polkitAgent', 'telepathyClient',
                'keyring', 'autorunManager', 'automountManager']
             : ['polkitAgent', 'telepathyClient',
-- 
2.31.1