Aux window: Main window editor hangs or is slow on aux window minimize (fix #197420) (#197433)

* Aux window: Main window editor hangs or is slow on aux window minimize (fix #197420)

* aux window - ensure a window id in all cases

* aux window - 💄

* aux window - 💄

* aux window - 💄

* aux window - 💄

* aux window - 💄

Author: bpasero

src/bootstrap-window.js

@@ -39,7 +39,7 @@
 	 * 	},
 	 * 	canModifyDOM?: (config: ISandboxConfiguration) => void,
 	 * 	beforeLoaderConfig?: (loaderConfig: object) => void,
-	 *  beforeRequire?: () => void
+	 *  beforeRequire?: (config: ISandboxConfiguration) => void
 	 * }} [options]
 	 */
 	async function load(modulePaths, resultCallback, options) {
@@ -143,7 +143,7 @@
 
 		// Signal before require()
 		if (typeof options?.beforeRequire === 'function') {
-			options.beforeRequire();
+			options.beforeRequire(configuration);
 		}
 
 		// Actually require the main module as specified

src/vs/base/browser/dom.ts

@@ -18,27 +18,36 @@ import * as platform from 'vs/base/common/platform';
 import { URI } from 'vs/base/common/uri';
 import { hash } from 'vs/base/common/hash';
 
-type WindowGlobal = Window & typeof globalThis;
+export type CodeWindow = Window & typeof globalThis & {
+	readonly vscodeWindowId: number;
+};
 
-interface IWindow {
-	readonly window: WindowGlobal;
+interface IRegisteredCodeWindow {
+	readonly window: CodeWindow;
 	readonly disposables: DisposableStore;
 }
 
-export const { registerWindow, getWindows, getWindowsCount, onDidRegisterWindow, onWillUnregisterWindow, onDidUnregisterWindow } = (function () {
-	const windows = new Map<WindowGlobal, IWindow>();
-	windows.set(window, { window, disposables: new DisposableStore() });
+export const { registerWindow, getWindows, getWindowsCount, getWindowId, onDidRegisterWindow, onWillUnregisterWindow, onDidUnregisterWindow } = (function () {
+	const windows = new Map<number, IRegisteredCodeWindow>();
+
+	const mainWindow = window as CodeWindow;
+	if (typeof mainWindow.vscodeWindowId !== 'number') {
+		Object.defineProperty(window, 'vscodeWindowId', {
+			get: () => -1
+		});
+	}
+	windows.set(mainWindow.vscodeWindowId, { window: mainWindow, disposables: new DisposableStore() });
 
-	const onDidRegisterWindow = new event.Emitter<IWindow>();
-	const onDidUnregisterWindow = new event.Emitter<WindowGlobal>();
-	const onWillUnregisterWindow = new event.Emitter<WindowGlobal>();
+	const onDidRegisterWindow = new event.Emitter<IRegisteredCodeWindow>();
+	const onDidUnregisterWindow = new event.Emitter<CodeWindow>();
+	const onWillUnregisterWindow = new event.Emitter<CodeWindow>();
 
 	return {
 		onDidRegisterWindow: onDidRegisterWindow.event,
 		onWillUnregisterWindow: onWillUnregisterWindow.event,
 		onDidUnregisterWindow: onDidUnregisterWindow.event,
-		registerWindow(window: WindowGlobal): IDisposable {
-			if (windows.has(window)) {
+		registerWindow(window: CodeWindow): IDisposable {
+			if (windows.has(window.vscodeWindowId)) {
 				return Disposable.None;
 			}
 
@@ -48,10 +57,10 @@ export const { registerWindow, getWindows, getWindowsCount, onDidRegisterWindow,
 				window,
 				disposables: disposables.add(new DisposableStore())
 			};
-			windows.set(window, registeredWindow);
+			windows.set(window.vscodeWindowId, registeredWindow);
 
 			disposables.add(toDisposable(() => {
-				windows.delete(window);
+				windows.delete(window.vscodeWindowId);
 				onDidUnregisterWindow.fire(window);
 			}));
 
@@ -63,11 +72,14 @@ export const { registerWindow, getWindows, getWindowsCount, onDidRegisterWindow,
 
 			return disposables;
 		},
-		getWindows(): Iterable<IWindow> {
+		getWindows(): Iterable<IRegisteredCodeWindow> {
 			return windows.values();
 		},
 		getWindowsCount(): number {
 			return windows.size;
+		},
+		getWindowId(targetWindow: Window): number {
+			return (targetWindow as CodeWindow).vscodeWindowId;
 		}
 	};
 })();
@@ -223,51 +235,65 @@ class AnimationFrameQueueItem implements IDisposable {
 	/**
 	 * The runners scheduled at the next animation frame
 	 */
-	let NEXT_QUEUE: AnimationFrameQueueItem[] = [];
+	const NEXT_QUEUE = new Map<number /* window ID */, AnimationFrameQueueItem[]>();
 	/**
 	 * The runners scheduled at the current animation frame
 	 */
-	let CURRENT_QUEUE: AnimationFrameQueueItem[] | null = null;
+	const CURRENT_QUEUE = new Map<number /* window ID */, AnimationFrameQueueItem[]>();
 	/**
 	 * A flag to keep track if the native requestAnimationFrame was already called
 	 */
-	let animFrameRequested = false;
+	const animFrameRequested = new Map<number /* window ID */, boolean>();
 	/**
 	 * A flag to indicate if currently handling a native requestAnimationFrame callback
 	 */
-	let inAnimationFrameRunner = false;
+	const inAnimationFrameRunner = new Map<number /* window ID */, boolean>();
 
-	const animationFrameRunner = () => {
-		animFrameRequested = false;
+	const animationFrameRunner = (targetWindowId: number) => {
+		animFrameRequested.set(targetWindowId, false);
 
-		CURRENT_QUEUE = NEXT_QUEUE;
-		NEXT_QUEUE = [];
+		const currentQueue = NEXT_QUEUE.get(targetWindowId) ?? [];
+		CURRENT_QUEUE.set(targetWindowId, currentQueue);
+		NEXT_QUEUE.set(targetWindowId, []);
 
-		inAnimationFrameRunner = true;
-		while (CURRENT_QUEUE.length > 0) {
-			CURRENT_QUEUE.sort(AnimationFrameQueueItem.sort);
-			const top = CURRENT_QUEUE.shift()!;
+		inAnimationFrameRunner.set(targetWindowId, true);
+		while (currentQueue.length > 0) {
+			currentQueue.sort(AnimationFrameQueueItem.sort);
+			const top = currentQueue.shift()!;
 			top.execute();
 		}
-		inAnimationFrameRunner = false;
+		inAnimationFrameRunner.set(targetWindowId, false);
 	};
 
 	scheduleAtNextAnimationFrame = (runner: () => void, targetWindow: Window, priority: number = 0) => {
+		const targetWindowId = getWindowId(targetWindow);
 		const item = new AnimationFrameQueueItem(runner, priority);
-		NEXT_QUEUE.push(item);
 
-		if (!animFrameRequested) {
-			animFrameRequested = true;
-			targetWindow.requestAnimationFrame(animationFrameRunner);
+		let nextQueue = NEXT_QUEUE.get(targetWindowId);
+		if (!nextQueue) {
+			nextQueue = [];
+			NEXT_QUEUE.set(targetWindowId, nextQueue);
+		}
+		nextQueue.push(item);
+
+		if (!animFrameRequested.get(targetWindowId)) {
+			animFrameRequested.set(targetWindowId, true);
+			targetWindow.requestAnimationFrame(() => animationFrameRunner(targetWindowId));
 		}
 
 		return item;
 	};
 
 	runAtThisOrScheduleAtNextAnimationFrame = (runner: () => void, targetWindow: Window, priority?: number) => {
-		if (inAnimationFrameRunner) {
+		const targetWindowId = getWindowId(targetWindow);
+		if (inAnimationFrameRunner.get(targetWindowId)) {
 			const item = new AnimationFrameQueueItem(runner, priority);
-			CURRENT_QUEUE!.push(item);
+			let currentQueue = CURRENT_QUEUE.get(targetWindowId);
+			if (!currentQueue) {
+				currentQueue = [];
+				CURRENT_QUEUE.set(targetWindowId, currentQueue);
+			}
+			currentQueue.push(item);
 			return item;
 		} else {
 			return scheduleAtNextAnimationFrame(runner, targetWindow, priority);
@@ -775,25 +801,25 @@ export function getActiveDocument(): Document {
 	return documents.find(document => document.hasFocus()) ?? document;
 }
 
-export function getActiveWindow(): WindowGlobal {
+export function getActiveWindow(): CodeWindow {
 	const document = getActiveDocument();
-	return document.defaultView?.window ?? window;
+	return (document.defaultView?.window ?? window) as CodeWindow;
 }
 
-export function getWindow(element: Node | undefined | null): WindowGlobal;
-export function getWindow(event: UIEvent | undefined | null): WindowGlobal;
-export function getWindow(e: unknown): WindowGlobal {
+export function getWindow(element: Node | undefined | null): CodeWindow;
+export function getWindow(event: UIEvent | undefined | null): CodeWindow;
+export function getWindow(e: unknown): CodeWindow {
 	const candidateNode = e as Node | undefined | null;
 	if (candidateNode?.ownerDocument?.defaultView) {
-		return candidateNode.ownerDocument.defaultView.window;
+		return candidateNode.ownerDocument.defaultView.window as CodeWindow;
 	}
 
 	const candidateEvent = e as UIEvent | undefined | null;
 	if (candidateEvent?.view) {
-		return candidateEvent.view.window;
+		return candidateEvent.view.window as CodeWindow;
 	}
 
-	return window;
+	return window as CodeWindow;
 }
 
 export function focusWindow(element: Node): void {

src/vs/code/electron-sandbox/workbench/workbench.js

@@ -47,9 +47,14 @@
 			beforeLoaderConfig: function (loaderConfig) {
 				loaderConfig.recordStats = true;
 			},
-			beforeRequire: function () {
+			beforeRequire: function (windowConfig) {
 				performance.mark('code/willLoadWorkbenchMain');
 
+				// Code windows have a `vscodeWindowId` property to identify them
+				Object.defineProperty(window, 'vscodeWindowId', {
+					get: () => windowConfig.windowId
+				});
+
 				// It looks like browsers only lazily enable
 				// the <canvas> element when needed. Since we
 				// leverage canvas elements in our code in many
@@ -72,6 +77,7 @@
 	/**
 	 * @typedef {import('../../../platform/window/common/window').INativeWindowConfiguration} INativeWindowConfiguration
 	 * @typedef {import('../../../platform/environment/common/argv').NativeParsedArgs} NativeParsedArgs
+	 * @typedef {import('../../../base/parts/sandbox/common/sandboxTypes').ISandboxConfiguration} ISandboxConfiguration
 	 *
 	 * @returns {{
 	 *   load: (
@@ -86,7 +92,7 @@
 	 * 		 },
 	 * 	     canModifyDOM?: (config: INativeWindowConfiguration & NativeParsedArgs) => void,
 	 * 	     beforeLoaderConfig?: (loaderConfig: object) => void,
-	 *       beforeRequire?: () => void
+	 *       beforeRequire?: (config: ISandboxConfiguration) => void
 	 *     }
 	 *   ) => Promise<unknown>
 	 * }}

src/vs/editor/browser/widget/diffEditor/utils.ts

@@ -144,7 +144,7 @@ export function animatedObservable(targetWindow: Window, base: IObservable<numbe
 	}, (reader, s) => {
 		/** @description update value */
 		if (animationFrame !== undefined) {
-			cancelAnimationFrame(animationFrame);
+			targetWindow.cancelAnimationFrame(animationFrame);
 			animationFrame = undefined;
 		}
 

src/vs/workbench/browser/layout.ts

@@ -47,12 +47,12 @@ import { IBannerService } from 'vs/workbench/services/banner/browser/bannerServi
 import { IPaneCompositePartService } from 'vs/workbench/services/panecomposite/browser/panecomposite';
 import { AuxiliaryBarPart } from 'vs/workbench/browser/parts/auxiliarybar/auxiliaryBarPart';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { IAuxiliaryWindowService, isAuxiliaryWindow } from 'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService';
+import { IAuxiliaryWindowService } from 'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService';
 
 //#region Layout Implementation
 
 interface ILayoutRuntimeState {
-	activeContainerId: 'main' | number /* window ID */;
+	activeContainerId: number;
 	fullscreen: boolean;
 	maximized: boolean;
 	hasFocus: boolean;
@@ -466,16 +466,10 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 		}
 	}
 
-	private getActiveContainerId(): 'main' | number {
+	private getActiveContainerId(): number {
 		const activeContainer = this.activeContainer;
-		if (activeContainer !== this.container) {
-			const containerWindow = getWindow(activeContainer);
-			if (isAuxiliaryWindow(containerWindow)) {
-				return containerWindow.vscodeWindowId;
-			}
-		}
 
-		return 'main';
+		return getWindow(activeContainer).vscodeWindowId;
 	}
 
 	private doUpdateLayoutConfiguration(skipLayout?: boolean): void {

src/vs/workbench/contrib/terminal/electron-sandbox/localTerminalBackend.ts

@@ -26,7 +26,7 @@ import * as terminalEnvironment from 'vs/workbench/contrib/terminal/common/termi
 import { IProductService } from 'vs/platform/product/common/productService';
 import { IEnvironmentVariableService } from 'vs/workbench/contrib/terminal/common/environmentVariable';
 import { BaseTerminalBackend } from 'vs/workbench/contrib/terminal/browser/baseTerminalBackend';
-import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-sandbox/environmentService';
+import { INativeHostService } from 'vs/platform/native/common/native';
 import { Client as MessagePortClient } from 'vs/base/parts/ipc/common/ipc.mp';
 import { acquirePort } from 'vs/base/parts/ipc/electron-sandbox/ipc.mp';
 import { getDelayedChannel, ProxyChannel } from 'vs/base/parts/ipc/common/ipc';
@@ -85,7 +85,7 @@ class LocalTerminalBackend extends BaseTerminalBackend implements ITerminalBacke
 		@ITerminalProfileResolverService private readonly _terminalProfileResolverService: ITerminalProfileResolverService,
 		@IEnvironmentVariableService private readonly _environmentVariableService: IEnvironmentVariableService,
 		@IHistoryService historyService: IHistoryService,
-		@INativeWorkbenchEnvironmentService private readonly _environmentService: INativeWorkbenchEnvironmentService,
+		@INativeHostService private readonly _nativeHostService: INativeHostService,
 		@IStatusbarService statusBarService: IStatusbarService,
 		@IRemoteAgentService private readonly _remoteAgentService: IRemoteAgentService,
 	) {
@@ -129,7 +129,7 @@ class LocalTerminalBackend extends BaseTerminalBackend implements ITerminalBacke
 			// _localPtyService, and one directly via message port _ptyHostDirectProxy. The former is
 			// used for pty host management messages, it would make sense in the future to use a
 			// separate interface/service for this one.
-			const client = new MessagePortClient(port, `window:${this._environmentService.window.id}`);
+			const client = new MessagePortClient(port, `window:${this._nativeHostService.windowId}`);
 			directProxyClientEventually.complete(client);
 			this._onPtyHostConnected.fire();
 

src/vs/workbench/electron-sandbox/actions/windowActions.ts

@@ -29,8 +29,6 @@ import { isMacintosh } from 'vs/base/common/platform';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { getActiveWindow } from 'vs/base/browser/dom';
-import { isAuxiliaryWindow } from 'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService';
-import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-sandbox/environmentService';
 import { IOpenedAuxiliaryWindow, IOpenedMainWindow, isOpenedAuxiliaryWindow } from 'vs/platform/window/common/window';
 
 export class CloseWindowAction extends Action2 {
@@ -63,12 +61,7 @@ export class CloseWindowAction extends Action2 {
 	override async run(accessor: ServicesAccessor): Promise<void> {
 		const nativeHostService = accessor.get(INativeHostService);
 
-		const window = getActiveWindow();
-		if (isAuxiliaryWindow(window)) {
-			return nativeHostService.closeWindowById(window.vscodeWindowId);
-		}
-
-		return nativeHostService.closeWindow();
+		return nativeHostService.closeWindowById(getActiveWindow().vscodeWindowId);
 	}
 }
 
@@ -217,13 +210,7 @@ abstract class BaseSwitchWindow extends Action2 {
 		const languageService = accessor.get(ILanguageService);
 		const nativeHostService = accessor.get(INativeHostService);
 
-		let currentWindowId: number;
-		const activeWindow = getActiveWindow();
-		if (isAuxiliaryWindow(activeWindow)) {
-			currentWindowId = activeWindow.vscodeWindowId;
-		} else {
-			currentWindowId = nativeHostService.windowId;
-		}
+		const currentWindowId = getActiveWindow().vscodeWindowId;
 
 		const windows = await nativeHostService.getWindows({ includeAuxiliaryWindows: true });
 
@@ -411,15 +398,8 @@ export class ExperimentalSplitWindowAction extends Action2 {
 		const editorService = accessor.get(IEditorService);
 		const editorGroupService = accessor.get(IEditorGroupsService);
 		const nativeHostService = accessor.get(INativeHostService);
-		const environmentService = accessor.get(INativeWorkbenchEnvironmentService);
 
-		let activeWindowId: number;
 		const activeWindow = getActiveWindow();
-		if (isAuxiliaryWindow(activeWindow)) {
-			activeWindowId = activeWindow.vscodeWindowId;
-		} else {
-			activeWindowId = environmentService.window.id;
-		}
 
 		// First position the active window which may involve
 		// leaving fullscreen mode and then split it.
@@ -428,7 +408,7 @@ export class ExperimentalSplitWindowAction extends Action2 {
 			y: 0,
 			width: activeWindow.screen.availWidth / 2,
 			height: activeWindow.screen.availHeight
-		}, { targetWindowId: activeWindowId });
+		}, { targetWindowId: activeWindow.vscodeWindowId });
 
 		// Then create a new window next to the active window
 		const auxiliaryEditorPart = await editorGroupService.createAuxiliaryEditorPart({