Merge VS Code 1.21 source code (#1067)

* Initial VS Code 1.21 file copy with patches

* A few more merges

* Post npm install

* Fix batch of build breaks

* Fix more build breaks

* Fix more build errors

* Fix more build breaks

* Runtime fixes 1

* Get connection dialog working with some todos

* Fix a few packaging issues

* Copy several node_modules to package build to fix loader issues

* Fix breaks from master

* A few more fixes

* Make tests pass

* First pass of license header updates

* Second pass of license header updates

* Fix restore dialog issues

* Remove add additional themes menu items

* fix select box issues where the list doesn't show up

* formatting

* Fix editor dispose issue

* Copy over node modules to correct location on all platforms

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

@@ -5,13 +5,15 @@
 
 'use strict';
 
+import * as nls from 'vs/nls';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { assign } from 'vs/base/common/objects';
 import URI from 'vs/base/common/uri';
-import { IWindowsService, OpenContext, INativeOpenDialogOptions, IEnterWorkspaceResult } from 'vs/platform/windows/common/windows';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { shell, crashReporter, app, Menu } from 'electron';
+import product from 'vs/platform/node/product';
+import { IWindowsService, OpenContext, INativeOpenDialogOptions, IEnterWorkspaceResult, IMessageBoxResult } from 'vs/platform/windows/common/windows';
+import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
+import { shell, crashReporter, app, Menu, clipboard } from 'electron';
 import Event, { chain, fromNodeEventEmitter } from 'vs/base/common/event';
 import { IURLService } from 'vs/platform/url/common/url';
 import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
@@ -19,6 +21,10 @@ import { IWindowsMainService, ISharedProcess } from 'vs/platform/windows/electro
 import { IHistoryMainService, IRecentlyOpened } from 'vs/platform/history/common/history';
 import { IWorkspaceIdentifier, IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
 import { ICommandAction } from 'vs/platform/actions/common/actions';
+import { Schemas } from 'vs/base/common/network';
+import { mnemonicButtonLabel } from 'vs/base/common/labels';
+import { isWindows } from 'vs/base/common/platform';
+import { ILogService } from '../../log/common/log';
 
 export class WindowsService implements IWindowsService, IDisposable {
 
@@ -36,11 +42,12 @@ export class WindowsService implements IWindowsService, IDisposable {
 		@IEnvironmentService private environmentService: IEnvironmentService,
 		@IURLService urlService: IURLService,
 		@ILifecycleService private lifecycleService: ILifecycleService,
-		@IHistoryMainService private historyService: IHistoryMainService
+		@IHistoryMainService private historyService: IHistoryMainService,
+		@ILogService private logService: ILogService
 	) {
 		// Catch file URLs
 		chain(urlService.onOpenURL)
-			.filter(uri => uri.authority === 'file' && !!uri.path)
+			.filter(uri => uri.authority === Schemas.file && !!uri.path)
 			.map(uri => URI.file(uri.fsPath))
 			.on(this.openFileForURI, this, this.disposables);
 
@@ -52,40 +59,67 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.logService.trace('windowsService#pickFileFolderAndOpen');
 		this.windowsMainService.pickFileFolderAndOpen(options);
 
 		return TPromise.as(null);
 	}
 
 	pickFileAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.logService.trace('windowsService#pickFileAndOpen');
 		this.windowsMainService.pickFileAndOpen(options);
 
 		return TPromise.as(null);
 	}
 
 	pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.logService.trace('windowsService#pickFolderAndOpen');
 		this.windowsMainService.pickFolderAndOpen(options);
 
 		return TPromise.as(null);
 	}
 
 	pickWorkspaceAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.logService.trace('windowsService#pickWorkspaceAndOpen');
 		this.windowsMainService.pickWorkspaceAndOpen(options);
 
 		return TPromise.as(null);
 	}
 
-	reloadWindow(windowId: number): TPromise<void> {
+	showMessageBox(windowId: number, options: Electron.MessageBoxOptions): TPromise<IMessageBoxResult> {
+		this.logService.trace('windowsService#showMessageBox', windowId);
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		return this.windowsMainService.showMessageBox(options, codeWindow);
+	}
+
+	showSaveDialog(windowId: number, options: Electron.SaveDialogOptions): TPromise<string> {
+		this.logService.trace('windowsService#showSaveDialog', windowId);
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		return this.windowsMainService.showSaveDialog(options, codeWindow);
+	}
+
+	showOpenDialog(windowId: number, options: Electron.OpenDialogOptions): TPromise<string[]> {
+		this.logService.trace('windowsService#showOpenDialog', windowId);
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		return this.windowsMainService.showOpenDialog(options, codeWindow);
+	}
+
+	reloadWindow(windowId: number, args: ParsedArgs): TPromise<void> {
+		this.logService.trace('windowsService#reloadWindow', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
-			this.windowsMainService.reload(codeWindow);
+			this.windowsMainService.reload(codeWindow, args);
 		}
 
 		return TPromise.as(null);
 	}
 
 	openDevTools(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#openDevTools', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -96,6 +130,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	toggleDevTools(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#toggleDevTools', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -111,6 +146,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	updateTouchBar(windowId: number, items: ICommandAction[][]): TPromise<void> {
+		this.logService.trace('windowsService#updateTouchBar', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -121,6 +157,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	closeWorkspace(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#closeWorkspace', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -131,6 +168,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	createAndEnterWorkspace(windowId: number, folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult> {
+		this.logService.trace('windowsService#createAndEnterWorkspace', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -141,6 +179,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	saveAndEnterWorkspace(windowId: number, path: string): TPromise<IEnterWorkspaceResult> {
+		this.logService.trace('windowsService#saveAndEnterWorkspace', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -151,6 +190,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	toggleFullScreen(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#toggleFullScreen', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -161,6 +201,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	setRepresentedFilename(windowId: number, fileName: string): TPromise<void> {
+		this.logService.trace('windowsService#setRepresentedFilename', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -171,24 +212,28 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	addRecentlyOpened(files: string[]): TPromise<void> {
+		this.logService.trace('windowsService#addRecentlyOpened');
 		this.historyService.addRecentlyOpened(void 0, files);
 
 		return TPromise.as(null);
 	}
 
 	removeFromRecentlyOpened(paths: string[]): TPromise<void> {
+		this.logService.trace('windowsService#removeFromRecentlyOpened');
 		this.historyService.removeFromRecentlyOpened(paths);
 
 		return TPromise.as(null);
 	}
 
 	clearRecentlyOpened(): TPromise<void> {
+		this.logService.trace('windowsService#clearRecentlyOpened');
 		this.historyService.clearRecentlyOpened();
 
 		return TPromise.as(null);
 	}
 
 	getRecentlyOpened(windowId: number): TPromise<IRecentlyOpened> {
+		this.logService.trace('windowsService#getRecentlyOpened', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -199,36 +244,42 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	showPreviousWindowTab(): TPromise<void> {
+		this.logService.trace('windowsService#showPreviousWindowTab');
 		Menu.sendActionToFirstResponder('selectPreviousTab:');
 
 		return TPromise.as(void 0);
 	}
 
 	showNextWindowTab(): TPromise<void> {
+		this.logService.trace('windowsService#showNextWindowTab');
 		Menu.sendActionToFirstResponder('selectNextTab:');
 
 		return TPromise.as(void 0);
 	}
 
 	moveWindowTabToNewWindow(): TPromise<void> {
+		this.logService.trace('windowsService#moveWindowTabToNewWindow');
 		Menu.sendActionToFirstResponder('moveTabToNewWindow:');
 
 		return TPromise.as(void 0);
 	}
 
 	mergeAllWindowTabs(): TPromise<void> {
+		this.logService.trace('windowsService#mergeAllWindowTabs');
 		Menu.sendActionToFirstResponder('mergeAllWindows:');
 
 		return TPromise.as(void 0);
 	}
 
 	toggleWindowTabsBar(): TPromise<void> {
+		this.logService.trace('windowsService#toggleWindowTabsBar');
 		Menu.sendActionToFirstResponder('toggleTabBar:');
 
 		return TPromise.as(void 0);
 	}
 
 	focusWindow(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#focusWindow', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -239,6 +290,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	closeWindow(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#closeWindow', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -249,6 +301,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	isFocused(windowId: number): TPromise<boolean> {
+		this.logService.trace('windowsService#isFocused', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -259,6 +312,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	isMaximized(windowId: number): TPromise<boolean> {
+		this.logService.trace('windowsService#isMaximized', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -269,6 +323,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	maximizeWindow(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#maximizeWindow', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -279,6 +334,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	unmaximizeWindow(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#unmaximizeWindow', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -289,6 +345,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	onWindowTitleDoubleClick(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#onWindowTitleDoubleClick', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -299,6 +356,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	setDocumentEdited(windowId: number, flag: boolean): TPromise<void> {
+		this.logService.trace('windowsService#setDocumentEdited', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow && codeWindow.win.isDocumentEdited() !== flag) {
@@ -309,6 +367,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }): TPromise<void> {
+		this.logService.trace('windowsService#openWindow');
 		if (!paths || !paths.length) {
 			return TPromise.as(null);
 		}
@@ -326,11 +385,13 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	openNewWindow(): TPromise<void> {
+		this.logService.trace('windowsService#openNewWindow');
 		this.windowsMainService.openNewWindow(OpenContext.API);
 		return TPromise.as(null);
 	}
 
 	showWindow(windowId: number): TPromise<void> {
+		this.logService.trace('windowsService#showWindow', windowId);
 		const codeWindow = this.windowsMainService.getWindowById(windowId);
 
 		if (codeWindow) {
@@ -341,6 +402,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]> {
+		this.logService.trace('windowsService#getWindows');
 		const windows = this.windowsMainService.getWindows();
 		const result = windows.map(w => ({ id: w.id, workspace: w.openedWorkspace, openedFolderPath: w.openedFolderPath, title: w.win.getTitle(), filename: w.getRepresentedFilename() }));
 
@@ -348,6 +410,7 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	getWindowCount(): TPromise<number> {
+		this.logService.trace('windowsService#getWindowCount');
 		return TPromise.as(this.windowsMainService.getWindows().length);
 	}
 
@@ -357,39 +420,82 @@ export class WindowsService implements IWindowsService, IDisposable {
 	}
 
 	showItemInFolder(path: string): TPromise<void> {
+		this.logService.trace('windowsService#showItemInFolder');
 		shell.showItemInFolder(path);
 		return TPromise.as(null);
 	}
 
 	openExternal(url: string): TPromise<boolean> {
+		this.logService.trace('windowsService#openExternal');
 		return TPromise.as(shell.openExternal(url));
 	}
 
 	startCrashReporter(config: Electron.CrashReporterStartOptions): TPromise<void> {
+		this.logService.trace('windowsService#startCrashReporter');
 		crashReporter.start(config);
 		return TPromise.as(null);
 	}
 
 	quit(): TPromise<void> {
+		this.logService.trace('windowsService#quit');
 		this.windowsMainService.quit();
 		return TPromise.as(null);
 	}
 
 	relaunch(options: { addArgs?: string[], removeArgs?: string[] }): TPromise<void> {
+		this.logService.trace('windowsService#relaunch');
 		this.lifecycleService.relaunch(options);
 
 		return TPromise.as(null);
 	}
 
 	whenSharedProcessReady(): TPromise<void> {
+		this.logService.trace('windowsService#whenSharedProcessReady');
 		return this.sharedProcess.whenReady();
 	}
 
 	toggleSharedProcess(): TPromise<void> {
+		this.logService.trace('windowsService#toggleSharedProcess');
 		this.sharedProcess.toggle();
 		return TPromise.as(null);
 	}
 
+	openAboutDialog(): TPromise<void> {
+		this.logService.trace('windowsService#openAboutDialog');
+		const lastActiveWindow = this.windowsMainService.getFocusedWindow() || this.windowsMainService.getLastActiveWindow();
+
+		const detail = nls.localize('aboutDetail',
+			"Version {0}\nCommit {1}\nDate {2}\nShell {3}\nRenderer {4}\nNode {5}\nArchitecture {6}",
+			app.getVersion(),
+			product.commit || 'Unknown',
+			product.date || 'Unknown',
+			process.versions['electron'],
+			process.versions['chrome'],
+			process.versions['node'],
+			process.arch
+		);
+
+		const buttons = [nls.localize('okButton', "OK")];
+		if (isWindows) {
+			buttons.push(mnemonicButtonLabel(nls.localize({ key: 'copy', comment: ['&& denotes a mnemonic'] }, "&&Copy"))); // https://github.com/Microsoft/vscode/issues/37608
+		}
+
+		this.windowsMainService.showMessageBox({
+			title: product.nameLong,
+			type: 'info',
+			message: product.nameLong,
+			detail: `\n${detail}`,
+			buttons,
+			noLink: true
+		}, lastActiveWindow).then(result => {
+			if (isWindows && result.button === 1) {
+				clipboard.writeText(detail);
+			}
+		});
+
+		return TPromise.as(null);
+	}
+
 	private openFileForURI(uri: URI): TPromise<void> {
 		const cli = assign(Object.create(null), this.environmentService.args, { goto: true });
 		const pathsToOpen = [uri.fsPath];