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/code/electron-browser/sharedProcess/contrib/contributions.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { NodeCachedDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/nodeCachedDataCleaner';
+import { LanguagePackCachedDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/languagePackCachedDataCleaner';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { IDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
+
+export function createSharedProcessContributions(service: IInstantiationService): IDisposable {
+	return combinedDisposable([
+		service.createInstance(NodeCachedDataCleaner),
+		service.createInstance(LanguagePackCachedDataCleaner)
+	]);
+}

src/vs/code/electron-browser/sharedProcess/contrib/languagePackCachedDataCleaner.ts

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as path from 'path';
+import * as pfs from 'vs/base/node/pfs';
+
+import { IStringDictionary } from 'vs/base/common/collections';
+import product from 'vs/platform/node/product';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+
+interface ExtensionEntry {
+	version: string;
+	extensionIdentifier: {
+		id: string;
+		uuid: string;
+	};
+}
+
+interface LanguagePackEntry {
+	hash: string;
+	extensions: ExtensionEntry[];
+}
+
+interface LanguagePackFile {
+	[locale: string]: LanguagePackEntry;
+}
+
+export class LanguagePackCachedDataCleaner {
+
+	private _disposables: IDisposable[] = [];
+
+	constructor(
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+		@ILogService private readonly _logService: ILogService
+	) {
+		// We have no Language pack support for dev version (run from source)
+		// So only cleanup when we have a build version.
+		if (this._environmentService.isBuilt) {
+			this._manageCachedDataSoon();
+		}
+	}
+
+	dispose(): void {
+		this._disposables = dispose(this._disposables);
+	}
+
+	private _manageCachedDataSoon(): void {
+		let handle = setTimeout(async () => {
+			handle = undefined;
+			this._logService.info('Starting to clean up unused language packs.');
+			const maxAge = product.nameLong.indexOf('Insiders') >= 0
+				? 1000 * 60 * 60 * 24 * 7 // roughly 1 week
+				: 1000 * 60 * 60 * 24 * 30 * 3; // roughly 3 months
+			try {
+				let installed: IStringDictionary<boolean> = Object.create(null);
+				const metaData: LanguagePackFile = JSON.parse(await pfs.readFile(path.join(this._environmentService.userDataPath, 'languagepacks.json'), 'utf8'));
+				for (let locale of Object.keys(metaData)) {
+					let entry = metaData[locale];
+					installed[`${entry.hash}.${locale}`] = true;
+				}
+				// Cleanup entries for language packs that aren't installed anymore
+				const cacheDir = path.join(this._environmentService.userDataPath, 'clp');
+				for (let entry of await pfs.readdir(cacheDir)) {
+					if (installed[entry]) {
+						this._logService.info(`Skipping directory ${entry}. Language pack still in use`);
+						continue;
+					}
+					this._logService.info('Removing unused language pack:', entry);
+					await pfs.rimraf(path.join(cacheDir, entry));
+				}
+
+				const now = Date.now();
+				for (let packEntry of Object.keys(installed)) {
+					const folder = path.join(cacheDir, packEntry);
+					for (let entry of await pfs.readdir(folder)) {
+						if (entry === 'tcf.json') {
+							continue;
+						}
+						const candidate = path.join(folder, entry);
+						const stat = await pfs.stat(candidate);
+						if (stat.isDirectory()) {
+							const diff = now - stat.mtime.getTime();
+							if (diff > maxAge) {
+								this._logService.info('Removing language pack cache entry: ', path.join(packEntry, entry));
+								await pfs.rimraf(candidate);
+							}
+						}
+					}
+				}
+			} catch (error) {
+				onUnexpectedError(error);
+			}
+		}, 40 * 1000);
+
+		this._disposables.push({
+			dispose() {
+				if (handle !== void 0) {
+					clearTimeout(handle);
+				}
+			}
+		});
+	}
+}

src/vs/code/electron-browser/sharedProcess/contrib/nodeCachedDataCleaner.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { join, basename, dirname } from 'path';
+import { readdir, rimraf, stat } from 'vs/base/node/pfs';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import product from 'vs/platform/node/product';
+
+export class NodeCachedDataCleaner {
+
+	private static readonly _DataMaxAge = product.nameLong.indexOf('Insiders') >= 0
+		? 1000 * 60 * 60 * 24 * 7 // roughly 1 week
+		: 1000 * 60 * 60 * 24 * 30 * 3; // roughly 3 months
+
+	private _disposables: IDisposable[] = [];
+
+	constructor(
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService
+	) {
+		this._manageCachedDataSoon();
+	}
+
+	dispose(): void {
+		this._disposables = dispose(this._disposables);
+	}
+
+	private _manageCachedDataSoon(): void {
+		// Cached data is stored as user data and we run a cleanup task everytime
+		// the editor starts. The strategy is to delete all files that are older than
+		// 3 months (1 week respectively)
+		if (!this._environmentService.nodeCachedDataDir) {
+			return;
+		}
+
+		// The folder which contains folders of cached data. Each of these folder is per
+		// version
+		const nodeCachedDataRootDir = dirname(this._environmentService.nodeCachedDataDir);
+		const nodeCachedDataCurrent = basename(this._environmentService.nodeCachedDataDir);
+
+		let handle = setTimeout(() => {
+			handle = undefined;
+
+			readdir(nodeCachedDataRootDir).then(entries => {
+
+				const now = Date.now();
+				const deletes: TPromise<any>[] = [];
+
+				entries.forEach(entry => {
+					// name check
+					// * not the current cached data folder
+					if (entry !== nodeCachedDataCurrent) {
+
+						const path = join(nodeCachedDataRootDir, entry);
+						deletes.push(stat(path).then(stats => {
+							// stat check
+							// * only directories
+							// * only when old enough
+							if (stats.isDirectory()) {
+								const diff = now - stats.mtime.getTime();
+								if (diff > NodeCachedDataCleaner._DataMaxAge) {
+									return rimraf(path);
+								}
+							}
+							return undefined;
+						}));
+					}
+				});
+
+				return TPromise.join(deletes);
+
+			}).done(undefined, onUnexpectedError);
+
+		}, 30 * 1000);
+
+		this._disposables.push({
+			dispose() { clearTimeout(handle); }
+		});
+	}
+}

src/vs/code/electron-browser/sharedProcess/sharedProcess.html

@@ -0,0 +1,17 @@
+<!-- Copyright (C) Microsoft Corporation. All rights reserved. -->
+<!DOCTYPE html>
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'self'; connect-src 'self' https:;">
+</head>
+
+<body aria-label="">
+	Shared Process
+</body>
+
+<!-- Startup via sharedProcess.js -->
+<script src="sharedProcess.js"></script>
+
+</html>

src/vs/code/electron-browser/sharedProcess/sharedProcess.js

@@ -0,0 +1,161 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function assign(destination, source) {
+	return Object.keys(source)
+		.reduce(function (r, key) { r[key] = source[key]; return r; }, destination);
+}
+
+function parseURLQueryArgs() {
+	const search = window.location.search || '';
+
+	return search.split(/[?&]/)
+		.filter(function (param) { return !!param; })
+		.map(function (param) { return param.split('='); })
+		.filter(function (param) { return param.length === 2; })
+		.reduce(function (r, param) { r[param[0]] = decodeURIComponent(param[1]); return r; }, {});
+}
+
+function createScript(src, onload) {
+	const script = document.createElement('script');
+	script.src = src;
+	script.addEventListener('load', onload);
+
+	const head = document.getElementsByTagName('head')[0];
+	head.insertBefore(script, head.lastChild);
+}
+
+function uriFromPath(_path) {
+	var pathName = path.resolve(_path).replace(/\\/g, '/');
+	if (pathName.length > 0 && pathName.charAt(0) !== '/') {
+		pathName = '/' + pathName;
+	}
+
+	return encodeURI('file://' + pathName);
+}
+
+function readFile(file) {
+	return new Promise(function(resolve, reject) {
+		fs.readFile(file, 'utf8', function(err, data) {
+			if (err) {
+				reject(err);
+				return;
+			}
+			resolve(data);
+		});
+	});
+}
+
+function main() {
+	const args = parseURLQueryArgs();
+	const configuration = JSON.parse(args['config'] || '{}') || {};
+
+	//#region Add support for using node_modules.asar
+	(function () {
+		const path = require('path');
+		const Module = require('module');
+		let NODE_MODULES_PATH = path.join(configuration.appRoot, 'node_modules');
+		if (/[a-z]\:/.test(NODE_MODULES_PATH)) {
+			// Make drive letter uppercase
+			NODE_MODULES_PATH = NODE_MODULES_PATH.charAt(0).toUpperCase() + NODE_MODULES_PATH.substr(1);
+		}
+		const NODE_MODULES_ASAR_PATH = NODE_MODULES_PATH + '.asar';
+
+		const originalResolveLookupPaths = Module._resolveLookupPaths;
+		Module._resolveLookupPaths = function (request, parent) {
+			const result = originalResolveLookupPaths(request, parent);
+
+			const paths = result[1];
+			for (let i = 0, len = paths.length; i < len; i++) {
+				if (paths[i] === NODE_MODULES_PATH) {
+					paths.splice(i, 0, NODE_MODULES_ASAR_PATH);
+					break;
+				}
+			}
+
+			return result;
+		};
+	})();
+	//#endregion
+
+	// Correctly inherit the parent's environment
+	assign(process.env, configuration.userEnv);
+
+	// Get the nls configuration into the process.env as early as possible.
+	var nlsConfig = { availableLanguages: {} };
+	const config = process.env['VSCODE_NLS_CONFIG'];
+	if (config) {
+		process.env['VSCODE_NLS_CONFIG'] = config;
+		try {
+			nlsConfig = JSON.parse(config);
+		} catch (e) { /*noop*/ }
+	}
+
+	if (nlsConfig._resolvedLanguagePackCoreLocation) {
+		let bundles = Object.create(null);
+		nlsConfig.loadBundle = function(bundle, language, cb) {
+			let result = bundles[bundle];
+			if (result) {
+				cb(undefined, result);
+				return;
+			}
+			let bundleFile = path.join(nlsConfig._resolvedLanguagePackCoreLocation, bundle.replace(/\//g, '!') + '.nls.json');
+			readFile(bundleFile).then(function (content) {
+				let json = JSON.parse(content);
+				bundles[bundle] = json;
+				cb(undefined, json);
+			})
+				.catch(cb);
+		};
+	}
+
+	var locale = nlsConfig.availableLanguages['*'] || 'en';
+	if (locale === 'zh-tw') {
+		locale = 'zh-Hant';
+	} else if (locale === 'zh-cn') {
+		locale = 'zh-Hans';
+	}
+
+	window.document.documentElement.setAttribute('lang', locale);
+
+	// Load the loader and start loading the workbench
+	const rootUrl = uriFromPath(configuration.appRoot) + '/out';
+
+	// In the bundled version the nls plugin is packaged with the loader so the NLS Plugins
+	// loads as soon as the loader loads. To be able to have pseudo translation
+	createScript(rootUrl + '/vs/loader.js', function () {
+		var define = global.define;
+		global.define = undefined;
+		define('fs', ['original-fs'], function (originalFS) { return originalFS; }); // replace the patched electron fs with the original node fs for all AMD code
+
+		window.MonacoEnvironment = {};
+
+		require.config({
+			baseUrl: rootUrl,
+			'vs/nls': nlsConfig,
+			nodeCachedDataDir: configuration.nodeCachedDataDir,
+			nodeModules: [/*BUILD->INSERT_NODE_MODULES*/]
+		});
+
+		if (nlsConfig.pseudo) {
+			require(['vs/nls'], function (nlsPlugin) {
+				nlsPlugin.setPseudoTranslation(nlsConfig.pseudo);
+			});
+		}
+
+		require(['vs/code/electron-browser/sharedProcess/sharedProcessMain'], function (sharedProcess) {
+			sharedProcess.startup({
+				machineId: configuration.machineId
+			});
+		});
+	});
+}
+
+main();

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -0,0 +1,213 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as fs from 'fs';
+import * as platform from 'vs/base/common/platform';
+import product from 'vs/platform/node/product';
+import pkg from 'vs/platform/node/package';
+import { serve, Server, connect } from 'vs/base/parts/ipc/node/ipc.net';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
+import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
+import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
+import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
+import { ExtensionManagementChannel } from 'vs/platform/extensionManagement/common/extensionManagementIpc';
+import { IExtensionManagementService, IExtensionGalleryService } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ExtensionManagementService } from 'vs/platform/extensionManagement/node/extensionManagementService';
+import { ExtensionGalleryService } from 'vs/platform/extensionManagement/node/extensionGalleryService';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
+import { IRequestService } from 'vs/platform/request/node/request';
+import { RequestService } from 'vs/platform/request/electron-browser/requestService';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { combinedAppender, NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
+import { resolveCommonProperties } from 'vs/platform/telemetry/node/commonProperties';
+import { TelemetryAppenderChannel } from 'vs/platform/telemetry/common/telemetryIpc';
+import { TelemetryService, ITelemetryServiceConfig } from 'vs/platform/telemetry/common/telemetryService';
+import { AppInsightsAppender } from 'vs/platform/telemetry/node/appInsightsAppender';
+import { IWindowsService } from 'vs/platform/windows/common/windows';
+import { WindowsChannelClient } from 'vs/platform/windows/common/windowsIpc';
+import { ipcRenderer } from 'electron';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { createSharedProcessContributions } from 'vs/code/electron-browser/sharedProcess/contrib/contributions';
+import { createSpdLogService } from 'vs/platform/log/node/spdlogService';
+import { ILogService, LogLevel } from 'vs/platform/log/common/log';
+import { LogLevelSetterChannelClient, FollowerLogService } from 'vs/platform/log/common/logIpc';
+import { LocalizationsService } from 'vs/platform/localizations/node/localizations';
+import { ILocalizationsService } from 'vs/platform/localizations/common/localizations';
+import { LocalizationsChannel } from 'vs/platform/localizations/common/localizationsIpc';
+import { IChoiceService } from 'vs/platform/dialogs/common/dialogs';
+import { ChoiceChannelClient } from 'vs/platform/dialogs/common/choiceIpc';
+
+export interface ISharedProcessConfiguration {
+	readonly machineId: string;
+}
+
+export function startup(configuration: ISharedProcessConfiguration) {
+	handshake(configuration);
+}
+
+interface ISharedProcessInitData {
+	sharedIPCHandle: string;
+	args: ParsedArgs;
+	logLevel: LogLevel;
+}
+
+class ActiveWindowManager implements IDisposable {
+	private disposables: IDisposable[] = [];
+	private _activeWindowId: number;
+
+	constructor( @IWindowsService windowsService: IWindowsService) {
+		windowsService.onWindowOpen(this.setActiveWindow, this, this.disposables);
+		windowsService.onWindowFocus(this.setActiveWindow, this, this.disposables);
+	}
+
+	private setActiveWindow(windowId: number) {
+		this._activeWindowId = windowId;
+	}
+
+	public get activeClientId(): string {
+		return `window:${this._activeWindowId}`;
+	}
+
+	public dispose() {
+		this.disposables = dispose(this.disposables);
+	}
+}
+
+const eventPrefix = 'monacoworkbench';
+
+function main(server: Server, initData: ISharedProcessInitData, configuration: ISharedProcessConfiguration): void {
+	const services = new ServiceCollection();
+
+	const environmentService = new EnvironmentService(initData.args, process.execPath);
+	const logLevelClient = new LogLevelSetterChannelClient(server.getChannel('loglevel', { route: () => 'main' }));
+	const logService = new FollowerLogService(logLevelClient, createSpdLogService('sharedprocess', initData.logLevel, environmentService.logsPath));
+	process.once('exit', () => logService.dispose());
+
+	logService.info('main', JSON.stringify(configuration));
+
+	services.set(IEnvironmentService, environmentService);
+	services.set(ILogService, logService);
+	services.set(IConfigurationService, new SyncDescriptor(ConfigurationService));
+	services.set(IRequestService, new SyncDescriptor(RequestService));
+
+	const windowsChannel = server.getChannel('windows', { route: () => 'main' });
+	const windowsService = new WindowsChannelClient(windowsChannel);
+	services.set(IWindowsService, windowsService);
+
+	const activeWindowManager = new ActiveWindowManager(windowsService);
+	const choiceChannel = server.getChannel('choice', {
+		route: () => {
+			logService.info('Routing choice request to the client', activeWindowManager.activeClientId);
+			return activeWindowManager.activeClientId;
+		}
+	});
+	services.set(IChoiceService, new ChoiceChannelClient(choiceChannel));
+
+	const instantiationService = new InstantiationService(services);
+
+	instantiationService.invokeFunction(accessor => {
+		const appenders: AppInsightsAppender[] = [];
+
+		if (product.aiConfig && product.aiConfig.asimovKey) {
+			appenders.push(new AppInsightsAppender(eventPrefix, null, product.aiConfig.asimovKey));
+		}
+
+		// It is important to dispose the AI adapter properly because
+		// only then they flush remaining data.
+		process.once('exit', () => appenders.forEach(a => a.dispose()));
+
+		const appender = combinedAppender(...appenders);
+		server.registerChannel('telemetryAppender', new TelemetryAppenderChannel(appender));
+
+		const services = new ServiceCollection();
+		const environmentService = accessor.get(IEnvironmentService);
+		const { appRoot, extensionsPath, extensionDevelopmentPath, isBuilt, installSourcePath } = environmentService;
+
+		if (isBuilt && !extensionDevelopmentPath && !environmentService.args['disable-telemetry'] && product.enableTelemetry) {
+			const config: ITelemetryServiceConfig = {
+				appender,
+				commonProperties: resolveCommonProperties(product.commit, pkg.version, configuration.machineId, installSourcePath),
+				piiPaths: [appRoot, extensionsPath]
+			};
+
+			services.set(ITelemetryService, new SyncDescriptor(TelemetryService, config));
+		} else {
+			services.set(ITelemetryService, NullTelemetryService);
+		}
+
+		services.set(IExtensionManagementService, new SyncDescriptor(ExtensionManagementService));
+		services.set(IExtensionGalleryService, new SyncDescriptor(ExtensionGalleryService));
+		services.set(ILocalizationsService, new SyncDescriptor(LocalizationsService));
+
+		const instantiationService2 = instantiationService.createChild(services);
+
+		instantiationService2.invokeFunction(accessor => {
+			const extensionManagementService = accessor.get(IExtensionManagementService);
+			const channel = new ExtensionManagementChannel(extensionManagementService);
+			server.registerChannel('extensions', channel);
+
+			// clean up deprecated extensions
+			(extensionManagementService as ExtensionManagementService).removeDeprecatedExtensions();
+
+			const localizationsService = accessor.get(ILocalizationsService);
+			const localizationsChannel = new LocalizationsChannel(localizationsService);
+			server.registerChannel('localizations', localizationsChannel);
+
+			createSharedProcessContributions(instantiationService2);
+		});
+	});
+}
+
+function setupIPC(hook: string): TPromise<Server> {
+	function setup(retry: boolean): TPromise<Server> {
+		return serve(hook).then(null, err => {
+			if (!retry || platform.isWindows || err.code !== 'EADDRINUSE') {
+				return TPromise.wrapError(err);
+			}
+
+			// should retry, not windows and eaddrinuse
+
+			return connect(hook, '').then(
+				client => {
+					// we could connect to a running instance. this is not good, abort
+					client.dispose();
+					return TPromise.wrapError(new Error('There is an instance already running.'));
+				},
+				err => {
+					// it happens on Linux and OS X that the pipe is left behind
+					// let's delete it, since we can't connect to it
+					// and the retry the whole thing
+					try {
+						fs.unlinkSync(hook);
+					} catch (e) {
+						return TPromise.wrapError(new Error('Error deleting the shared ipc hook.'));
+					}
+
+					return setup(false);
+				}
+			);
+		});
+	}
+
+	return setup(true);
+}
+
+function startHandshake(): TPromise<ISharedProcessInitData> {
+	return new TPromise<ISharedProcessInitData>((c, e) => {
+		ipcRenderer.once('handshake:hey there', (_: any, r: ISharedProcessInitData) => c(r));
+		ipcRenderer.send('handshake:hello');
+	});
+}
+
+function handshake(configuration: ISharedProcessConfiguration): TPromise<void> {
+	return startHandshake()
+		.then(data => setupIPC(data.sharedIPCHandle).then(server => main(server, data, configuration)))
+		.then(() => ipcRenderer.send('handshake:im ready'));
+}