Adding upstream version 3.38.6.upstream/3.38.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 810 insertions, 0 deletions

diff --git a/js/ui/endSessionDialog.js b/js/ui/endSessionDialog.js
new file mode 100644
index 0000000..ebf4f4d
--- /dev/null
+++ b/js/ui/endSessionDialog.js
@@ -0,0 +1,810 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported init, EndSessionDialog */
+/*
+ * Copyright 2010-2016 Red Hat, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+const { AccountsService, Clutter, Gio,
+        GLib, GObject, Pango, Polkit, Shell, St, UPowerGlib: UPower }  = imports.gi;
+
+const CheckBox = imports.ui.checkBox;
+const Dialog = imports.ui.dialog;
+const GnomeSession = imports.misc.gnomeSession;
+const LoginManager = imports.misc.loginManager;
+const ModalDialog = imports.ui.modalDialog;
+const UserWidget = imports.ui.userWidget;
+
+const { loadInterfaceXML } = imports.misc.fileUtils;
+
+const _ITEM_ICON_SIZE = 64;
+
+const LOW_BATTERY_THRESHOLD = 30;
+
+const EndSessionDialogIface = loadInterfaceXML('org.gnome.SessionManager.EndSessionDialog');
+
+const logoutDialogContent = {
+    subjectWithUser: C_("title", "Log Out %s"),
+    subject: C_("title", "Log Out"),
+    descriptionWithUser(user, seconds) {
+        return ngettext(
+            '%s will be logged out automatically in %d second.',
+            '%s will be logged out automatically in %d seconds.',
+            seconds).format(user, seconds);
+    },
+    description(seconds) {
+        return ngettext(
+            'You will be logged out automatically in %d second.',
+            'You will be logged out automatically in %d seconds.',
+            seconds).format(seconds);
+    },
+    showBatteryWarning: false,
+    confirmButtons: [{
+        signal: 'ConfirmedLogout',
+        label: C_('button', 'Log Out'),
+    }],
+    showOtherSessions: false,
+};
+
+const shutdownDialogContent = {
+    subject: C_("title", "Power Off"),
+    subjectWithUpdates: C_("title", "Install Updates & Power Off"),
+    description(seconds) {
+        return ngettext(
+            'The system will power off automatically in %d second.',
+            'The system will power off automatically in %d seconds.',
+            seconds).format(seconds);
+    },
+    checkBoxText: C_("checkbox", "Install pending software updates"),
+    showBatteryWarning: true,
+    confirmButtons: [{
+        signal: 'ConfirmedShutdown',
+        label: C_('button', 'Power Off'),
+    }],
+    iconName: 'system-shutdown-symbolic',
+    showOtherSessions: true,
+};
+
+const restartDialogContent = {
+    subject: C_("title", "Restart"),
+    subjectWithUpdates: C_('title', 'Install Updates & Restart'),
+    description(seconds) {
+        return ngettext(
+            'The system will restart automatically in %d second.',
+            'The system will restart automatically in %d seconds.',
+            seconds).format(seconds);
+    },
+    checkBoxText: C_('checkbox', 'Install pending software updates'),
+    showBatteryWarning: true,
+    confirmButtons: [{
+        signal: 'ConfirmedReboot',
+        label: C_('button', 'Restart'),
+    }],
+    iconName: 'view-refresh-symbolic',
+    showOtherSessions: true,
+};
+
+const restartUpdateDialogContent = {
+
+    subject: C_("title", "Restart & Install Updates"),
+    description(seconds) {
+        return ngettext(
+            'The system will automatically restart and install updates in %d second.',
+            'The system will automatically restart and install updates in %d seconds.',
+            seconds).format(seconds);
+    },
+    showBatteryWarning: true,
+    confirmButtons: [{
+        signal: 'ConfirmedReboot',
+        label: C_('button', 'Restart &amp; Install'),
+    }],
+    unusedFutureButtonForTranslation: C_("button", "Install &amp; Power Off"),
+    unusedFutureCheckBoxForTranslation: C_("checkbox", "Power off after updates are installed"),
+    iconName: 'view-refresh-symbolic',
+    showOtherSessions: true,
+};
+
+const restartUpgradeDialogContent = {
+
+    subject: C_("title", "Restart & Install Upgrade"),
+    upgradeDescription(distroName, distroVersion) {
+        /* Translators: This is the text displayed for system upgrades in the
+           shut down dialog. First %s gets replaced with the distro name and
+           second %s with the distro version to upgrade to */
+        return _("%s %s will be installed after restart. Upgrade installation can take a long time: ensure that you have backed up and that the computer is plugged in.").format(distroName, distroVersion);
+    },
+    disableTimer: true,
+    showBatteryWarning: false,
+    confirmButtons: [{
+        signal: 'ConfirmedReboot',
+        label: C_('button', 'Restart &amp; Install'),
+    }],
+    iconName: 'view-refresh-symbolic',
+    showOtherSessions: true,
+};
+
+const DialogType = {
+    LOGOUT: 0 /* GSM_SHELL_END_SESSION_DIALOG_TYPE_LOGOUT */,
+    SHUTDOWN: 1 /* GSM_SHELL_END_SESSION_DIALOG_TYPE_SHUTDOWN */,
+    RESTART: 2 /* GSM_SHELL_END_SESSION_DIALOG_TYPE_RESTART */,
+    UPDATE_RESTART: 3,
+    UPGRADE_RESTART: 4,
+};
+
+const DialogContent = {
+    0 /* DialogType.LOGOUT */: logoutDialogContent,
+    1 /* DialogType.SHUTDOWN */: shutdownDialogContent,
+    2 /* DialogType.RESTART */: restartDialogContent,
+    3 /* DialogType.UPDATE_RESTART */: restartUpdateDialogContent,
+    4 /* DialogType.UPGRADE_RESTART */: restartUpgradeDialogContent,
+};
+
+var MAX_USERS_IN_SESSION_DIALOG = 5;
+
+const LogindSessionIface = loadInterfaceXML('org.freedesktop.login1.Session');
+const LogindSession = Gio.DBusProxy.makeProxyWrapper(LogindSessionIface);
+
+const PkOfflineIface = loadInterfaceXML('org.freedesktop.PackageKit.Offline');
+const PkOfflineProxy = Gio.DBusProxy.makeProxyWrapper(PkOfflineIface);
+
+const UPowerIface = loadInterfaceXML('org.freedesktop.UPower.Device');
+const UPowerProxy = Gio.DBusProxy.makeProxyWrapper(UPowerIface);
+
+function findAppFromInhibitor(inhibitor) {
+    let desktopFile;
+    try {
+        [desktopFile] = inhibitor.GetAppIdSync();
+    } catch (e) {
+        // XXX -- sometimes JIT inhibitors generated by gnome-session
+        // get removed too soon. Don't fail in this case.
+        log('gnome-session gave us a dead inhibitor: %s'.format(inhibitor.get_object_path()));
+        return null;
+    }
+
+    if (!GLib.str_has_suffix(desktopFile, '.desktop'))
+        desktopFile += '.desktop';
+
+    return Shell.AppSystem.get_default().lookup_heuristic_basename(desktopFile);
+}
+
+// The logout timer only shows updates every 10 seconds
+// until the last 10 seconds, then it shows updates every
+// second.  This function takes a given time and returns
+// what we should show to the user for that time.
+function _roundSecondsToInterval(totalSeconds, secondsLeft, interval) {
+    let time;
+
+    time = Math.ceil(secondsLeft);
+
+    // Final count down is in decrements of 1
+    if (time <= interval)
+        return time;
+
+    // Round up higher than last displayable time interval
+    time += interval - 1;
+
+    // Then round down to that time interval
+    if (time > totalSeconds)
+        time = Math.ceil(totalSeconds);
+    else
+        time -= time % interval;
+
+    return time;
+}
+
+function _setCheckBoxLabel(checkBox, text) {
+    let label = checkBox.getLabelActor();
+
+    if (text) {
+        label.set_text(text);
+        checkBox.show();
+    } else {
+        label.set_text('');
+        checkBox.hide();
+    }
+}
+
+function init() {
+    // This always returns the same singleton object
+    // By instantiating it initially, we register the
+    // bus object, etc.
+    new EndSessionDialog();
+}
+
+var EndSessionDialog = GObject.registerClass(
+class EndSessionDialog extends ModalDialog.ModalDialog {
+    _init() {
+        super._init({ styleClass: 'end-session-dialog',
+                      destroyOnClose: false });
+
+        this._loginManager = LoginManager.getLoginManager();
+        this._loginManager.canRebootToBootLoaderMenu(
+            (canRebootToBootLoaderMenu, unusedNeedsAuth) => {
+                this._canRebootToBootLoaderMenu = canRebootToBootLoaderMenu;
+            });
+
+        this._userManager = AccountsService.UserManager.get_default();
+        this._user = this._userManager.get_user(GLib.get_user_name());
+        this._updatesPermission = null;
+
+        this._pkOfflineProxy = new PkOfflineProxy(Gio.DBus.system,
+                                                  'org.freedesktop.PackageKit',
+                                                  '/org/freedesktop/PackageKit',
+                                                  this._onPkOfflineProxyCreated.bind(this));
+
+        this._powerProxy = new UPowerProxy(Gio.DBus.system,
+                                           'org.freedesktop.UPower',
+                                           '/org/freedesktop/UPower/devices/DisplayDevice',
+                                           (proxy, error) => {
+                                               if (error) {
+                                                   log(error.message);
+                                                   return;
+                                               }
+                                               this._powerProxy.connect('g-properties-changed',
+                                                                        this._sync.bind(this));
+                                               this._sync();
+                                           });
+
+        this._secondsLeft = 0;
+        this._totalSecondsToStayOpen = 0;
+        this._applications = [];
+        this._sessions = [];
+        this._capturedEventId = 0;
+        this._rebootButton = null;
+        this._rebootButtonAlt = null;
+
+        this.connect('destroy',
+                     this._onDestroy.bind(this));
+        this.connect('opened',
+                     this._onOpened.bind(this));
+
+        this._userLoadedId = this._user.connect('notify::is-loaded', this._sync.bind(this));
+        this._userChangedId = this._user.connect('changed', this._sync.bind(this));
+
+        this._messageDialogContent = new Dialog.MessageDialogContent();
+
+        this._checkBox = new CheckBox.CheckBox();
+        this._checkBox.connect('clicked', this._sync.bind(this));
+        this._messageDialogContent.add_child(this._checkBox);
+
+        this._batteryWarning = new St.Label({
+            style_class: 'end-session-dialog-battery-warning',
+            text: _('Low battery power: please plug in before installing updates.'),
+        });
+        this._batteryWarning.clutter_text.ellipsize = Pango.EllipsizeMode.NONE;
+        this._batteryWarning.clutter_text.line_wrap = true;
+        this._messageDialogContent.add_child(this._batteryWarning);
+
+        this.contentLayout.add_child(this._messageDialogContent);
+
+        this._applicationSection = new Dialog.ListSection({
+            title: _('Some applications are busy or have unsaved work'),
+        });
+        this.contentLayout.add_child(this._applicationSection);
+
+        this._sessionSection = new Dialog.ListSection({
+            title: _('Other users are logged in'),
+        });
+        this.contentLayout.add_child(this._sessionSection);
+
+        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(EndSessionDialogIface, this);
+        this._dbusImpl.export(Gio.DBus.session, '/org/gnome/SessionManager/EndSessionDialog');
+    }
+
+    async _onPkOfflineProxyCreated(proxy, error) {
+        if (error) {
+            log(error.message);
+            return;
+        }
+
+        // Creating a D-Bus proxy won't propagate SERVICE_UNKNOWN or NAME_HAS_NO_OWNER
+        // errors if PackageKit is not available, but the GIO implementation will make
+        // sure in that case that the proxy's g-name-owner is set to null, so check that.
+        if (this._pkOfflineProxy.g_name_owner === null) {
+            this._pkOfflineProxy = null;
+            return;
+        }
+
+        // It only makes sense to check for this permission if PackageKit is available.
+        try {
+            this._updatesPermission = await Polkit.Permission.new(
+                'org.freedesktop.packagekit.trigger-offline-update', null, null);
+        } catch (e) {
+            log('No permission to trigger offline updates: %s'.format(e.toString()));
+        }
+    }
+
+    _onDestroy() {
+        this._user.disconnect(this._userLoadedId);
+        this._user.disconnect(this._userChangedId);
+    }
+
+    _isDischargingBattery() {
+        return this._powerProxy.IsPresent &&
+            this._powerProxy.State !== UPower.DeviceState.CHARGING &&
+            this._powerProxy.State !== UPower.DeviceState.FULLY_CHARGED;
+    }
+
+    _isBatteryLow() {
+        return this._isDischargingBattery() && this._powerProxy.Percentage < LOW_BATTERY_THRESHOLD;
+    }
+
+    _shouldShowLowBatteryWarning(dialogContent) {
+        if (!dialogContent.showBatteryWarning)
+            return false;
+
+        if (!this._isBatteryLow())
+            return false;
+
+        if (this._checkBox.checked)
+            return true;
+
+        // Show the warning if updates have already been triggered, but
+        // the user doesn't have enough permissions to cancel them.
+        let updatesAllowed = this._updatesPermission && this._updatesPermission.allowed;
+        return this._updateInfo.UpdatePrepared && this._updateInfo.UpdateTriggered && !updatesAllowed;
+    }
+
+    _sync() {
+        let open = this.state == ModalDialog.State.OPENING || this.state == ModalDialog.State.OPENED;
+        if (!open)
+            return;
+
+        let dialogContent = DialogContent[this._type];
+
+        let subject = dialogContent.subject;
+
+        // Use different title when we are installing updates
+        if (dialogContent.subjectWithUpdates && this._checkBox.checked)
+            subject = dialogContent.subjectWithUpdates;
+
+        this._batteryWarning.visible = this._shouldShowLowBatteryWarning(dialogContent);
+
+        let description;
+        let displayTime = _roundSecondsToInterval(this._totalSecondsToStayOpen,
+                                                  this._secondsLeft,
+                                                  10);
+
+        if (this._user.is_loaded) {
+            let realName = this._user.get_real_name();
+
+            if (realName != null) {
+                if (dialogContent.subjectWithUser)
+                    subject = dialogContent.subjectWithUser.format(realName);
+
+                if (dialogContent.descriptionWithUser)
+                    description = dialogContent.descriptionWithUser(realName, displayTime);
+            }
+        }
+
+        // Use a different description when we are installing a system upgrade
+        // if the PackageKit proxy is available (i.e. PackageKit is available).
+        if (dialogContent.upgradeDescription) {
+            const { name, version } = this._updateInfo.PreparedUpgrade;
+            if (name != null && version != null)
+                description = dialogContent.upgradeDescription(name, version);
+        }
+
+        // Fall back to regular description
+        if (!description)
+            description = dialogContent.description(displayTime);
+
+        this._messageDialogContent.title = subject;
+        this._messageDialogContent.description = description;
+
+        let hasApplications = this._applications.length > 0;
+        let hasSessions = this._sessions.length > 0;
+
+        this._applicationSection.visible = hasApplications;
+        this._sessionSection.visible = hasSessions;
+    }
+
+    _onCapturedEvent(actor, event) {
+        let altEnabled = false;
+
+        let type = event.type();
+        if (type !== Clutter.EventType.KEY_PRESS && type !== Clutter.EventType.KEY_RELEASE)
+            return Clutter.EVENT_PROPAGATE;
+
+        let key = event.get_key_symbol();
+        if (key !== Clutter.KEY_Alt_L && key !== Clutter.KEY_Alt_R)
+            return Clutter.EVENT_PROPAGATE;
+
+        if (type === Clutter.EventType.KEY_PRESS)
+            altEnabled = true;
+
+        this._rebootButton.visible = !altEnabled;
+        this._rebootButtonAlt.visible = altEnabled;
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    _updateButtons() {
+        this.clearButtons();
+
+        this.addButton({ action: this.cancel.bind(this),
+                         label: _("Cancel"),
+                         key: Clutter.KEY_Escape });
+
+        let dialogContent = DialogContent[this._type];
+        for (let i = 0; i < dialogContent.confirmButtons.length; i++) {
+            let signal = dialogContent.confirmButtons[i].signal;
+            let label = dialogContent.confirmButtons[i].label;
+            let button = this.addButton({
+                action: () => {
+                    this.close(true);
+                    let signalId = this.connect('closed', () => {
+                        this.disconnect(signalId);
+                        this._confirm(signal);
+                    });
+                },
+                label,
+            });
+
+            // Add Alt "Boot Options" option to the Reboot button
+            if (this._canRebootToBootLoaderMenu && signal === 'ConfirmedReboot') {
+                this._rebootButton = button;
+                this._rebootButtonAlt = this.addButton({
+                    action: () => {
+                        this.close(true);
+                        let signalId = this.connect('closed', () => {
+                            this.disconnect(signalId);
+                            this._confirmRebootToBootLoaderMenu();
+                        });
+                    },
+                    label: C_('button', 'Boot Options'),
+                });
+                this._rebootButtonAlt.visible = false;
+                this._capturedEventId = global.stage.connect('captured-event',
+                    this._onCapturedEvent.bind(this));
+            }
+        }
+    }
+
+    _stopAltCapture() {
+        if (this._capturedEventId > 0) {
+            global.stage.disconnect(this._capturedEventId);
+            this._capturedEventId = 0;
+        }
+        this._rebootButton = null;
+        this._rebootButtonAlt = null;
+    }
+
+    close(skipSignal) {
+        super.close();
+
+        if (!skipSignal)
+            this._dbusImpl.emit_signal('Closed', null);
+    }
+
+    cancel() {
+        this._stopTimer();
+        this._stopAltCapture();
+        this._dbusImpl.emit_signal('Canceled', null);
+        this.close();
+    }
+
+    _confirmRebootToBootLoaderMenu() {
+        this._loginManager.setRebootToBootLoaderMenu();
+        this._confirm('ConfirmedReboot');
+    }
+
+    _confirm(signal) {
+        let callback = () => {
+            this._fadeOutDialog();
+            this._stopTimer();
+            this._stopAltCapture();
+            this._dbusImpl.emit_signal(signal, null);
+        };
+
+        // Offline update not available; just emit the signal
+        if (!this._checkBox.visible) {
+            callback();
+            return;
+        }
+
+        // Trigger the offline update as requested
+        if (this._checkBox.checked) {
+            switch (signal) {
+            case "ConfirmedReboot":
+                this._triggerOfflineUpdateReboot(callback);
+                break;
+            case "ConfirmedShutdown":
+                // To actually trigger the offline update, we need to
+                // reboot to do the upgrade. When the upgrade is complete,
+                // the computer will shut down automatically.
+                signal = "ConfirmedReboot";
+                this._triggerOfflineUpdateShutdown(callback);
+                break;
+            default:
+                callback();
+                break;
+            }
+        } else {
+            this._triggerOfflineUpdateCancel(callback);
+        }
+    }
+
+    _onOpened() {
+        this._sync();
+    }
+
+    _triggerOfflineUpdateReboot(callback) {
+        // Handle this gracefully if PackageKit is not available.
+        if (!this._pkOfflineProxy) {
+            callback();
+            return;
+        }
+
+        this._pkOfflineProxy.TriggerRemote('reboot', (result, error) => {
+            if (error)
+                log(error.message);
+
+            callback();
+        });
+    }
+
+    _triggerOfflineUpdateShutdown(callback) {
+        // Handle this gracefully if PackageKit is not available.
+        if (!this._pkOfflineProxy) {
+            callback();
+            return;
+        }
+
+        this._pkOfflineProxy.TriggerRemote('power-off', (result, error) => {
+            if (error)
+                log(error.message);
+
+            callback();
+        });
+    }
+
+    _triggerOfflineUpdateCancel(callback) {
+        // Handle this gracefully if PackageKit is not available.
+        if (!this._pkOfflineProxy) {
+            callback();
+            return;
+        }
+
+        this._pkOfflineProxy.CancelRemote((result, error) => {
+            if (error)
+                log(error.message);
+
+            callback();
+        });
+    }
+
+    _startTimer() {
+        let startTime = GLib.get_monotonic_time();
+        this._secondsLeft = this._totalSecondsToStayOpen;
+
+        this._timerId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 1, () => {
+            let currentTime = GLib.get_monotonic_time();
+            let secondsElapsed = (currentTime - startTime) / 1000000;
+
+            this._secondsLeft = this._totalSecondsToStayOpen - secondsElapsed;
+            if (this._secondsLeft > 0) {
+                this._sync();
+                return GLib.SOURCE_CONTINUE;
+            }
+
+            let dialogContent = DialogContent[this._type];
+            let button = dialogContent.confirmButtons[dialogContent.confirmButtons.length - 1];
+            this._confirm(button.signal);
+            this._timerId = 0;
+
+            return GLib.SOURCE_REMOVE;
+        });
+        GLib.Source.set_name_by_id(this._timerId, '[gnome-shell] this._confirm');
+    }
+
+    _stopTimer() {
+        if (this._timerId > 0) {
+            GLib.source_remove(this._timerId);
+            this._timerId = 0;
+        }
+
+        this._secondsLeft = 0;
+    }
+
+    _onInhibitorLoaded(inhibitor) {
+        if (!this._applications.includes(inhibitor)) {
+            // Stale inhibitor
+            return;
+        }
+
+        let app = findAppFromInhibitor(inhibitor);
+
+        if (app) {
+            let [description] = inhibitor.GetReasonSync();
+            let listItem = new Dialog.ListSectionItem({
+                icon_actor: app.create_icon_texture(_ITEM_ICON_SIZE),
+                title: app.get_name(),
+                description,
+            });
+            this._applicationSection.list.add_child(listItem);
+        } else {
+            // inhibiting app is a service, not an application
+            this._applications.splice(this._applications.indexOf(inhibitor), 1);
+        }
+
+        this._sync();
+    }
+
+    _loadSessions() {
+        this._loginManager.listSessions(result => {
+            let n = 0;
+            for (let i = 0; i < result.length; i++) {
+                let [id_, uid_, userName, seat_, sessionPath] = result[i];
+                let proxy = new LogindSession(Gio.DBus.system, 'org.freedesktop.login1', sessionPath);
+
+                if (proxy.Class != 'user')
+                    continue;
+
+                if (proxy.State == 'closing')
+                    continue;
+
+                let sessionId = GLib.getenv('XDG_SESSION_ID');
+                if (!sessionId) {
+                    this._loginManager.getCurrentSessionProxy(currentSessionProxy => {
+                        sessionId = currentSessionProxy.Id;
+                        log('endSessionDialog: No XDG_SESSION_ID, fetched from logind: %d'.format(sessionId));
+                    });
+                }
+
+                if (proxy.Id == sessionId)
+                    continue;
+
+                let session = { user: this._userManager.get_user(userName),
+                                username: userName,
+                                type: proxy.Type,
+                                remote: proxy.Remote };
+                this._sessions.push(session);
+
+                let userAvatar = new UserWidget.Avatar(session.user, { iconSize: _ITEM_ICON_SIZE });
+                userAvatar.update();
+
+                userName = session.user.get_real_name()
+                    ? session.user.get_real_name() : session.username;
+
+                let userLabelText;
+                if (session.remote)
+                    /* Translators: Remote here refers to a remote session, like a ssh login */
+                    userLabelText = _('%s (remote)').format(userName);
+                else if (session.type === 'tty')
+                    /* Translators: Console here refers to a tty like a VT console */
+                    userLabelText = _('%s (console)').format(userName);
+                else
+                    userLabelText = userName;
+
+                let listItem = new Dialog.ListSectionItem({
+                    icon_actor: userAvatar,
+                    title: userLabelText,
+                });
+                this._sessionSection.list.add_child(listItem);
+
+                // limit the number of entries
+                n++;
+                if (n == MAX_USERS_IN_SESSION_DIALOG)
+                    break;
+            }
+
+            this._sync();
+        });
+    }
+
+    async _getUpdateInfo() {
+        const connection = this._pkOfflineProxy.get_connection();
+        const reply = await connection.call(
+            this._pkOfflineProxy.g_name,
+            this._pkOfflineProxy.g_object_path,
+            'org.freedesktop.DBus.Properties',
+            'GetAll',
+            new GLib.Variant('(s)', [this._pkOfflineProxy.g_interface_name]),
+            null,
+            Gio.DBusCallFlags.NONE,
+            -1,
+            null);
+        const [info] = reply.recursiveUnpack();
+        return info;
+    }
+
+    async OpenAsync(parameters, invocation) {
+        let [type, timestamp, totalSecondsToStayOpen, inhibitorObjectPaths] = parameters;
+        this._totalSecondsToStayOpen = totalSecondsToStayOpen;
+        this._type = type;
+
+        try {
+            this._updateInfo = await this._getUpdateInfo();
+        } catch (e) {
+            if (this._pkOfflineProxy !== null)
+                log('Failed to get update info from PackageKit: %s'.format(e.message));
+
+            this._updateInfo = {
+                UpdateTriggered: false,
+                UpdatePrepared: false,
+                UpgradeTriggered: false,
+                PreparedUpgrade: {},
+            };
+        }
+
+        // Only consider updates and upgrades if PackageKit is available.
+        if (this._pkOfflineProxy && this._type == DialogType.RESTART) {
+            if (this._updateInfo.UpdateTriggered)
+                this._type = DialogType.UPDATE_RESTART;
+            else if (this._updateInfo.UpgradeTriggered)
+                this._type = DialogType.UPGRADE_RESTART;
+        }
+
+        this._applications = [];
+        this._applicationSection.list.destroy_all_children();
+
+        this._sessions = [];
+        this._sessionSection.list.destroy_all_children();
+
+        if (!(this._type in DialogContent)) {
+            invocation.return_dbus_error('org.gnome.Shell.ModalDialog.TypeError',
+                                         "Unknown dialog type requested");
+            return;
+        }
+
+        let dialogContent = DialogContent[this._type];
+
+        for (let i = 0; i < inhibitorObjectPaths.length; i++) {
+            let inhibitor = new GnomeSession.Inhibitor(inhibitorObjectPaths[i], proxy => {
+                this._onInhibitorLoaded(proxy);
+            });
+
+            this._applications.push(inhibitor);
+        }
+
+        if (dialogContent.showOtherSessions)
+            this._loadSessions();
+
+        let updatesAllowed = this._updatesPermission && this._updatesPermission.allowed;
+
+        _setCheckBoxLabel(this._checkBox, dialogContent.checkBoxText || '');
+        this._checkBox.visible = dialogContent.checkBoxText && this._updateInfo.UpdatePrepared && updatesAllowed;
+
+        if (this._type === DialogType.UPGRADE_RESTART)
+            this._checkBox.checked = this._checkBox.visible && this._updateInfo.UpdateTriggered && !this._isDischargingBattery();
+        else
+            this._checkBox.checked = this._checkBox.visible && !this._isBatteryLow();
+
+        this._batteryWarning.visible = this._shouldShowLowBatteryWarning(dialogContent);
+
+        this._updateButtons();
+
+        if (!this.open(timestamp)) {
+            invocation.return_dbus_error('org.gnome.Shell.ModalDialog.GrabError',
+                                         "Cannot grab pointer and keyboard");
+            return;
+        }
+
+        if (!dialogContent.disableTimer)
+            this._startTimer();
+
+        this._sync();
+
+        let signalId = this.connect('opened', () => {
+            invocation.return_value(null);
+            this.disconnect(signalId);
+        });
+    }
+
+    Close(_parameters, _invocation) {
+        this.close();
+    }
+});