@theia/core 1.37.0-next.9 → 1.37.1

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

@@ -0,0 +1,291 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import {
+    ipcMain, BrowserWindow, Menu, MenuItemConstructorOptions, webContents, WebContents, session, shell, clipboard, IpcMainEvent
+} from '@theia/electron/shared/electron';
+import * as nativeKeymap from '@theia/electron/shared/native-keymap';
+
+import { inject, injectable } from 'inversify';
+import { FrontendApplicationState, StopReason } from '../common/frontend-application-state';
+import { ElectronSecurityToken } from '../electron-common/electron-token';
+import {
+    CHANNEL_GET_SECURITY_TOKEN, CHANNEL_SET_MENU, MenuDto, CHANNEL_INVOKE_MENU, CHANNEL_FOCUS_WINDOW,
+    CHANNEL_ATTACH_SECURITY_TOKEN, CHANNEL_OPEN_POPUP, CHANNEL_ON_CLOSE_POPUP, CHANNEL_CLOSE_POPUP,
+    CHANNEL_GET_TITLE_STYLE_AT_STARTUP,
+    CHANNEL_MINIMIZE,
+    CHANNEL_MAXIMIZE,
+    CHANNEL_UNMAXIMIZE,
+    CHANNEL_CLOSE,
+    CHANNEL_ON_WINDOW_EVENT,
+    WindowEvent,
+    CHANNEL_TOGGLE_DEVTOOLS,
+    CHANNEL_SET_ZOOM_LEVEL,
+    CHANNEL_GET_ZOOM_LEVEL,
+    CHANNEL_IS_FULL_SCREENABLE,
+    CHANNEL_REQUEST_CLOSE,
+    CHANNEL_RESTART,
+    CHANNEL_SET_TITLE_STYLE,
+    CHANNEL_REQUEST_RELOAD,
+    CHANNEL_APP_STATE_CHANGED,
+    CHANNEL_SHOW_ITEM_IN_FOLDER,
+    CHANNEL_READ_CLIPBOARD,
+    CHANNEL_WRITE_CLIPBOARD,
+    CHANNEL_IPC_CONNECTION,
+    CHANNEL_IS_FULL_SCREEN,
+    InternalMenuDto,
+    CHANNEL_SET_MENU_BAR_VISIBLE,
+    CHANNEL_TOGGLE_FULL_SCREEN,
+    CHANNEL_IS_MAXIMIZED
+} from '../electron-common/electron-api';
+import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
+import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
+import { createDisposableListener } from './event-utils';
+
+@injectable()
+export class TheiaMainApi implements ElectronMainApplicationContribution {
+    @inject(ElectronSecurityToken)
+    protected electronSecurityToken: ElectronSecurityToken;
+
+    protected readonly openPopups = new Map<number, Menu>();
+
+    onStart(application: ElectronMainApplication): MaybePromise<void> {
+        // electron security token
+        ipcMain.handle(CHANNEL_GET_SECURITY_TOKEN, () => this.electronSecurityToken.value);
+
+        ipcMain.handle(CHANNEL_ATTACH_SECURITY_TOKEN, (event, endpoint) => session.defaultSession.cookies.set({
+            url: endpoint,
+            name: ElectronSecurityToken,
+            value: JSON.stringify(this.electronSecurityToken),
+            httpOnly: true,
+            sameSite: 'no_restriction'
+        }));
+
+        // application menu
+        ipcMain.on(CHANNEL_SET_MENU, (event, menuId: number, menu: MenuDto[]) => {
+            let electronMenu: Menu | null;
+            if (menu) {
+                electronMenu = Menu.buildFromTemplate(this.fromMenuDto(event.sender, menuId, menu));
+            } else {
+                // eslint-disable-next-line no-null/no-null
+                electronMenu = null;
+            }
+            if (isOSX) {
+                Menu.setApplicationMenu(electronMenu);
+            } else {
+                BrowserWindow.fromWebContents(event.sender)?.setMenu(electronMenu);
+            }
+        });
+
+        ipcMain.on(CHANNEL_SET_MENU_BAR_VISIBLE, (event, visible: boolean, windowName: string | undefined) => {
+            let electronWindow;
+            if (windowName) {
+                electronWindow = BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName);
+            } else {
+                electronWindow = BrowserWindow.fromWebContents(event.sender);
+            }
+            if (electronWindow) {
+                electronWindow.setMenuBarVisibility(visible);
+            } else {
+                console.warn(`There is no known secondary window '${windowName}'. Thus, the menu bar could not be made visible.`);
+            }
+        });
+
+        // popup menu
+        ipcMain.handle(CHANNEL_OPEN_POPUP, (event, menuId, menu, x, y) => {
+            const zoom = event.sender.getZoomFactor();
+            // TODO: Remove the offset once Electron fixes https://github.com/electron/electron/issues/31641
+            const offset = process.platform === 'win32' ? 0 : 2;
+            // x and y values must be Ints or else there is a conversion error
+            x = Math.round(x * zoom) + offset;
+            y = Math.round(y * zoom) + offset;
+            const popup = Menu.buildFromTemplate(this.fromMenuDto(event.sender, menuId, menu));
+            this.openPopups.set(menuId, popup);
+            popup.popup({
+                callback: () => {
+                    this.openPopups.delete(menuId);
+                    event.sender.send(CHANNEL_ON_CLOSE_POPUP, menuId);
+                }
+            });
+        });
+
+        ipcMain.handle(CHANNEL_CLOSE_POPUP, (event, handle) => {
+            if (this.openPopups.has(handle)) {
+                this.openPopups.get(handle)!.closePopup();
+            }
+        });
+
+        // focus windows for secondary window support
+        ipcMain.on(CHANNEL_FOCUS_WINDOW, (event, windowName) => {
+            const electronWindow = BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName);
+            if (electronWindow) {
+                if (electronWindow.isMinimized()) {
+                    electronWindow.restore();
+                }
+                electronWindow.focus();
+            } else {
+                console.warn(`There is no known secondary window '${windowName}'. Thus, the window could not be focussed.`);
+            }
+        });
+
+        ipcMain.on(CHANNEL_SHOW_ITEM_IN_FOLDER, (event, fsPath) => {
+            shell.showItemInFolder(fsPath);
+        });
+
+        ipcMain.handle(CHANNEL_GET_TITLE_STYLE_AT_STARTUP, event => application.getTitleBarStyleAtStartup(event.sender));
+
+        ipcMain.on(CHANNEL_SET_TITLE_STYLE, (event, style) => application.setTitleBarStyle(event.sender, style));
+
+        ipcMain.on(CHANNEL_MINIMIZE, event => {
+            BrowserWindow.fromWebContents(event.sender)?.minimize();
+        });
+
+        ipcMain.on(CHANNEL_IS_MAXIMIZED, event => {
+            event.returnValue = BrowserWindow.fromWebContents(event.sender)?.isMaximized();
+        });
+
+        ipcMain.on(CHANNEL_MAXIMIZE, event => {
+            BrowserWindow.fromWebContents(event.sender)?.maximize();
+        });
+
+        ipcMain.on(CHANNEL_UNMAXIMIZE, event => {
+            BrowserWindow.fromWebContents(event.sender)?.unmaximize();
+        });
+
+        ipcMain.on(CHANNEL_CLOSE, event => {
+            BrowserWindow.fromWebContents(event.sender)?.close();
+        });
+
+        ipcMain.on(CHANNEL_RESTART, event => {
+            application.restart(event.sender);
+        });
+
+        ipcMain.on(CHANNEL_TOGGLE_DEVTOOLS, event => {
+            event.sender.toggleDevTools();
+        });
+
+        ipcMain.on(CHANNEL_SET_ZOOM_LEVEL, (event, zoomLevel: number) => {
+            event.sender.setZoomLevel(zoomLevel);
+        });
+
+        ipcMain.handle(CHANNEL_GET_ZOOM_LEVEL, event => event.sender.getZoomLevel());
+
+        ipcMain.on(CHANNEL_TOGGLE_FULL_SCREEN, event => {
+            const win = BrowserWindow.fromWebContents(event.sender);
+            if (win) {
+                win.setFullScreen(!win.isFullScreen());
+            }
+        });
+        ipcMain.on(CHANNEL_IS_FULL_SCREENABLE, event => {
+            event.returnValue = BrowserWindow.fromWebContents(event.sender)?.isFullScreenable();
+        });
+
+        ipcMain.on(CHANNEL_IS_FULL_SCREEN, event => {
+            event.returnValue = BrowserWindow.fromWebContents(event.sender)?.isFullScreen();
+        });
+
+        ipcMain.on(CHANNEL_READ_CLIPBOARD, event => {
+            event.returnValue = clipboard.readText();
+        });
+        ipcMain.on(CHANNEL_WRITE_CLIPBOARD, (event, text) => {
+            clipboard.writeText(text);
+        });
+
+        nativeKeymap.onDidChangeKeyboardLayout(() => {
+            const newLayout = {
+                info: nativeKeymap.getCurrentKeyboardLayout(),
+                mapping: nativeKeymap.getKeyMap()
+            };
+            for (const webContent of webContents.getAllWebContents()) {
+                webContent.send('keyboardLayoutChanged', newLayout);
+            }
+        });
+    }
+
+    fromMenuDto(sender: WebContents, menuId: number, menuDto: InternalMenuDto[]): MenuItemConstructorOptions[] {
+        return menuDto.map(dto => {
+
+            const result: MenuItemConstructorOptions = {
+                id: dto.id,
+                label: dto.label,
+                type: dto.type,
+                checked: dto.checked,
+                enabled: dto.enabled,
+                visible: dto.visible,
+                role: dto.role,
+                accelerator: dto.accelerator
+            };
+            if (dto.submenu) {
+                result.submenu = this.fromMenuDto(sender, menuId, dto.submenu);
+            }
+            if (dto.handlerId) {
+                result.click = () => {
+                    sender.send(CHANNEL_INVOKE_MENU, menuId, dto.handlerId);
+                };
+            }
+            return result;
+        });
+    }
+}
+
+let nextReplyChannel: number = 0;
+
+export namespace TheiaRendererAPI {
+    export function sendWindowEvent(wc: WebContents, event: WindowEvent): void {
+        wc.send(CHANNEL_ON_WINDOW_EVENT, event);
+    }
+
+    export function requestClose(wc: WebContents, stopReason: StopReason): Promise<boolean> {
+        const channelNr = nextReplyChannel++;
+        const confirmChannel = `confirm-${channelNr}`;
+        const cancelChannel = `cancel-${channelNr}`;
+        const disposables = new DisposableCollection();
+
+        return new Promise<boolean>(resolve => {
+            wc.send(CHANNEL_REQUEST_CLOSE, stopReason, confirmChannel, cancelChannel);
+            createDisposableListener(ipcMain, confirmChannel, e => {
+                resolve(true);
+            }, disposables);
+            createDisposableListener(ipcMain, cancelChannel, e => {
+                resolve(false);
+            }, disposables);
+        }).finally(() => disposables.dispose());
+    }
+
+    export function onRequestReload(wc: WebContents, handler: () => void): Disposable {
+        return createWindowListener(wc, CHANNEL_REQUEST_RELOAD, handler);
+    }
+
+    export function onApplicationStateChanged(wc: WebContents, handler: (state: FrontendApplicationState) => void): Disposable {
+        return createWindowListener(wc, CHANNEL_APP_STATE_CHANGED, state => handler(state as FrontendApplicationState));
+    }
+
+    export function onIpcData(handler: (sender: WebContents, data: Uint8Array) => void): Disposable {
+        return createDisposableListener<IpcMainEvent>(ipcMain, CHANNEL_IPC_CONNECTION, (event, data) => handler(event.sender, data as Uint8Array));
+    }
+
+    export function sendData(wc: WebContents, data: Uint8Array): void {
+        wc.send(CHANNEL_IPC_CONNECTION, data);
+    }
+
+    function createWindowListener(wc: WebContents, channel: string, handler: (...args: unknown[]) => unknown): Disposable {
+        return createDisposableListener<IpcMainEvent>(ipcMain, channel, (event, ...args) => {
+            if (wc.id === event.sender.id) {
+                handler(...args);
+            }
+        });
+    }
+}

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

@@ -27,7 +27,7 @@ import { ElectronMessagingService } from './messaging/electron-messaging-service
 import { ElectronConnectionHandler } from '../electron-common/messaging/electron-connection-handler';
 import { ElectronSecurityTokenService } from './electron-security-token-service';
 import { TheiaBrowserWindowOptions, TheiaElectronWindow, TheiaElectronWindowFactory, WindowApplicationConfig } from './theia-electron-window';
-import { ElectronNativeKeymap } from './electron-native-keymap';
+import { TheiaMainApi } from './electron-api-main';
 
 const electronSecurityToken: ElectronSecurityToken = { value: v4() };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -44,6 +44,8 @@ export default new ContainerModule(bind => {
     bindContributionProvider(bind, ElectronMainApplicationContribution);
 
     bind(ElectronMainApplicationContribution).toService(ElectronMessagingContribution);
+    bind(TheiaMainApi).toSelf().inSingletonScope();
+    bind(ElectronMainApplicationContribution).toService(TheiaMainApi);
 
     bind(ElectronMainWindowService).to(ElectronMainWindowServiceImpl).inSingletonScope();
     bind(ElectronConnectionHandler).toDynamicValue(context =>
@@ -60,7 +62,4 @@ export default new ContainerModule(bind => {
         child.bind(WindowApplicationConfig).toConstantValue(config);
         return child.get(TheiaElectronWindow);
     });
-
-    bind(ElectronNativeKeymap).toSelf().inSingletonScope();
-    bind(ElectronMainApplicationContribution).toService(ElectronNativeKeymap);
 });

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

@@ -15,8 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable, named } from 'inversify';
-import * as electronRemoteMain from '../../electron-shared/@electron/remote/main';
-import { screen, ipcMain, app, BrowserWindow, Event as ElectronEvent, BrowserWindowConstructorOptions, nativeImage } from '../../electron-shared/electron';
+import { screen, app, BrowserWindow, WebContents, Event as ElectronEvent, BrowserWindowConstructorOptions, nativeImage } from '../../electron-shared/electron';
 import * as path from 'path';
 import { Argv } from 'yargs';
 import { AddressInfo } from 'net';
@@ -32,16 +31,12 @@ import { ElectronSecurityTokenService } from './electron-security-token-service'
 import { ElectronSecurityToken } from '../electron-common/electron-token';
 import Storage = require('electron-store');
 import { Disposable, DisposableCollection, isOSX, isWindows } from '../common';
-import {
-    RequestTitleBarStyle,
-    Restart, StopReason,
-    TitleBarStyleAtStartup,
-    TitleBarStyleChanged
-} from '../electron-common/messaging/electron-messages';
 import { DEFAULT_WINDOW_HASH } from '../common/window';
 import { TheiaBrowserWindowOptions, TheiaElectronWindow, TheiaElectronWindowFactory } from './theia-electron-window';
 import { ElectronMainApplicationGlobals } from './electron-main-constants';
 import { createDisposableListener } from './event-utils';
+import { TheiaRendererAPI } from './electron-api-main';
+import { StopReason } from '../common/frontend-application-state';
 
 export { ElectronMainApplicationGlobals };
 
@@ -156,7 +151,6 @@ export namespace ElectronMainProcessArgv {
 
 @injectable()
 export class ElectronMainApplication {
-
     @inject(ContributionProvider)
     @named(ElectronMainApplicationContribution)
     protected readonly contributions: ContributionProvider<ElectronMainApplicationContribution>;
@@ -229,6 +223,24 @@ export class ElectronMainApplication {
         return isWindows ? 'custom' : 'native';
     }
 
+    public setTitleBarStyle(webContents: WebContents, style: string): void {
+        this.useNativeWindowFrame = isOSX || style === 'native';
+        const browserWindow = BrowserWindow.fromWebContents(webContents);
+        if (browserWindow) {
+            this.saveWindowState(browserWindow);
+        } else {
+            console.warn(`no BrowserWindow with id: ${webContents.id}`);
+        }
+    }
+
+    /**
+     * @param id the id of the WebContents of the BrowserWindow in question
+     * @returns 'native' or 'custom'
+     */
+    getTitleBarStyleAtStartup(webContents: WebContents): 'native' | 'custom' {
+        return this.didUseNativeWindowFrameOnStart.get(webContents.id) ? 'native' : 'custom';
+    }
+
     protected async launch(params: ElectronMainExecutionParams): Promise<void> {
         createYargs(params.argv, params.cwd)
             .command('$0 [file]', false,
@@ -247,11 +259,13 @@ export class ElectronMainApplication {
         let options = await asyncOptions;
         options = this.avoidOverlap(options);
         const electronWindow = this.windowFactory(options, this.config);
-        const { window: { id } } = electronWindow;
+        const id = electronWindow.window.webContents.id;
         this.windows.set(id, electronWindow);
         electronWindow.onDidClose(() => this.windows.delete(id));
+        electronWindow.window.on('maximize', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'maximize'));
+        electronWindow.window.on('unmaximize', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'unmaximize'));
+        electronWindow.window.on('focus', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'focus'));
         this.attachSaveWindowState(electronWindow.window);
-        electronRemoteMain.enable(electronWindow.window.webContents);
         this.configureNativeSecondaryWindowCreation(electronWindow.window);
         return electronWindow.window;
     }
@@ -292,12 +306,13 @@ export class ElectronMainApplication {
             minHeight: 120,
             webPreferences: {
                 // `global` is undefined when `true`.
-                contextIsolation: false,
-                // https://github.com/eclipse-theia/theia/issues/2018
-                nodeIntegration: true,
+                contextIsolation: true,
+                sandbox: false,
+                nodeIntegration: false,
                 // Setting the following option to `true` causes some features to break, somehow.
                 // Issue: https://github.com/eclipse-theia/theia/issues/8577
                 nodeIntegrationInWorker: false,
+                preload: path.resolve(this.globals.THEIA_APP_PROJECT_PATH, 'lib/preload.js').toString()
             },
             ...this.config.electron?.windowOptions || {},
         };
@@ -418,8 +433,8 @@ export class ElectronMainApplication {
         }, windowStateListeners);
         createDisposableListener(electronWindow, 'resize', saveWindowStateDelayed, windowStateListeners);
         createDisposableListener(electronWindow, 'move', saveWindowStateDelayed, windowStateListeners);
-        windowStateListeners.push(Disposable.create(() => { try { this.didUseNativeWindowFrameOnStart.delete(electronWindow.id); } catch { } }));
-        this.didUseNativeWindowFrameOnStart.set(electronWindow.id, this.useNativeWindowFrame);
+        windowStateListeners.push(Disposable.create(() => { try { this.didUseNativeWindowFrameOnStart.delete(electronWindow.webContents.id); } catch { } }));
+        this.didUseNativeWindowFrameOnStart.set(electronWindow.webContents.id, this.useNativeWindowFrame);
         electronWindow.once('closed', () => windowStateListeners.dispose());
     }
 
@@ -532,24 +547,6 @@ export class ElectronMainApplication {
         app.on('will-quit', this.onWillQuit.bind(this));
         app.on('second-instance', this.onSecondInstance.bind(this));
         app.on('window-all-closed', this.onWindowAllClosed.bind(this));
-
-        ipcMain.on(TitleBarStyleChanged, ({ sender }, titleBarStyle: string) => {
-            this.useNativeWindowFrame = isOSX || titleBarStyle === 'native';
-            const browserWindow = BrowserWindow.fromId(sender.id);
-            if (browserWindow) {
-                this.saveWindowState(browserWindow);
-            } else {
-                console.warn(`no BrowserWindow with id: ${sender.id}`);
-            }
-        });
-
-        ipcMain.on(Restart, ({ sender }) => {
-            this.restart(sender.id);
-        });
-
-        ipcMain.on(RequestTitleBarStyle, ({ sender }) => {
-            sender.send(TitleBarStyleAtStartup, this.didUseNativeWindowFrameOnStart.get(sender.id) ? 'native' : 'custom');
-        });
     }
 
     protected onWillQuit(event: ElectronEvent): void {
@@ -573,10 +570,9 @@ export class ElectronMainApplication {
         }
     }
 
-    protected async restart(id: number): Promise<void> {
+    public async restart(webContents: WebContents): Promise<void> {
         this.restarting = true;
-        const window = BrowserWindow.fromId(id);
-        const wrapper = this.windows.get(window?.id as number); // If it's not a number, we won't get anything.
+        const wrapper = this.windows.get(webContents.id);
         if (wrapper) {
             const listener = wrapper.onDidClose(async () => {
                 listener.dispose();

package/src/electron-main/electron-security-token-service.ts

@@ -29,7 +29,8 @@ export class ElectronSecurityTokenService {
             url,
             name: ElectronSecurityToken,
             value: JSON.stringify(this.electronSecurityToken),
-            httpOnly: true
+            httpOnly: true,
+            sameSite: 'no_restriction'
         });
     }
 }

package/src/electron-main/messaging/electron-messaging-contribution.ts

@@ -14,16 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { IpcMainEvent, ipcMain, WebContents } from '@theia/electron/shared/electron';
+import { WebContents } from '@theia/electron/shared/electron';
 import { inject, injectable, named, postConstruct } from 'inversify';
 import { ContributionProvider } from '../../common/contribution-provider';
 import { MessagingContribution } from '../../node/messaging/messaging-contribution';
-import { ElectronConnectionHandler, THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
+import { ElectronConnectionHandler } from '../../electron-common/messaging/electron-connection-handler';
 import { ElectronMainApplicationContribution } from '../electron-main-application';
 import { ElectronMessagingService } from './electron-messaging-service';
 import { AbstractChannel, Channel, ChannelMultiplexer, MessageProvider } from '../../common/message-rpc/channel';
-import { Emitter, WriteBuffer } from '../../common';
+import { ConnectionHandler, Emitter, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+import { TheiaRendererAPI } from '../electron-api-main';
 
 /**
  * This component replicates the role filled by `MessagingContribution` but for Electron.
@@ -40,7 +41,7 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
     protected readonly messagingContributions: ContributionProvider<ElectronMessagingService.Contribution>;
 
     @inject(ContributionProvider) @named(ElectronConnectionHandler)
-    protected readonly connectionHandlers: ContributionProvider<ElectronConnectionHandler>;
+    protected readonly connectionHandlers: ContributionProvider<ConnectionHandler>;
 
     protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<Channel>();
     /**
@@ -50,13 +51,10 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
 
     @postConstruct()
     protected init(): void {
-        ipcMain.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (event: IpcMainEvent, data: Uint8Array) => {
-            this.handleIpcEvent(event, data);
-        });
+        TheiaRendererAPI.onIpcData((sender, data) => this.handleIpcEvent(sender, data));
     }
 
-    protected handleIpcEvent(event: IpcMainEvent, data: Uint8Array): void {
-        const sender = event.sender;
+    protected handleIpcEvent(sender: WebContents, data: Uint8Array): void {
         // Get the multiplexer for a given window id
         try {
             const windowChannelData = this.windowChannelMultiplexer.get(sender.id) ?? this.createWindowChannelData(sender);
@@ -133,7 +131,7 @@ export class ElectronWebContentChannel extends AbstractChannel {
 
         writer.onCommit(buffer => {
             if (!this.sender.isDestroyed()) {
-                this.sender.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer);
+                TheiaRendererAPI.sendData(this.sender, buffer);
             }
         });
 

package/src/electron-main/theia-electron-window.ts

@@ -15,15 +15,15 @@
 // *****************************************************************************
 
 import { FrontendApplicationConfig } from '@theia/application-package';
-import { FrontendApplicationState } from '../common/frontend-application-state';
-import { APPLICATION_STATE_CHANGE_SIGNAL, CLOSE_REQUESTED_SIGNAL, RELOAD_REQUESTED_SIGNAL, StopReason } from '../electron-common/messaging/electron-messages';
-import { BrowserWindow, BrowserWindowConstructorOptions, ipcMain, IpcMainEvent } from '../../electron-shared/electron';
+import { FrontendApplicationState, StopReason } from '../common/frontend-application-state';
+import { BrowserWindow, BrowserWindowConstructorOptions } from '../../electron-shared/electron';
 import { inject, injectable, postConstruct } from '../../shared/inversify';
 import { ElectronMainApplicationGlobals } from './electron-main-constants';
 import { DisposableCollection, Emitter, Event } from '../common';
 import { createDisposableListener } from './event-utils';
 import { URI } from '../common/uri';
 import { FileUri } from '../node/file-uri';
+import { TheiaRendererAPI } from './electron-api-main';
 
 /**
  * Theia tracks the maximized state of Electron Browser Windows.
@@ -138,22 +138,7 @@ export class TheiaElectronWindow {
     }
 
     protected checkSafeToStop(reason: StopReason): Promise<boolean> {
-        const confirmChannel = `safe-to-close-${this._window.id}`;
-        const cancelChannel = `notSafeToClose-${this._window.id}`;
-        const temporaryDisposables = new DisposableCollection();
-        return new Promise<boolean>(resolve => {
-            this._window.webContents.send(CLOSE_REQUESTED_SIGNAL, { confirmChannel, cancelChannel, reason });
-            createDisposableListener(ipcMain, confirmChannel, (e: IpcMainEvent) => {
-                if (this.isSender(e)) {
-                    resolve(true);
-                }
-            }, temporaryDisposables);
-            createDisposableListener(ipcMain, cancelChannel, (e: IpcMainEvent) => {
-                if (this.isSender(e)) {
-                    resolve(false);
-                }
-            }, temporaryDisposables);
-        }).finally(() => temporaryDisposables.dispose());
+        return TheiaRendererAPI.requestClose(this.window.webContents, reason);
     }
 
     protected restoreMaximizedState(): void {
@@ -165,23 +150,13 @@ export class TheiaElectronWindow {
     }
 
     protected trackApplicationState(): void {
-        createDisposableListener(ipcMain, APPLICATION_STATE_CHANGE_SIGNAL, (e: IpcMainEvent, state: FrontendApplicationState) => {
-            if (this.isSender(e)) {
-                this.applicationState = state;
-            }
-        }, this.toDispose);
+        this.toDispose.push(TheiaRendererAPI.onApplicationStateChanged(this.window.webContents, state => {
+            this.applicationState = state;
+        }));
     }
 
     protected attachReloadListener(): void {
-        createDisposableListener(ipcMain, RELOAD_REQUESTED_SIGNAL, (e: IpcMainEvent) => {
-            if (this.isSender(e)) {
-                this.reload();
-            }
-        }, this.toDispose);
-    }
-
-    protected isSender(e: IpcMainEvent): boolean {
-        return BrowserWindow.fromId(e.sender.id) === this._window;
+        this.toDispose.push(TheiaRendererAPI.onRequestReload(this.window.webContents, () => this.reload()));
     }
 
     dispose(): void {

package/src/node/i18n/localization-backend-contribution.ts

@@ -16,6 +16,7 @@
 
 import * as express from 'express';
 import { inject, injectable } from 'inversify';
+import { nls } from '../../common/nls';
 import { Deferred } from '../../common/promise-util';
 import { BackendApplicationContribution } from '../backend-application';
 import { LocalizationRegistry } from './localization-contribution';
@@ -44,7 +45,7 @@ export class LocalizationBackendContribution implements BackendApplicationContri
         app.get('/i18n/:locale', async (req, res) => {
             await this.waitForInitialization();
             let locale = req.params.locale;
-            locale = this.localizationProvider.getAvailableLanguages().some(e => e.languageId === locale) ? locale : 'en';
+            locale = this.localizationProvider.getAvailableLanguages().some(e => e.languageId === locale) ? locale : nls.defaultLocale;
             this.localizationProvider.setCurrentLanguage(locale);
             res.send(this.localizationProvider.loadLocalization(locale));
         });

package/src/node/i18n/localization-provider.ts

@@ -15,13 +15,14 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
+import { nls } from '../../common/nls';
 import { LanguageInfo, Localization } from '../../common/i18n/localization';
 
 @injectable()
 export class LocalizationProvider {
 
     protected localizations: Localization[] = [];
-    protected currentLanguage = 'en';
+    protected currentLanguage = nls.defaultLocale;
 
     addLocalizations(...localizations: Localization[]): void {
         this.localizations.push(...localizations);