@theia/core 1.21.0-next.17 → 1.21.0-next.21

package/src/browser/window/default-window-service.ts

@@ -18,14 +18,16 @@ import { inject, injectable, named } from 'inversify';
 import { Event, Emitter } from '../../common';
 import { CorePreferences } from '../core-preferences';
 import { ContributionProvider } from '../../common/contribution-provider';
-import { FrontendApplicationContribution, FrontendApplication } from '../frontend-application';
+import { FrontendApplicationContribution, FrontendApplication, OnWillStopAction } from '../frontend-application';
 import { WindowService } from './window-service';
 import { DEFAULT_WINDOW_HASH } from '../../common/window';
+import { confirmExit } from '../dialogs';
 
 @injectable()
 export class DefaultWindowService implements WindowService, FrontendApplicationContribution {
 
     protected frontendApplication: FrontendApplication;
+    protected allowVetoes = true;
 
     protected onUnloadEmitter = new Emitter<void>();
     get onUnload(): Event<void> {
@@ -53,26 +55,40 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         this.openNewWindow(`#${DEFAULT_WINDOW_HASH}`);
     }
 
-    canUnload(): boolean {
-        const confirmExit = this.corePreferences['application.confirmExit'];
-        let preventUnload = confirmExit === 'always';
-        for (const contribution of this.contributions.getContributions()) {
-            if (contribution.onWillStop?.(this.frontendApplication)) {
-                preventUnload = true;
+    /**
+     * Returns a list of actions that {@link FrontendApplicationContribution}s would like to take before shutdown
+     * It is expected that this will succeed - i.e. return an empty array - at most once per session. If no vetoes are received
+     * during any cycle, no further checks will be made. In that case, shutdown should proceed unconditionally.
+     */
+    protected collectContributionUnloadVetoes(): OnWillStopAction[] {
+        const vetoes = [];
+        if (this.allowVetoes) {
+            const shouldConfirmExit = this.corePreferences['application.confirmExit'];
+            for (const contribution of this.contributions.getContributions()) {
+                const veto = contribution.onWillStop?.(this.frontendApplication);
+                if (veto && shouldConfirmExit !== 'never') { // Ignore vetoes if we should not prompt the user on exit.
+                    if (OnWillStopAction.is(veto)) {
+                        vetoes.push(veto);
+                    } else {
+                        vetoes.push({ reason: 'No reason given', action: () => false });
+                    }
+                }
+            }
+            if (vetoes.length === 0 && shouldConfirmExit === 'always') {
+                vetoes.push({ reason: 'application.confirmExit preference', action: () => confirmExit() });
+            }
+            if (vetoes.length === 0) {
+                this.allowVetoes = false;
             }
         }
-        return confirmExit === 'never' || !preventUnload;
+        return vetoes;
     }
 
     /**
      * Implement the mechanism to detect unloading of the page.
      */
     protected registerUnloadListeners(): void {
-        window.addEventListener('beforeunload', event => {
-            if (!this.canUnload()) {
-                return this.preventUnload(event);
-            }
-        });
+        window.addEventListener('beforeunload', event => this.handleBeforeUnloadEvent(event));
         // In a browser, `unload` is correctly fired when the page unloads, unlike Electron.
         // If `beforeunload` is cancelled, the user will be prompted to leave or stay.
         // If the user stays, the page won't be unloaded, so `unload` is not fired.
@@ -80,6 +96,43 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         window.addEventListener('unload', () => this.onUnloadEmitter.fire());
     }
 
+    async isSafeToShutDown(): Promise<boolean> {
+        const vetoes = this.collectContributionUnloadVetoes();
+        if (vetoes.length === 0) {
+            return true;
+        }
+        console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+        const resolvedVetoes = await Promise.allSettled(vetoes.map(({ action }) => action()));
+        if (resolvedVetoes.every(resolution => resolution.status === 'rejected' || resolution.value === true)) {
+            console.debug('OnWillStop actions resolved; allowing shutdown');
+            this.allowVetoes = false;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    setSafeToShutDown(): void {
+        this.allowVetoes = false;
+    }
+
+    /**
+     * Called when the `window` is about to `unload` its resources.
+     * At this point, the `document` is still visible and the [`BeforeUnloadEvent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event)
+     * event will be canceled if the return value of this method is `false`.
+     *
+     * In Electron, handleCloseRequestEvent is is run instead.
+     */
+    protected handleBeforeUnloadEvent(event: BeforeUnloadEvent): string | void {
+        const vetoes = this.collectContributionUnloadVetoes();
+        if (vetoes.length) {
+            // In the browser, we don't call the functions because this has to finish in a single tick, so we treat any desired action as a veto.
+            console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+            return this.preventUnload(event);
+        }
+        console.debug('Shutdown will proceed.');
+    }
+
     /**
      * Notify the browser that we do not want to unload.
      *
@@ -95,4 +148,7 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         return '';
     }
 
+    reload(): void {
+        window.location.reload();
+    }
 }

package/src/browser/window/test/mock-window-service.ts

@@ -21,6 +21,8 @@ import { WindowService } from '../window-service';
 export class MockWindowService implements WindowService {
     openNewWindow(): undefined { return undefined; }
     openNewDefaultWindow(): void { }
-    canUnload(): boolean { return true; }
+    reload(): void { }
+    isSafeToShutDown(): Promise<boolean> { return Promise.resolve(true); }
+    setSafeToShutDown(): void { }
     get onUnload(): Event<void> { return Event.None; }
 }

package/src/browser/window/window-service.ts

@@ -23,7 +23,6 @@ import { NewWindowOptions } from '../../common/window';
 export const WindowService = Symbol('WindowService');
 
 export interface WindowService {
-
     /**
      * Opens a new window and loads the content from the given URL.
      * In a browser, opening a new Theia tab or open a link is the same thing.
@@ -37,17 +36,32 @@ export interface WindowService {
      */
     openNewDefaultWindow(): void;
 
-    /**
-     * Called when the `window` is about to `unload` its resources.
-     * At this point, the `document` is still visible and the [`BeforeUnloadEvent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event)
-     * event will be canceled if the return value of this method is `false`.
-     */
-    canUnload(): boolean;
-
     /**
      * Fires when the `window` unloads. The unload event is inevitable. On this event, the frontend application can save its state and release resource.
      * Saving the state and releasing any resources must be a synchronous call. Any asynchronous calls invoked after emitting this event might be ignored.
      */
     readonly onUnload: Event<void>;
 
+    /**
+     * Checks `FrontendApplicationContribution#willStop` for impediments to shutdown and runs any actions returned.
+     * Can be used safely in browser and Electron when triggering reload or shutdown programmatically.
+     * Should _only_ be called before a shutdown - if this returns `true`, `FrontendApplicationContribution#willStop`
+     * will not be called again in the current session. I.e. if this return `true`, the shutdown should proceed without
+     * further condition.
+     */
+    isSafeToShutDown(): Promise<boolean>;
+
+    /**
+     * Will prevent subsequent checks of `FrontendApplicationContribution#willStop`. Should only be used after requesting
+     * user confirmation.
+     *
+     * This is primarily intended programmatic restarts due to e.g. change of display language. It allows for a single confirmation
+     * of intent, rather than one warning and then several warnings from other contributions.
+     */
+    setSafeToShutDown(): void;
+
+    /**
+     * Reloads the window according to platform.
+     */
+    reload(): void;
 }

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -22,7 +22,7 @@ import {
 } from '../../common';
 import {
     ApplicationShell, codicon, ConfirmDialog, KeybindingContribution, KeybindingRegistry,
-    PreferenceScope, Widget, FrontendApplication, FrontendApplicationContribution, CommonMenus, CommonCommands, Dialog
+    PreferenceScope, Widget, FrontendApplication, FrontendApplicationContribution, CommonMenus, CommonCommands, Dialog,
 } from '../../browser';
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { FrontendApplicationStateService, FrontendApplicationState } from '../../browser/frontend-application-state';
@@ -30,6 +30,7 @@ import { FrontendApplicationConfigProvider } from '../../browser/frontend-applic
 import { RequestTitleBarStyle, Restart, TitleBarStyleAtStartup, TitleBarStyleChanged } from '../../electron-common/messaging/electron-messages';
 import { ZoomLevel } from '../window/electron-window-preferences';
 import { BrowserMenuBarContribution } from '../../browser/menu/browser-menu-plugin';
+import { WindowService } from '../../browser/window/window-service';
 
 import '../../../src/electron-browser/menu/electron-menu-style.css';
 
@@ -84,6 +85,9 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
     @inject(FrontendApplicationStateService)
     protected readonly stateService: FrontendApplicationStateService;
 
+    @inject(WindowService)
+    protected readonly windowService: WindowService;
+
     protected titleBarStyleChangeFlag = false;
     protected titleBarStyle?: string;
 
@@ -241,6 +245,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
             cancel: Dialog.CANCEL
         });
         if (await dialog.open()) {
+            this.windowService.setSafeToShutDown();
             electron.ipcRenderer.send(Restart);
         }
     }

package/src/electron-browser/window/electron-window-service.ts

@@ -15,11 +15,12 @@
  ********************************************************************************/
 
 import { injectable, inject, postConstruct } from 'inversify';
-import { remote } from '../../../shared/electron';
+import * as electron from '../../../shared/electron';
 import { NewWindowOptions } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
 import { ElectronWindowPreferences } from './electron-window-preferences';
+import { CloseRequestArguments, CLOSE_REQUESTED_SIGNAL, RELOAD_REQUESTED_SIGNAL, StopReason } from '../../electron-common/messaging/electron-messages';
 
 @injectable()
 export class ElectronWindowService extends DefaultWindowService {
@@ -59,49 +60,24 @@ export class ElectronWindowService extends DefaultWindowService {
         });
     }
 
-    registerUnloadListeners(): void {
-        window.addEventListener('beforeunload', event => {
-            if (this.isUnloading) {
-                // Unloading process ongoing, do nothing:
-                return this.preventUnload(event);
-            } else if (this.closeOnUnload || this.canUnload()) {
-                // Let the window close and notify clients:
-                delete event.returnValue;
-                this.onUnloadEmitter.fire();
-                return;
-            } else {
-                this.isUnloading = true;
-                // Fix https://github.com/eclipse-theia/theia/issues/8186#issuecomment-742624480
-                // On Electron/Linux doing `showMessageBoxSync` does not seems to block the closing
-                // process long enough and closes the window no matter what you click on (yes/no).
-                // Instead we'll prevent closing right away, ask for confirmation and finally close.
-                setTimeout(() => {
-                    if (this.shouldUnload()) {
-                        this.closeOnUnload = true;
-                        window.close();
-                    }
-                    this.isUnloading = false;
-                });
-                return this.preventUnload(event);
-            }
-        });
+    protected registerUnloadListeners(): void {
+        electron.ipcRenderer.on(CLOSE_REQUESTED_SIGNAL, (_event, closeRequestEvent: CloseRequestArguments) => this.handleCloseRequestedEvent(closeRequestEvent));
+        window.addEventListener('unload', () => this.onUnloadEmitter.fire());
     }
 
     /**
-     * When preventing `beforeunload` on Electron, no popup is shown.
-     *
-     * This method implements a modal to ask the user if he wants to quit the page.
+     * Run when ElectronMain detects a `close` event and emits a `close-requested` event.
+     * Should send an event to `electron.ipcRenderer` on the event's `confirmChannel` if it is safe to exit
+     * after running FrontentApplication `onWillStop` handlers or on the `cancelChannel` if it is not safe to exit.
      */
-    protected shouldUnload(): boolean {
-        const electronWindow = remote.getCurrentWindow();
-        const response = remote.dialog.showMessageBoxSync(electronWindow, {
-            type: 'question',
-            buttons: ['Yes', 'No'],
-            title: 'Confirm',
-            message: 'Are you sure you want to quit?',
-            detail: 'Any unsaved changes will not be saved.'
-        });
-        return response === 0; // 'Yes', close the window.
+    protected async handleCloseRequestedEvent(event: CloseRequestArguments): Promise<void> {
+        const safeToClose = await this.isSafeToShutDown();
+        if (safeToClose) {
+            console.debug(`Shutting down because of ${StopReason[event.reason]} request.`);
+            electron.ipcRenderer.send(event.confirmChannel);
+        } else {
+            electron.ipcRenderer.send(event.cancelChannel);
+        }
     }
 
     /**
@@ -109,9 +85,13 @@ export class ElectronWindowService extends DefaultWindowService {
      */
     protected updateWindowZoomLevel(): void {
         const preferredZoomLevel = this.electronWindowPreferences['window.zoomLevel'];
-        const webContents = remote.getCurrentWindow().webContents;
+        const webContents = electron.remote.getCurrentWindow().webContents;
         if (webContents.getZoomLevel() !== preferredZoomLevel) {
             webContents.setZoomLevel(preferredZoomLevel);
         }
     }
+
+    reload(): void {
+        electron.ipcRenderer.send(RELOAD_REQUESTED_SIGNAL);
+    }
 }

package/src/electron-common/messaging/electron-messages.ts

@@ -18,3 +18,32 @@ export const RequestTitleBarStyle = 'requestTitleBarStyle';
 export const TitleBarStyleChanged = 'titleBarStyleChanged';
 export const TitleBarStyleAtStartup = 'titleBarStyleAtStartup';
 export const Restart = 'restart';
+/**
+ * Emitted by main when close requested.
+ */
+export const CLOSE_REQUESTED_SIGNAL = 'close-requested';
+/**
+ * Emitted by window when a reload is requested.
+ */
+export const RELOAD_REQUESTED_SIGNAL = 'reload-requested';
+
+export enum StopReason {
+    /**
+     * Closing the window with no prospect of restart.
+     */
+    Close,
+    /**
+     * Reload without closing the window.
+     */
+    Reload,
+    /**
+     * Reload that includes closing the window.
+     */
+    Restart, // eslint-disable-line @typescript-eslint/no-shadow
+}
+
+export interface CloseRequestArguments {
+    confirmChannel: string;
+    cancelChannel: string;
+    reason: StopReason;
+}

package/src/electron-main/electron-main-application.ts

@@ -31,7 +31,14 @@ import { ElectronSecurityTokenService } from './electron-security-token-service'
 import { ElectronSecurityToken } from '../electron-common/electron-token';
 import Storage = require('electron-store');
 import { isOSX, isWindows } from '../common';
-import { RequestTitleBarStyle, Restart, TitleBarStyleAtStartup, TitleBarStyleChanged } from '../electron-common/messaging/electron-messages';
+import {
+    CLOSE_REQUESTED_SIGNAL,
+    RELOAD_REQUESTED_SIGNAL,
+    RequestTitleBarStyle,
+    Restart, StopReason,
+    TitleBarStyleAtStartup,
+    TitleBarStyleChanged
+} from '../electron-common/messaging/electron-messages';
 import { DEFAULT_WINDOW_HASH } from '../common/window';
 
 const createYargs: (argv?: string[], cwd?: string) => Argv = require('yargs/yargs');
@@ -192,6 +199,8 @@ export class ElectronMainApplication {
     protected useNativeWindowFrame: boolean = true;
     protected didUseNativeWindowFrameOnStart = new Map<number, boolean>();
     protected restarting = false;
+    protected closeIsConfirmed = new Set<number>();
+    protected closeRequested = 0;
 
     get config(): FrontendApplicationConfig {
         if (!this._config) {
@@ -256,6 +265,7 @@ export class ElectronMainApplication {
         this.attachSaveWindowState(electronWindow);
         this.attachGlobalShortcuts(electronWindow);
         this.restoreMaximizedState(electronWindow, options);
+        this.attachCloseListeners(electronWindow, options);
         return electronWindow;
     }
 
@@ -433,19 +443,20 @@ export class ElectronMainApplication {
      * Catch certain keybindings to prevent reloading the window using keyboard shortcuts.
      */
     protected attachGlobalShortcuts(electronWindow: BrowserWindow): void {
-        if (this.config.electron?.disallowReloadKeybinding) {
-            const accelerators = ['CmdOrCtrl+R', 'F5'];
-            electronWindow.on('focus', () => {
-                for (const accelerator of accelerators) {
-                    globalShortcut.register(accelerator, () => { });
-                }
-            });
-            electronWindow.on('blur', () => {
-                for (const accelerator of accelerators) {
-                    globalShortcut.unregister(accelerator);
-                }
-            });
-        }
+        const handler = this.config.electron?.disallowReloadKeybinding
+            ? () => { }
+            : () => this.reload(electronWindow);
+        const accelerators = ['CmdOrCtrl+R', 'F5'];
+        electronWindow.on('focus', () => {
+            for (const accelerator of accelerators) {
+                globalShortcut.register(accelerator, handler);
+            }
+        });
+        electronWindow.on('blur', () => {
+            for (const accelerator of accelerators) {
+                globalShortcut.unregister(accelerator);
+            }
+        });
     }
 
     protected restoreMaximizedState(electronWindow: BrowserWindow, options: TheiaBrowserWindowOptions): void {
@@ -456,6 +467,43 @@ export class ElectronMainApplication {
         }
     }
 
+    protected attachCloseListeners(electronWindow: BrowserWindow, options: TheiaBrowserWindowOptions): void {
+        electronWindow.on('close', async event => {
+            // User has already indicated that it is OK to close this window.
+            if (this.closeIsConfirmed.has(electronWindow.id)) {
+                this.closeIsConfirmed.delete(electronWindow.id);
+                return;
+            }
+
+            event.preventDefault();
+            this.handleStopRequest(electronWindow, () => this.doCloseWindow(electronWindow), StopReason.Close);
+        });
+    }
+
+    protected doCloseWindow(electronWindow: BrowserWindow): void {
+        this.closeIsConfirmed.add(electronWindow.id);
+        electronWindow.close();
+    }
+
+    protected async handleStopRequest(electronWindow: BrowserWindow, onSafeCallback: () => unknown, reason: StopReason): Promise<void> {
+        // Only confirm close to windows that have loaded our front end.
+        const safeToClose = !electronWindow.webContents.getURL().includes(this.globals.THEIA_FRONTEND_HTML_PATH) || await this.checkSafeToStop(electronWindow, reason);
+        if (safeToClose) {
+            onSafeCallback();
+        }
+    }
+
+    protected checkSafeToStop(electronWindow: BrowserWindow, reason: StopReason): Promise<boolean> {
+        const closeRequest = this.closeRequested++;
+        const confirmChannel = `safeToClose-${electronWindow.id}-${closeRequest}`;
+        const cancelChannel = `notSafeToClose-${electronWindow.id}-${closeRequest}`;
+        return new Promise<boolean>(resolve => {
+            electronWindow.webContents.send(CLOSE_REQUESTED_SIGNAL, { confirmChannel, cancelChannel, reason });
+            ipcMain.once(confirmChannel, () => resolve(true));
+            ipcMain.once(cancelChannel, () => resolve(false));
+        });
+    }
+
     /**
      * Start the NodeJS backend server.
      *
@@ -541,6 +589,8 @@ export class ElectronMainApplication {
             this.restart(sender.id);
         });
 
+        ipcMain.on(RELOAD_REQUESTED_SIGNAL, event => this.handleReload(event));
+
         ipcMain.on(RequestTitleBarStyle, ({ sender }) => {
             sender.send(TitleBarStyleAtStartup, this.didUseNativeWindowFrameOnStart.get(sender.id) ? 'native' : 'custom');
         });
@@ -578,7 +628,16 @@ export class ElectronMainApplication {
             });
             this.restarting = false;
         });
-        window.close();
+        this.handleStopRequest(window, () => this.doCloseWindow(window), StopReason.Restart);
+    }
+
+    protected async handleReload(event: Electron.IpcMainEvent): Promise<void> {
+        const window = BrowserWindow.fromId(event.sender.id);
+        this.reload(window);
+    }
+
+    protected reload(electronWindow: BrowserWindow): void {
+        this.handleStopRequest(electronWindow, () => electronWindow.reload(), StopReason.Reload);
     }
 
     protected async startContributions(): Promise<void> {