Merge from vscode c58aaab8a1cc22a7139b761166a0d4f37d41e998 (#7880)

* Merge from vscode c58aaab8a1cc22a7139b761166a0d4f37d41e998

* fix pipelines

* fix strict-null-checks

* add missing files

src/vs/platform/windows/common/windows.ts

@@ -65,6 +65,17 @@ export function isFileToOpen(uriToOpen: IWindowOpenable): uriToOpen is IFileToOp
 
 export type MenuBarVisibility = 'default' | 'visible' | 'toggle' | 'hidden' | 'compact';
 
+export function getMenuBarVisibility(configurationService: IConfigurationService, environment: IEnvironmentService, isExtensionDevelopment = environment.isExtensionDevelopment): MenuBarVisibility {
+	const titleBarStyle = getTitleBarStyle(configurationService, environment, isExtensionDevelopment);
+	const menuBarVisibility = configurationService.getValue<MenuBarVisibility>('window.menuBarVisibility');
+
+	if (titleBarStyle === 'native' && menuBarVisibility === 'compact') {
+		return 'default';
+	} else {
+		return menuBarVisibility;
+	}
+}
+
 export interface IWindowsConfiguration {
 	window: IWindowSettings;
 }

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

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { OpenContext, IWindowConfiguration, IWindowOpenable, IOpenEmptyWindowOptions } from 'vs/platform/windows/common/windows';
-import { INativeOpenDialogOptions } from 'vs/platform/dialogs/node/dialogs';
 import { ParsedArgs } from 'vs/platform/environment/common/environment';
 import { Event } from 'vs/base/common/event';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
@@ -13,6 +12,7 @@ import { IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
 import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
 import { URI } from 'vs/base/common/uri';
 import { Rectangle, BrowserWindow } from 'electron';
+import { IDisposable } from 'vs/base/common/lifecycle';
 
 export interface IWindowState {
 	width?: number;
@@ -30,10 +30,16 @@ export const enum WindowMode {
 	Fullscreen
 }
 
-export interface ICodeWindow {
+export interface ICodeWindow extends IDisposable {
+
+	readonly onClose: Event<void>;
+	readonly onDestroy: Event<void>;
+
+	readonly whenClosedOrLoaded: Promise<void>;
+
 	readonly id: number;
 	readonly win: BrowserWindow;
-	readonly config: IWindowConfiguration;
+	readonly config: IWindowConfiguration | undefined;
 
 	readonly openedFolderUri?: URI;
 	readonly openedWorkspace?: IWorkspaceIdentifier;
@@ -48,6 +54,9 @@ export interface ICodeWindow {
 
 	readonly isReady: boolean;
 	ready(): Promise<ICodeWindow>;
+	setReady(): void;
+
+	readonly hasHiddenTitleBarStyle: boolean;
 
 	addTabbedWindow(window: ICodeWindow): void;
 
@@ -62,20 +71,19 @@ export interface ICodeWindow {
 	send(channel: string, ...args: any[]): void;
 	sendWhenReady(channel: string, ...args: any[]): void;
 
+	readonly isFullScreen: boolean;
 	toggleFullScreen(): void;
-	isFullScreen(): boolean;
+
 	isMinimized(): boolean;
-	hasHiddenTitleBarStyle(): boolean;
+
 	setRepresentedFilename(name: string): void;
-	getRepresentedFilename(): string;
+	getRepresentedFilename(): string | undefined;
+
 	handleTitleDoubleClick(): void;
 
 	updateTouchBar(items: ISerializableCommandAction[][]): void;
 
-	setReady(): void;
 	serializeWindowState(): IWindowState;
-
-	dispose(): void;
 }
 
 export const IWindowsMainService = createDecorator<IWindowsMainService>('windowsMainService');
@@ -91,17 +99,11 @@ export interface IWindowsMainService {
 
 	readonly onWindowReady: Event<ICodeWindow>;
 	readonly onWindowsCountChanged: Event<IWindowsCountChangedEvent>;
-	readonly onWindowClose: Event<number>;
 
 	open(openConfig: IOpenConfiguration): ICodeWindow[];
 	openEmptyWindow(context: OpenContext, options?: IOpenEmptyWindowOptions): ICodeWindow[];
 	openExtensionDevelopmentHostWindow(extensionDevelopmentPath: string[], openConfig: IOpenConfiguration): ICodeWindow[];
 
-	pickFileFolderAndOpen(options: INativeOpenDialogOptions, win?: ICodeWindow): Promise<void>;
-	pickFolderAndOpen(options: INativeOpenDialogOptions, win?: ICodeWindow): Promise<void>;
-	pickFileAndOpen(options: INativeOpenDialogOptions, win?: ICodeWindow): Promise<void>;
-	pickWorkspaceAndOpen(options: INativeOpenDialogOptions, win?: ICodeWindow): Promise<void>;
-
 	sendToFocused(channel: string, ...args: any[]): void;
 	sendToAll(channel: string, payload: any, windowIdsToIgnore?: number[]): void;
 
@@ -110,11 +112,6 @@ export interface IWindowsMainService {
 	getWindowById(windowId: number): ICodeWindow | undefined;
 	getWindows(): ICodeWindow[];
 	getWindowCount(): number;
-
-	waitForWindowCloseOrLoad(windowId: number): Promise<void>;
-	reload(win: ICodeWindow, cli?: ParsedArgs): void;
-	closeWorkspace(win: ICodeWindow): void;
-	quit(): void;
 }
 
 export interface IOpenConfiguration {

src/vs/platform/windows/electron-main/windowsStateStorage.ts

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IWindowState as IWindowUIState } from 'vs/platform/windows/electron-main/windows';
+import { IWindowState, IWindowsState } from 'vs/platform/windows/electron-main/windowsMainService';
+
+export type WindowsStateStorageData = object;
+
+interface ISerializedWindowsState {
+	lastActiveWindow?: ISerializedWindowState;
+	lastPluginDevelopmentHostWindow?: ISerializedWindowState;
+	openedWindows: ISerializedWindowState[];
+}
+
+interface ISerializedWindowState {
+	workspaceIdentifier?: { id: string; configURIPath: string };
+	folder?: string;
+	backupPath?: string;
+	remoteAuthority?: string;
+	uiState: IWindowUIState;
+
+	// deprecated
+	folderUri?: UriComponents;
+	folderPath?: string;
+	workspace?: { id: string; configPath: string };
+}
+
+export function restoreWindowsState(data: WindowsStateStorageData | undefined): IWindowsState {
+	const result: IWindowsState = { openedWindows: [] };
+	const windowsState = data as ISerializedWindowsState || { openedWindows: [] };
+
+	if (windowsState.lastActiveWindow) {
+		result.lastActiveWindow = restoreWindowState(windowsState.lastActiveWindow);
+	}
+
+	if (windowsState.lastPluginDevelopmentHostWindow) {
+		result.lastPluginDevelopmentHostWindow = restoreWindowState(windowsState.lastPluginDevelopmentHostWindow);
+	}
+
+	if (Array.isArray(windowsState.openedWindows)) {
+		result.openedWindows = windowsState.openedWindows.map(windowState => restoreWindowState(windowState));
+	}
+
+	return result;
+}
+
+function restoreWindowState(windowState: ISerializedWindowState): IWindowState {
+	const result: IWindowState = { uiState: windowState.uiState };
+	if (windowState.backupPath) {
+		result.backupPath = windowState.backupPath;
+	}
+
+	if (windowState.remoteAuthority) {
+		result.remoteAuthority = windowState.remoteAuthority;
+	}
+
+	if (windowState.folder) {
+		result.folderUri = URI.parse(windowState.folder);
+	} else if (windowState.folderUri) {
+		result.folderUri = URI.revive(windowState.folderUri);
+	} else if (windowState.folderPath) {
+		result.folderUri = URI.file(windowState.folderPath);
+	}
+
+	if (windowState.workspaceIdentifier) {
+		result.workspace = { id: windowState.workspaceIdentifier.id, configPath: URI.parse(windowState.workspaceIdentifier.configURIPath) };
+	} else if (windowState.workspace) {
+		result.workspace = { id: windowState.workspace.id, configPath: URI.file(windowState.workspace.configPath) };
+	}
+
+	return result;
+}
+
+export function getWindowsStateStoreData(windowsState: IWindowsState): WindowsStateStorageData {
+	return {
+		lastActiveWindow: windowsState.lastActiveWindow && serializeWindowState(windowsState.lastActiveWindow),
+		lastPluginDevelopmentHostWindow: windowsState.lastPluginDevelopmentHostWindow && serializeWindowState(windowsState.lastPluginDevelopmentHostWindow),
+		openedWindows: windowsState.openedWindows.map(ws => serializeWindowState(ws))
+	};
+}
+
+function serializeWindowState(windowState: IWindowState): ISerializedWindowState {
+	return {
+		workspaceIdentifier: windowState.workspace && { id: windowState.workspace.id, configURIPath: windowState.workspace.configPath.toString() },
+		folder: windowState.folderUri && windowState.folderUri.toString(),
+		backupPath: windowState.backupPath,
+		remoteAuthority: windowState.remoteAuthority,
+		uiState: windowState.uiState
+	};
+}

src/vs/platform/windows/node/window.ts

@@ -111,7 +111,7 @@ export function findWindowOnExtensionDevelopmentPath<W extends IWindowContext>(w
 	for (const window of windows) {
 		// match on extension development path. The path can be one or more paths or uri strings, using paths.isEqual is not 100% correct but good enough
 		const currPaths = window.extensionDevelopmentPath;
-		if (currPaths && currPaths.some(p => matches(p))) {
+		if (currPaths?.some(p => matches(p))) {
 			return window;
 		}
 	}