Aux window: support to restore aux windows and editors (fix #195887) (#201291)

Author: bpasero

src/vs/platform/auxiliaryWindow/electron-main/auxiliaryWindow.ts

@@ -6,6 +6,7 @@
 import { BrowserWindow, WebContents } from 'electron';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
+import { ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IStateService } from 'vs/platform/state/node/state';
 import { IBaseWindow } from 'vs/platform/window/electron-main/window';
@@ -33,7 +34,8 @@ export class AuxiliaryWindow extends BaseWindow implements IAuxiliaryWindow {
 		@IEnvironmentMainService environmentMainService: IEnvironmentMainService,
 		@ILogService private readonly logService: ILogService,
 		@IConfigurationService configurationService: IConfigurationService,
-		@IStateService stateService: IStateService
+		@IStateService stateService: IStateService,
+		@ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService
 	) {
 		super(configurationService, stateService, environmentMainService);
 
@@ -61,6 +63,9 @@ export class AuxiliaryWindow extends BaseWindow implements IAuxiliaryWindow {
 
 			// Disable Menu
 			window.setMenu(null);
+
+			// Lifecycle
+			this.lifecycleMainService.registerAuxWindow(this);
 		}
 	}
 }

src/vs/platform/lifecycle/electron-main/lifecycleMainService.ts

@@ -18,6 +18,7 @@ import { IStateService } from 'vs/platform/state/node/state';
 import { ICodeWindow, LoadReason, UnloadReason } from 'vs/platform/window/electron-main/window';
 import { ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vs/platform/workspace/common/workspace';
 import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
+import { IAuxiliaryWindow } from 'vs/platform/auxiliaryWindow/electron-main/auxiliaryWindow';
 
 export const ILifecycleMainService = createDecorator<ILifecycleMainService>('lifecycleMainService');
 
@@ -131,6 +132,11 @@ export interface ILifecycleMainService {
 	 */
 	registerWindow(window: ICodeWindow): void;
 
+	/**
+	 * Make a `IAuxiliaryWindow` known to the lifecycle main service.
+	 */
+	registerAuxWindow(auxWindow: IAuxiliaryWindow): void;
+
 	/**
 	 * Reload a window. All lifecycle event handlers are triggered.
 	 */
@@ -472,6 +478,34 @@ export class LifecycleMainService extends Disposable implements ILifecycleMainSe
 		});
 	}
 
+	registerAuxWindow(auxWindow: IAuxiliaryWindow): void {
+		const win = assertIsDefined(auxWindow.win);
+
+		win.on('close', e => {
+			this.trace(`Lifecycle#auxWindow.on('close') - window ID ${auxWindow.id}`);
+
+			if (this._quitRequested) {
+				this.trace(`Lifecycle#auxWindow.on('close') - preventDefault() because quit requested`);
+
+				// When quit is requested, Electron will close all
+				// auxiliary windows before closing the main windows.
+				// This prevents us from storing the auxiliary window
+				// state on shutdown and thus we prevent closing if
+				// quit is requested.
+				//
+				// Interestingly, this will not prevent the application
+				// from quitting because the auxiliary windows will still
+				// close once the owning window closes.
+
+				e.preventDefault();
+			}
+		});
+
+		win.on('closed', () => {
+			this.trace(`Lifecycle#auxWindow.on('closed') - window ID ${auxWindow.id}`);
+		});
+	}
+
 	async reload(window: ICodeWindow, cli?: NativeParsedArgs): Promise<void> {
 
 		// Only reload when the window has not vetoed this

src/vs/platform/test/electron-main/workbenchTestServices.ts

@@ -5,6 +5,7 @@
 
 import { Promises } from 'vs/base/common/async';
 import { Event, Emitter } from 'vs/base/common/event';
+import { IAuxiliaryWindow } from 'vs/platform/auxiliaryWindow/electron-main/auxiliaryWindow';
 import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
 import { ILifecycleMainService, IRelaunchHandler, LifecycleMainPhase, ShutdownEvent, ShutdownReason } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
 import { IStateService } from 'vs/platform/state/node/state';
@@ -41,6 +42,7 @@ export class TestLifecycleMainService implements ILifecycleMainService {
 	phase = LifecycleMainPhase.Ready;
 
 	registerWindow(window: ICodeWindow): void { }
+	registerAuxWindow(auxWindow: IAuxiliaryWindow): void { }
 	async reload(window: ICodeWindow, cli?: NativeParsedArgs): Promise<void> { }
 	async unload(window: ICodeWindow, reason: UnloadReason): Promise<boolean> { return true; }
 	setRelaunchHandler(handler: IRelaunchHandler): void { }

src/vs/workbench/api/browser/mainThreadEditorTabs.ts

@@ -70,7 +70,7 @@ export class MainThreadEditorTabs implements MainThreadEditorTabsShape {
 		this._dispoables.add(this._editorGroupsService.onDidRemoveGroup(() => this._createTabsModel()));
 
 		// Once everything is read go ahead and initialize the model
-		this._editorGroupsService.mainPart.whenReady.then(() => this._createTabsModel());
+		this._editorGroupsService.whenReady.then(() => this._createTabsModel());
 	}
 
 	dispose(): void {

src/vs/workbench/browser/actions/developerActions.ts

@@ -39,6 +39,7 @@ import { IUserDataProfileService } from 'vs/workbench/services/userDataProfile/c
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import product from 'vs/platform/product/common/product';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 
 class InspectContextKeysAction extends Action2 {
 
@@ -467,6 +468,7 @@ class RemoveLargeStorageEntriesAction extends Action2 {
 		const quickInputService = accessor.get(IQuickInputService);
 		const userDataProfileService = accessor.get(IUserDataProfileService);
 		const dialogService = accessor.get(IDialogService);
+		const environmentService = accessor.get(IEnvironmentService);
 
 		interface IStorageItem extends IQuickPickItem {
 			readonly key: string;
@@ -485,7 +487,7 @@ class RemoveLargeStorageEntriesAction extends Action2 {
 			for (const target of [StorageTarget.MACHINE, StorageTarget.USER]) {
 				for (const key of storageService.keys(scope, target)) {
 					const value = storageService.get(key, scope);
-					if (value && value.length > RemoveLargeStorageEntriesAction.SIZE_THRESHOLD) {
+					if (value && (!environmentService.isBuilt /* show all keys in dev */ || value.length > RemoveLargeStorageEntriesAction.SIZE_THRESHOLD)) {
 						items.push({
 							key,
 							scope,

src/vs/workbench/browser/contextkeys.ts

@@ -227,7 +227,7 @@ export class WorkbenchContextKeysHandler extends Disposable {
 	}
 
 	private registerListeners(): void {
-		this.editorGroupService.mainPart.whenReady.then(() => {
+		this.editorGroupService.whenReady.then(() => {
 			this.updateEditorAreaContextKeys();
 			this.updateEditorContextKeys();
 		});

src/vs/workbench/browser/layout.ts

@@ -333,7 +333,7 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 
 		// Wait to register these listeners after the editor group service
 		// is ready to avoid conflicts on startup
-		this.editorGroupService.mainPart.whenRestored.then(() => {
+		this.editorGroupService.whenRestored.then(() => {
 
 			// Restore main editor part on any editor change in main part
 			this._register(this.mainPartEditorService.onDidVisibleEditorsChange(showEditorIfHidden));
@@ -494,7 +494,7 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 		this.updateMenubarVisibility(!!skipLayout);
 
 		// Centered Layout
-		this.editorGroupService.mainPart.whenRestored.then(() => {
+		this.editorGroupService.whenRestored.then(() => {
 			this.centerMainEditorLayout(this.stateModel.getRuntimeValue(LayoutStateKeys.EDITOR_CENTERED), skipLayout);
 		});
 	}
@@ -781,7 +781,7 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 
 		// Empty workbench configured to open untitled file if empty
 		else if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY && this.configurationService.getValue('workbench.startupEditor') === 'newUntitledFile') {
-			if (this.editorGroupService.mainPart.hasRestorableState) {
+			if (this.editorGroupService.hasRestorableState) {
 				return []; // do not open any empty untitled file if we restored groups/editors from previous session
 			}
 
@@ -854,7 +854,7 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 			mark('code/willRestoreEditors');
 
 			// first ensure the editor part is ready
-			await this.editorGroupService.mainPart.whenReady;
+			await this.editorGroupService.whenReady;
 			mark('code/restoreEditors/editorGroupsReady');
 
 			// apply editor layout if any
@@ -910,7 +910,7 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 			layoutRestoredPromises.push(
 				Promise.all([
 					openEditorsPromise?.finally(() => mark('code/restoreEditors/editorsOpened')),
-					this.editorGroupService.mainPart.whenRestored.finally(() => mark('code/restoreEditors/editorGroupsRestored'))
+					this.editorGroupService.whenRestored.finally(() => mark('code/restoreEditors/editorGroupsRestored'))
 				]).finally(() => {
 					// the `code/didRestoreEditors` perf mark is specifically
 					// for when visible editors have resolved, so we only mark

src/vs/workbench/browser/part.ts

@@ -12,7 +12,7 @@ import { ISerializableView, IViewSize } from 'vs/base/browser/ui/grid/grid';
 import { Event, Emitter } from 'vs/base/common/event';
 import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';
 import { assertIsDefined } from 'vs/base/common/types';
-import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 
 export interface IPartOptions {
 	readonly hasTitle?: boolean;
@@ -187,7 +187,7 @@ export interface IMultiWindowPart {
 	readonly element: HTMLElement;
 }
 
-export abstract class MultiWindowParts<T extends IMultiWindowPart> extends Disposable {
+export abstract class MultiWindowParts<T extends IMultiWindowPart> extends Component {
 
 	protected readonly _parts = new Set<T>();
 	get parts() { return Array.from(this._parts); }

src/vs/workbench/browser/parts/editor/auxiliaryEditorPart.ts

@@ -15,7 +15,7 @@ import { IStorageService } from 'vs/platform/storage/common/storage';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
 import { getTitleBarStyle } from 'vs/platform/window/common/window';
 import { IEditorGroupView, IEditorPartsView } from 'vs/workbench/browser/parts/editor/editor';
-import { EditorPart } from 'vs/workbench/browser/parts/editor/editorPart';
+import { EditorPart, IEditorPartUIState } from 'vs/workbench/browser/parts/editor/editorPart';
 import { IAuxiliaryTitlebarPart } from 'vs/workbench/browser/parts/titlebar/titlebarPart';
 import { WindowTitle } from 'vs/workbench/browser/parts/titlebar/windowTitle';
 import { IAuxiliaryWindowOpenOptions, IAuxiliaryWindowService } from 'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService';
@@ -27,6 +27,16 @@ import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecy
 import { IStatusbarService } from 'vs/workbench/services/statusbar/browser/statusbar';
 import { ITitleService } from 'vs/workbench/services/title/browser/titleService';
 
+export interface IAuxiliaryEditorPartOpenOptions extends IAuxiliaryWindowOpenOptions {
+	readonly state?: IEditorPartUIState;
+}
+
+export interface ICreateAuxiliaryEditorPartResult {
+	readonly part: AuxiliaryEditorPartImpl;
+	readonly instantiationService: IInstantiationService;
+	readonly disposables: DisposableStore;
+}
+
 export class AuxiliaryEditorPart {
 
 	private static STATUS_BAR_VISIBILITY = 'workbench.statusBar.visible';
@@ -44,7 +54,7 @@ export class AuxiliaryEditorPart {
 	) {
 	}
 
-	async create(label: string, options?: IAuxiliaryWindowOpenOptions): Promise<{ readonly part: AuxiliaryEditorPartImpl; readonly instantiationService: IInstantiationService; readonly disposables: DisposableStore }> {
+	async create(label: string, options?: IAuxiliaryEditorPartOpenOptions): Promise<ICreateAuxiliaryEditorPartResult> {
 
 		function computeEditorPartHeightOffset(): number {
 			let editorPartHeightOffset = 0;
@@ -90,9 +100,9 @@ export class AuxiliaryEditorPart {
 		editorPartContainer.style.position = 'relative';
 		auxiliaryWindow.container.appendChild(editorPartContainer);
 
-		const editorPart = disposables.add(this.instantiationService.createInstance(AuxiliaryEditorPartImpl, auxiliaryWindow.window.vscodeWindowId, this.editorPartsView, label));
+		const editorPart = disposables.add(this.instantiationService.createInstance(AuxiliaryEditorPartImpl, auxiliaryWindow.window.vscodeWindowId, this.editorPartsView, options?.state, label));
 		disposables.add(this.editorPartsView.registerPart(editorPart));
-		editorPart.create(editorPartContainer, { restorePreviousState: false });
+		editorPart.create(editorPartContainer);
 
 		// Titlebar
 		let titlebarPart: IAuxiliaryTitlebarPart | undefined = undefined;
@@ -140,7 +150,7 @@ export class AuxiliaryEditorPart {
 
 		// Lifecycle
 		const editorCloseListener = disposables.add(Event.once(editorPart.onWillClose)(() => auxiliaryWindow.window.close()));
-		disposables.add(Event.once(auxiliaryWindow.onWillClose)(() => {
+		disposables.add(Event.once(auxiliaryWindow.onUnload)(() => {
 			if (disposables.isDisposed) {
 				return; // the close happened as part of an earlier dispose call
 			}
@@ -187,6 +197,7 @@ class AuxiliaryEditorPartImpl extends EditorPart implements IAuxiliaryEditorPart
 	constructor(
 		readonly windowId: number,
 		editorPartsView: IEditorPartsView,
+		private readonly state: IEditorPartUIState | undefined,
 		groupsLabel: string,
 		@IInstantiationService instantiationService: IInstantiationService,
 		@IThemeService themeService: IThemeService,
@@ -231,8 +242,12 @@ class AuxiliaryEditorPartImpl extends EditorPart implements IAuxiliaryEditorPart
 		this.doClose(false /* do not merge any groups to main part */);
 	}
 
+	protected override loadState(): IEditorPartUIState | undefined {
+		return this.state;
+	}
+
 	protected override saveState(): void {
-		return; // TODO support auxiliary editor state
+		return; // disabled, auxiliary editor part state is tracked outside
 	}
 
 	close(): void {

src/vs/workbench/browser/parts/editor/editorGroupView.ts

@@ -507,13 +507,17 @@ export class EditorGroupView extends Themable implements IEditorGroupView {
 
 		options.pinned = this.model.isPinned(activeEditor);	// preserve pinned state
 		options.sticky = this.model.isSticky(activeEditor);	// preserve sticky state
-		options.preserveFocus = true;						// handle focus after editor is opened
+		options.preserveFocus = true;						// handle focus after editor is restored
+
+		const internalOptions: IInternalEditorOpenOptions = {
+			preserveWindowOrder: true						// handle window order after editor is restored
+		};
 
 		const activeElement = getActiveElement();
 
 		// Show active editor (intentionally not using async to keep
 		// `restoreEditors` from executing in same stack)
-		return this.doShowEditor(activeEditor, { active: true, isNew: false /* restored */ }, options).then(() => {
+		return this.doShowEditor(activeEditor, { active: true, isNew: false /* restored */ }, options, internalOptions).then(() => {
 
 			// Set focused now if this is the active group and focus has
 			// not changed meanwhile. This prevents focus from being