@theia/core 1.44.0 → 1.45.0

package/src/common/message-rpc/channel.ts

@@ -220,6 +220,8 @@ export class ChannelMultiplexer implements Disposable {
             this.openChannels.set(id, channel);
             resolve(channel);
             this.onOpenChannelEmitter.fire({ id, channel });
+        } else {
+            console.error(`not expecting ack-open on for ${id}`);
         }
     }
 
@@ -234,6 +236,8 @@ export class ChannelMultiplexer implements Disposable {
             }
             this.underlyingChannel.getWriteBuffer().writeUint8(MessageTypes.AckOpen).writeString(id).commit();
             this.onOpenChannelEmitter.fire({ id, channel });
+        } else {
+            console.error(`channel already open: ${id}`);
         }
     }
 
@@ -275,7 +279,7 @@ export class ChannelMultiplexer implements Disposable {
     }
 
     open(id: string): Promise<Channel> {
-        if (this.openChannels.has(id)) {
+        if (this.openChannels.has(id) || this.pendingOpen.has(id)) {
             throw new Error(`Another channel with the id '${id}' is already open.`);
         }
         const result = new Promise<Channel>((resolve, reject) => {

package/src/common/message-rpc/message-buffer.ts

@@ -25,6 +25,7 @@ export interface WriteBuffer {
     writeBytes(value: Uint8Array): this
     writeNumber(value: number): this
     writeLength(value: number): this
+    writeRaw(bytes: Uint8Array): this;
     /**
      * Makes any writes to the buffer permanent, for example by sending the writes over a channel.
      * You must obtain a new write buffer after committing
@@ -71,6 +72,11 @@ export class ForwardingWriteBuffer implements WriteBuffer {
         return this;
     }
 
+    writeRaw(bytes: Uint8Array): this {
+        this.underlying.writeRaw(bytes);
+        return this;
+    }
+
     commit(): void {
         this.underlying.commit();
     }

package/src/common/message-rpc/uint8-array-message-buffer.ts

@@ -76,6 +76,13 @@ export class Uint8ArrayWriteBuffer implements WriteBuffer, Disposable {
         return this;
     }
 
+    writeRaw(bytes: Uint8Array): this {
+        this.ensureCapacity(bytes.byteLength);
+        this.buffer.set(bytes, this.offset);
+        this.offset += bytes.byteLength;
+        return this;
+    }
+
     writeUint16(value: number): this {
         this.ensureCapacity(2);
         this.msg.setUint16(this.offset, value);

package/src/common/messaging/connection-management.ts

@@ -0,0 +1,43 @@
+
+// *****************************************************************************
+// Copyright (C) 2017 TypeFox 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export const ConnectionCloseService = Symbol('ConnectionCloseService');
+export const connectionCloseServicePath = '/services/ChannelCloseService';
+
+/**
+ * These messages are used to negotiate service reconnection between a front ends and back end.
+ * Whenever a front end first connects to a back end, it sends the ${@link ConnectionManagementMessages#INITIAL_CONNECT} message
+ * together with its front end id.
+ * The back end then starts a new front end connection context for that front end. If the back end already had another connection context
+ * for the given front end id, it gets discarded.
+ * If the front end reconnects after a websocket disconnect, it sends the ${@link ConnectionManagementMessages#RECONNECT} message
+ * together with its front end id..
+ * If the back end still has a connection context for the front end id, the context is reconnected and the back end replies with the value true.
+ * If there is no context anymore, the back end replies with value false. The front end can then either do an initial connect or reload
+ * the whole UI.
+ */
+export namespace ConnectionManagementMessages {
+    export const INITIAL_CONNECT = 'initialConnection';
+    export const RECONNECT = 'reconnect';
+}
+
+/**
+ * A service to mark a front end as unused. As soon as it disconnects from the back end, the connection context will be discarded.
+ */
+export interface ConnectionCloseService {
+    markForClose(frontEndId: string): Promise<void>;
+}

package/src/common/messaging/handler.ts

@@ -16,6 +16,8 @@
 
 import { Channel } from '../message-rpc/channel';
 
+export const servicesPath = '/services';
+
 export const ConnectionHandler = Symbol('ConnectionHandler');
 
 export interface ConnectionHandler {

package/src/common/messaging/socket-write-buffer.ts

@@ -0,0 +1,52 @@
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { WebSocket } from './web-socket-channel';
+
+export class SocketWriteBuffer {
+    private static DISCONNECTED_BUFFER_SIZE = 100 * 1024;
+
+    private disconnectedBuffer: Uint8Array | undefined;
+    private bufferWritePosition = 0;
+
+    buffer(data: Uint8Array): void {
+        this.ensureWriteBuffer(data.byteLength);
+        this.disconnectedBuffer?.set(data, this.bufferWritePosition);
+        this.bufferWritePosition += data.byteLength;
+    }
+
+    protected ensureWriteBuffer(byteLength: number): void {
+        if (!this.disconnectedBuffer) {
+            this.disconnectedBuffer = new Uint8Array(SocketWriteBuffer.DISCONNECTED_BUFFER_SIZE);
+            this.bufferWritePosition = 0;
+        }
+
+        if (this.bufferWritePosition + byteLength > this.disconnectedBuffer.byteLength) {
+            throw new Error(`Max disconnected buffer size exceeded by adding ${byteLength} bytes`);
+        }
+    }
+
+    flush(socket: WebSocket): void {
+        if (this.disconnectedBuffer) {
+            socket.send(this.disconnectedBuffer.slice(0, this.bufferWritePosition));
+            this.disconnectedBuffer = undefined;
+        }
+    }
+
+    drain(): void {
+        this.disconnectedBuffer = undefined;
+    }
+}

package/src/common/messaging/web-socket-channel.ts

@@ -19,7 +19,11 @@
 import { WriteBuffer } from '../message-rpc';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../message-rpc/uint8-array-message-buffer';
 import { AbstractChannel } from '../message-rpc/channel';
-import { Disposable } from '../disposable';
+import { Socket as ClientSocket } from 'socket.io-client';
+import { Socket as ServerSocket } from 'socket.io';
+import { Emitter } from 'vscode-languageserver-protocol';
+
+export type WebSocket = ClientSocket | ServerSocket;
 
 /**
  * A channel that manages the main websocket connection between frontend and backend. All service channels
@@ -29,65 +33,44 @@ import { Disposable } from '../disposable';
 export class WebSocketChannel extends AbstractChannel {
     static wsPath = '/services';
 
-    constructor(protected readonly socket: IWebSocket) {
+    private onDidConnectEmitter = new Emitter<void>();
+    onDidConnect = this.onDidConnectEmitter.event;
+
+    constructor(protected readonly socket: WebSocket) {
         super();
-        this.toDispose.push(Disposable.create(() => socket.close()));
-        socket.onClose((reason, code) => this.onCloseEmitter.fire({ reason, code }));
-        socket.onClose(() => this.close());
-        socket.onError(error => this.onErrorEmitter.fire(error));
-        socket.onMessage(data => this.onMessageEmitter.fire(() => {
+        socket.on('connect', () => {
+            this.onDidConnectEmitter.fire();
+        });
+
+        socket.on('disconnect', reason => {
+            this.onCloseEmitter.fire({
+                reason: reason
+            });
+        });
+
+        socket.on('error', reason => this.onErrorEmitter.fire(reason));
+        socket.on('message', data => {
             // In the browser context socketIO receives binary messages as ArrayBuffers.
             // So we have to convert them to a Uint8Array before delegating the message to the read buffer.
             const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-            return new Uint8ArrayReadBuffer(buffer);
-        }));
+            this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(buffer));
+        });
     }
 
     getWriteBuffer(): WriteBuffer {
         const result = new Uint8ArrayWriteBuffer();
 
         result.onCommit(buffer => {
-            if (this.socket.isConnected()) {
+            if (this.socket.connected) {
                 this.socket.send(buffer);
             }
         });
 
         return result;
     }
-}
 
-/**
- * An abstraction that enables reuse of the `{@link WebSocketChannel} class in the frontend and backend
- * independent of the actual underlying socket implementation.
- */
-export interface IWebSocket {
-    /**
-     * Sends the given message over the web socket in binary format.
-     * @param message The binary message.
-     */
-    send(message: Uint8Array): void;
-    /**
-     * Closes the websocket from the local side.
-     */
-    close(): void;
-    /**
-     * The connection state of the web socket.
-     */
-    isConnected(): boolean;
-    /**
-     * Listener callback to handle incoming messages.
-     * @param cb The callback.
-     */
-    onMessage(cb: (message: Uint8Array) => void): void;
-    /**
-     * Listener callback to handle socket errors.
-     * @param cb The callback.
-     */
-    onError(cb: (reason: any) => void): void;
-    /**
-     * Listener callback to handle close events (Remote side).
-     * @param cb The callback.
-     */
-    onClose(cb: (reason: string, code?: number) => void): void;
+    override close(): void {
+        this.socket.disconnect();
+        super.close();
+    }
 }
-

package/src/electron-browser/messaging/electron-frontend-id-provider.ts

@@ -0,0 +1,25 @@
+// *****************************************************************************
+// 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from 'inversify';
+import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
+
+@injectable()
+export class ElectronFrontendIdProvider implements FrontendIdProvider {
+    getId(): string {
+        return window.electronTheiaCore.WindowMetadata.webcontentId;
+    }
+}

package/src/electron-browser/messaging/{electron-ipc-connection-provider.ts → electron-ipc-connection-source.ts}

@@ -16,32 +16,36 @@
 
 import { injectable, interfaces } from 'inversify';
 import { RpcProxy } from '../../common/messaging';
-import { AbstractConnectionProvider } from '../../common/messaging/abstract-connection-provider';
-import { AbstractChannel, Channel, WriteBuffer } from '../../common';
+import { AbstractChannel, Channel, Emitter, Event, MaybePromise, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+import { FrontendApplicationContribution } from '../../browser';
 
 export interface ElectronIpcOptions {
 }
 
+export const ElectronMainConnectionProvider = Symbol('ElectronMainConnectionProvider');
+
 /**
  * Connection provider between the Theia frontend and the electron-main process via IPC.
  */
-@injectable()
-export class ElectronIpcConnectionProvider extends AbstractConnectionProvider<ElectronIpcOptions> {
+export namespace ElectronIpcConnectionProvider {
 
-    static override createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
-        return container.get(ElectronIpcConnectionProvider).createProxy<T>(path, arg);
+    export function createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
+        return container.get<ServiceConnectionProvider>(ElectronMainConnectionProvider).createProxy<T>(path, arg);
     }
+}
 
-    constructor() {
-        super();
-        this.initializeMultiplexer();
-    }
+@injectable()
+export class ElectronIpcConnectionSource implements ConnectionSource, FrontendApplicationContribution {
+    protected readonly onConnectionDidOpenEmitter: Emitter<Channel> = new Emitter();
+    onConnectionDidOpen: Event<Channel> = this.onConnectionDidOpenEmitter.event;
 
-    protected createMainChannel(): Channel {
-        return new ElectronIpcRendererChannel();
+    onStart(): MaybePromise<void> {
+        const channel = new ElectronIpcRendererChannel();
+        this.onConnectionDidOpenEmitter.fire(channel);
     }
-
 }
 
 export class ElectronIpcRendererChannel extends AbstractChannel {

package/src/electron-browser/messaging/{electron-local-ws-connection-provider.ts → electron-local-ws-connection-source.ts}

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
-import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { Endpoint } from '../../browser/endpoint';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 
 export function getLocalPort(): string | undefined {
     const params = new URLSearchParams(location.search);
@@ -24,7 +24,7 @@ export function getLocalPort(): string | undefined {
 }
 
 @injectable()
-export class ElectronLocalWebSocketConnectionProvider extends WebSocketConnectionProvider {
+export class ElectronLocalWebSocketConnectionSource extends WebSocketConnectionSource {
 
     protected override createEndpoint(path: string): Endpoint {
         const localPort = getLocalPort();

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -16,26 +16,63 @@
 
 import { ContainerModule } from 'inversify';
 import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
-import { LocalWebSocketConnectionProvider, WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
-import { ElectronWebSocketConnectionProvider } from './electron-ws-connection-provider';
-import { ElectronIpcConnectionProvider } from './electron-ipc-connection-provider';
-import { ElectronLocalWebSocketConnectionProvider, getLocalPort } from './electron-local-ws-connection-provider';
+import { ElectronWebSocketConnectionSource } from './electron-ws-connection-source';
+import { ElectronIpcConnectionSource, ElectronMainConnectionProvider } from './electron-ipc-connection-source';
+import { ElectronLocalWebSocketConnectionSource, getLocalPort } from './electron-local-ws-connection-source';
+import { ElectronFrontendIdProvider } from './electron-frontend-id-provider';
+import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { WebSocketConnectionProvider } from '../../browser';
+import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
+
+const backendServiceProvider = Symbol('backendServiceProvider2');
+const localServiceProvider = Symbol('localServiceProvider');
 
 export const messagingFrontendModule = new ContainerModule(bind => {
-    bind(ElectronWebSocketConnectionProvider).toSelf().inSingletonScope();
-    bind(FrontendApplicationContribution).toService(ElectronWebSocketConnectionProvider);
-    bind(WebSocketConnectionProvider).toService(ElectronWebSocketConnectionProvider);
-    bind(ElectronLocalWebSocketConnectionProvider).toSelf().inSingletonScope();
-    bind(LocalWebSocketConnectionProvider).toDynamicValue(ctx => {
+    bind(ConnectionCloseService).toDynamicValue(ctx => WebSocketConnectionProvider.createProxy(ctx.container, connectionCloseServicePath)).inSingletonScope();
+    bind(ElectronWebSocketConnectionSource).toSelf().inSingletonScope();
+    bind(WebSocketConnectionSource).toService(ElectronWebSocketConnectionSource);
+    bind(ElectronIpcConnectionSource).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(ElectronIpcConnectionSource);
+    bind(ElectronLocalWebSocketConnectionSource).toSelf().inSingletonScope();
+    bind(backendServiceProvider).toDynamicValue(ctx => {
+        const container = ctx.container.createChild();
+        container.bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        container.bind(ConnectionSource).toService(ElectronWebSocketConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+
+    bind(localServiceProvider).toDynamicValue(ctx => {
+        const container = ctx.container.createChild();
+        container.bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        container.bind(ConnectionSource).toService(ElectronLocalWebSocketConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+
+    bind(ElectronMainConnectionProvider).toDynamicValue(ctx => {
+        const container = ctx.container.createChild();
+        container.bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        container.bind(ConnectionSource).toService(ElectronIpcConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+
+    bind(LocalConnectionProvider).toDynamicValue(ctx => {
         const localPort = getLocalPort();
         if (localPort) {
             // Return new web socket provider that connects to local app
-            return ctx.container.get(ElectronLocalWebSocketConnectionProvider);
+            return ctx.container.get(localServiceProvider);
         } else {
             // Return the usual web socket provider that already established its connection
             // That way we don't create a second socket connection
-            return ctx.container.get(WebSocketConnectionProvider);
+            return ctx.container.get(backendServiceProvider);
         }
     }).inSingletonScope();
-    bind(ElectronIpcConnectionProvider).toSelf().inSingletonScope();
+    bind(RemoteConnectionProvider).toService(backendServiceProvider);
+
+    bind(FrontendApplicationContribution).toService(ElectronWebSocketConnectionSource);
+    bind(ElectronFrontendIdProvider).toSelf().inSingletonScope();
+    bind(FrontendIdProvider).toService(ElectronFrontendIdProvider);
+    bind(WebSocketConnectionProvider).toSelf().inSingletonScope();
 });

package/src/electron-browser/messaging/{electron-ws-connection-provider.ts → electron-ws-connection-source.ts}

@@ -15,9 +15,8 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
-import { WebSocketConnectionProvider, WebSocketOptions } from '../../browser/messaging/ws-connection-provider';
 import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
-import { Channel } from '../../common';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 
 /**
  * Customized connection provider between the frontend and the backend in electron environment.
@@ -25,25 +24,15 @@ import { Channel } from '../../common';
  * once the electron-browser window is refreshed. Otherwise, backend resources are not disposed.
  */
 @injectable()
-export class ElectronWebSocketConnectionProvider extends WebSocketConnectionProvider implements FrontendApplicationContribution {
-
-    /**
-     * Do not try to reconnect when the frontend application is stopping. The browser is navigating away from this page.
-     */
-    protected stopping = false;
+export class ElectronWebSocketConnectionSource extends WebSocketConnectionSource implements FrontendApplicationContribution {
+    constructor() {
+        super();
+    }
 
     onStop(): void {
-        this.stopping = true;
         // Manually close the websocket connections `onStop`. Otherwise, the channels will be closed with 30 sec (`MessagingContribution#checkAliveTimeout`) delay.
         // https://github.com/eclipse-theia/theia/issues/6499
         // `1001` indicates that an endpoint is "going away", such as a server going down or a browser having navigated away from a page.
-        this.channelMultiplexer?.onUnderlyingChannelClose({ reason: 'The frontend is "going away"', code: 1001 });
+        this.socket.close();
     }
-
-    override async openChannel(path: string, handler: (channel: Channel) => void, options?: WebSocketOptions): Promise<void> {
-        if (!this.stopping) {
-            super.openChannel(path, handler, options);
-        }
-    }
-
 }

package/src/electron-browser/preload.ts

@@ -25,7 +25,8 @@ import {
     CHANNEL_ON_WINDOW_EVENT, CHANNEL_GET_ZOOM_LEVEL, CHANNEL_SET_ZOOM_LEVEL, CHANNEL_IS_FULL_SCREENABLE, CHANNEL_TOGGLE_FULL_SCREEN,
     CHANNEL_IS_FULL_SCREEN, CHANNEL_SET_MENU_BAR_VISIBLE, CHANNEL_REQUEST_CLOSE, CHANNEL_SET_TITLE_STYLE, CHANNEL_RESTART,
     CHANNEL_REQUEST_RELOAD, CHANNEL_APP_STATE_CHANGED, CHANNEL_SHOW_ITEM_IN_FOLDER, CHANNEL_READ_CLIPBOARD, CHANNEL_WRITE_CLIPBOARD,
-    CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR
+    CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR,
+    CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -65,6 +66,7 @@ function convertMenu(menu: MenuDto[] | undefined, handlerMap: Map<number, () =>
 }
 
 const api: TheiaCoreAPI = {
+    WindowMetadata: { webcontentId: 'none' },
     setMenuBarVisible: (visible: boolean, windowName?: string) => ipcRenderer.send(CHANNEL_SET_MENU_BAR_VISIBLE, visible, windowName),
     setMenu: (menu: MenuDto[] | undefined) => {
         commandHandlers.delete(mainMenuId);
@@ -119,6 +121,17 @@ const api: TheiaCoreAPI = {
     close: function (): void {
         ipcRenderer.send(CHANNEL_CLOSE);
     },
+
+    onAboutToClose(handler: () => void): Disposable {
+        const h = (event: Electron.IpcRendererEvent, replyChannel: string) => {
+            handler();
+            event.sender.send(replyChannel);
+        };
+
+        ipcRenderer.on(CHANNEL_ABOUT_TO_CLOSE, h);
+        return Disposable.create(() => ipcRenderer.off(CHANNEL_ABOUT_TO_CLOSE, h));
+    },
+
     onWindowEvent: function (event: WindowEvent, handler: () => void): Disposable {
         const h = (_event: unknown, evt: WindowEvent) => {
             if (event === evt) {
@@ -227,6 +240,7 @@ export function preload(): void {
             }
         }
     });
+    api.WindowMetadata.webcontentId = ipcRenderer.sendSync(CHANNEL_WC_METADATA);
 
     contextBridge.exposeInMainWorld('electronTheiaCore', api);
 }

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

@@ -21,7 +21,7 @@ import { FrontendApplicationContribution } from '../../browser/frontend-applicat
 import { ElectronClipboardService } from '../electron-clipboard-service';
 import { ClipboardService } from '../../browser/clipboard-service';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../../electron-common/electron-main-window-service';
-import { ElectronIpcConnectionProvider } from '../messaging/electron-ipc-connection-provider';
+import { ElectronIpcConnectionProvider } from '../messaging/electron-ipc-connection-source';
 import { bindWindowPreferences } from './electron-window-preferences';
 import { FrontendApplicationStateService } from '../../browser/frontend-application-state';
 import { ElectronFrontendApplicationStateService } from './electron-frontend-application-state';

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

@@ -19,6 +19,8 @@ import { NewWindowOptions, WindowSearchParams } 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 { ConnectionCloseService } from '../../common/messaging/connection-management';
+import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 
 @injectable()
 export class ElectronWindowService extends DefaultWindowService {
@@ -33,12 +35,18 @@ export class ElectronWindowService extends DefaultWindowService {
      */
     protected closeOnUnload: boolean = false;
 
+    @inject(FrontendIdProvider)
+    protected readonly frontendIdProvider: FrontendIdProvider;
+
     @inject(ElectronMainWindowService)
     protected readonly delegate: ElectronMainWindowService;
 
     @inject(ElectronWindowPreferences)
     protected readonly electronWindowPreferences: ElectronWindowPreferences;
 
+    @inject(ConnectionCloseService)
+    protected readonly connectionCloseService: ConnectionCloseService;
+
     override openNewWindow(url: string, { external }: NewWindowOptions = {}): undefined {
         this.delegate.openNewWindow(url, { external });
         return undefined;
@@ -56,6 +64,9 @@ export class ElectronWindowService extends DefaultWindowService {
                 this.updateWindowZoomLevel();
             }
         });
+        window.electronTheiaCore.onAboutToClose(() => {
+            this.connectionCloseService.markForClose(this.frontendIdProvider.getId());
+        });
     }
 
     protected override registerUnloadListeners(): void {

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

@@ -41,6 +41,9 @@ export type InternalMenuDto = Omit<MenuDto, 'execute' | 'submenu'> & {
 export type WindowEvent = 'maximize' | 'unmaximize' | 'focus';
 
 export interface TheiaCoreAPI {
+    WindowMetadata: {
+        webcontentId: string;
+    }
     getSecurityToken: () => string;
     attachSecurityToken: (endpoint: string) => Promise<void>;
 
@@ -63,6 +66,7 @@ export interface TheiaCoreAPI {
     unMaximize(): void;
     close(): void;
     onWindowEvent(event: WindowEvent, handler: () => void): Disposable;
+    onAboutToClose(handler: () => void): Disposable;
     setCloseRequestHandler(handler: (reason: StopReason) => Promise<boolean>): void;
 
     setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void;
@@ -96,6 +100,7 @@ declare global {
     }
 }
 
+export const CHANNEL_WC_METADATA = 'WebContentMetadata';
 export const CHANNEL_SET_MENU = 'SetMenu';
 export const CHANNEL_SET_MENU_BAR_VISIBLE = 'SetMenuBarVisible';
 export const CHANNEL_INVOKE_MENU = 'InvokeMenu';
@@ -117,6 +122,8 @@ export const CHANNEL_MINIMIZE = 'Minimize';
 export const CHANNEL_MAXIMIZE = 'Maximize';
 export const CHANNEL_IS_MAXIMIZED = 'IsMaximized';
 
+export const CHANNEL_ABOUT_TO_CLOSE = 'AboutToClose';
+
 export const CHANNEL_UNMAXIMIZE = 'UnMaximize';
 export const CHANNEL_ON_WINDOW_EVENT = 'OnWindowEvent';
 export const CHANNEL_TOGGLE_DEVTOOLS = 'ToggleDevtools';

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

@@ -51,7 +51,9 @@ import {
     CHANNEL_TOGGLE_FULL_SCREEN,
     CHANNEL_IS_MAXIMIZED,
     CHANNEL_REQUEST_SECONDARY_CLOSE,
-    CHANNEL_SET_BACKGROUND_COLOR
+    CHANNEL_SET_BACKGROUND_COLOR,
+    CHANNEL_WC_METADATA,
+    CHANNEL_ABOUT_TO_CLOSE
 } from '../electron-common/electron-api';
 import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
 import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
@@ -65,6 +67,10 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
     protected readonly openPopups = new Map<number, Menu>();
 
     onStart(application: ElectronMainApplication): MaybePromise<void> {
+        ipcMain.on(CHANNEL_WC_METADATA, event => {
+            event.returnValue = event.sender.id.toString();
+        });
+
         // electron security token
         ipcMain.on(CHANNEL_GET_SECURITY_TOKEN, event => {
             event.returnValue = this.electronSecurityToken.value;
@@ -254,6 +260,19 @@ export namespace TheiaRendererAPI {
         wc.send(CHANNEL_ON_WINDOW_EVENT, event);
     }
 
+    export function sendAboutToClose(wc: WebContents): Promise<void> {
+        return new Promise<void>(resolve => {
+            const channelNr = nextReplyChannel++;
+            const replyChannel = `aboutToClose${channelNr}`;
+            const l = createDisposableListener(ipcMain, replyChannel, e => {
+                l.dispose();
+                resolve();
+            });
+
+            wc.send(CHANNEL_ABOUT_TO_CLOSE, replyChannel);
+        });
+    }
+
     export function requestClose(wc: WebContents, stopReason: StopReason): Promise<boolean> {
         const channelNr = nextReplyChannel++;
         const confirmChannel = `confirm-${channelNr}`;