Merge from vscode b12f623603e2fc1c5b3037115fa37c1a6acc4165 (#6760)

src/vs/workbench/services/extensions/browser/extensionService.ts

@@ -20,6 +20,8 @@ import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEn
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { WebWorkerExtensionHostStarter } from 'vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter';
 import { URI } from 'vs/base/common/uri';
+import { isWebExtension } from 'vs/workbench/services/extensions/common/extensionsUtil';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 
 export class ExtensionService extends AbstractExtensionService implements IExtensionService {
 
@@ -34,6 +36,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		@IFileService fileService: IFileService,
 		@IProductService productService: IProductService,
 		@IRemoteAgentService private readonly _remoteAgentService: IRemoteAgentService,
+		@IConfigurationService private readonly _configService: IConfigurationService,
 	) {
 		super(
 			instantiationService,
@@ -65,11 +68,14 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 
 		const remoteAgentConnection = this._remoteAgentService.getConnection()!;
 
-		const webHostProcessWorker = this._instantiationService.createInstance(WebWorkerExtensionHostStarter, true, Promise.resolve([]), URI.parse('empty:value')); //todo@joh
+		const webExtensions = this.getExtensions().then(extensions => extensions.filter(ext => isWebExtension(ext, this._configService)));
+		const remoteExtensions = this.getExtensions().then(extensions => extensions.filter(ext => !isWebExtension(ext, this._configService)));
+
+		const webHostProcessWorker = this._instantiationService.createInstance(WebWorkerExtensionHostStarter, true, webExtensions, URI.parse('empty:value')); //todo@joh
 		const webHostProcessManager = this._instantiationService.createInstance(ExtensionHostProcessManager, false, webHostProcessWorker, remoteAgentConnection.remoteAuthority, initialActivationEvents);
 		result.push(webHostProcessManager);
 
-		const remoteExtHostProcessWorker = this._instantiationService.createInstance(RemoteExtensionHostClient, this.getExtensions(), this._createProvider(remoteAgentConnection.remoteAuthority), this._remoteAgentService.socketFactory);
+		const remoteExtHostProcessWorker = this._instantiationService.createInstance(RemoteExtensionHostClient, remoteExtensions, this._createProvider(remoteAgentConnection.remoteAuthority), this._remoteAgentService.socketFactory);
 		const remoteExtHostProcessManager = this._instantiationService.createInstance(ExtensionHostProcessManager, false, remoteExtHostProcessWorker, remoteAgentConnection.remoteAuthority, initialActivationEvents);
 		result.push(remoteExtHostProcessManager);
 

src/vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter.ts

@@ -3,9 +3,9 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DefaultWorkerFactory } from 'vs/base/worker/defaultWorkerFactory';
+import { getWorkerBootstrapUrl } from 'vs/base/worker/defaultWorkerFactory';
 import { Emitter, Event } from 'vs/base/common/event';
-import { DisposableStore } from 'vs/base/common/lifecycle';
+import { DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { createMessageOfType, MessageType, isMessageOfType } from 'vs/workbench/services/extensions/common/extensionHostProtocol';
@@ -49,23 +49,29 @@ export class WebWorkerExtensionHostStarter implements IExtensionHostStarter {
 		if (!this._protocol) {
 
 			const emitter = new Emitter<VSBuffer>();
-			const worker = new DefaultWorkerFactory('WorkerExtensionHost').create(
-				'vs/workbench/services/extensions/worker/extensionHostWorker', data => {
-					if (data instanceof ArrayBuffer) {
-						emitter.fire(VSBuffer.wrap(new Uint8Array(data, 0, data.byteLength)));
-					} else {
-						console.warn('UNKNOWN data received', data);
-						this._onDidExit.fire([77, 'UNKNOWN data received']);
-					}
-				}, err => {
-					this._onDidExit.fire([81, err]);
-					console.error(err);
+
+			const url = getWorkerBootstrapUrl(require.toUrl('../worker/extensionHostWorkerMain.js'), 'WorkerExtensionHost');
+			const worker = new Worker(url);
+
+			worker.onmessage = (event) => {
+				const { data } = event;
+				if (!(data instanceof ArrayBuffer)) {
+					console.warn('UNKNOWN data received', data);
+					this._onDidExit.fire([77, 'UNKNOWN data received']);
+					return;
 				}
-			);
+
+				emitter.fire(VSBuffer.wrap(new Uint8Array(data, 0, data.byteLength)));
+			};
+
+			worker.onerror = (event) => {
+				console.error(event.error);
+				this._onDidExit.fire([81, event.error]);
+			};
 
 			// keep for cleanup
 			this._toDispose.add(emitter);
-			this._toDispose.add(worker);
+			this._toDispose.add(toDisposable(() => worker.terminate()));
 
 			const protocol: IMessagePassingProtocol = {
 				onMessage: emitter.event,
@@ -111,16 +117,16 @@ export class WebWorkerExtensionHostStarter implements IExtensionHostStarter {
 		const [telemetryInfo, extensionDescriptions] = await Promise.all([this._telemetryService.getTelemetryInfo(), this._extensions]);
 		const workspace = this._contextService.getWorkspace();
 		return {
-			commit: this._productService.commit,
-			version: this._productService.version,
-			vscodeVersion: this._productService.vscodeVersion,
+			commit: this._productService.productConfiguration.commit,
+			version: this._productService.productConfiguration.version,
+			vscodeVersion: this._productService.productConfiguration.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
 			parentPid: -1,
 			environment: {
 				isExtensionDevelopmentDebug: false,
 				appRoot: this._environmentService.appRoot ? URI.file(this._environmentService.appRoot) : undefined,
 				appSettingsHome: this._environmentService.appSettingsHome ? this._environmentService.appSettingsHome : undefined,
-				appName: this._productService.nameLong,
-				appUriScheme: this._productService.urlProtocol,
+				appName: this._productService.productConfiguration.nameLong,
+				appUriScheme: this._productService.productConfiguration.urlProtocol,
 				appLanguage: platform.language,
 				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,

src/vs/workbench/services/extensions/common/abstractExtensionService.ts

@@ -462,12 +462,12 @@ class ProposedApiController {
 		}
 
 		this.enableProposedApiForAll = !environmentService.isBuilt ||
-			(!!environmentService.extensionDevelopmentLocationURI && productService.nameLong !== 'Visual Studio Code') ||
+			(!!environmentService.extensionDevelopmentLocationURI && productService.productConfiguration.nameLong !== 'Visual Studio Code') ||
 			(this.enableProposedApiFor.length === 0 && 'enable-proposed-api' in environmentService.args);
 
 		this.productAllowProposedApi = new Set<string>();
-		if (isNonEmptyArray(productService.extensionAllowedProposedApi)) {
-			productService.extensionAllowedProposedApi.forEach((id) => this.productAllowProposedApi.add(ExtensionIdentifier.toKey(id)));
+		if (isNonEmptyArray(productService.productConfiguration.extensionAllowedProposedApi)) {
+			productService.productConfiguration.extensionAllowedProposedApi.forEach((id) => this.productAllowProposedApi.add(ExtensionIdentifier.toKey(id)));
 		}
 	}
 

src/vs/workbench/services/extensions/common/extensionsUtil.ts

@@ -10,6 +10,11 @@ import { getGalleryExtensionId, areSameExtensions } from 'vs/platform/extensionM
 import { isNonEmptyArray } from 'vs/base/common/arrays';
 import { IProductService } from 'vs/platform/product/common/product';
 
+export function isWebExtension(manifest: IExtensionManifest, configurationService: IConfigurationService): boolean {
+	const extensionKind = getExtensionKind(manifest, configurationService);
+	return extensionKind === 'web';
+}
+
 export function isUIExtension(manifest: IExtensionManifest, productService: IProductService, configurationService: IConfigurationService): boolean {
 	const uiContributions = ExtensionsRegistry.getExtensionPoints().filter(e => e.defaultExtensionKind !== 'workspace').map(e => e.name);
 	const extensionId = getGalleryExtensionId(manifest.publisher, manifest.name);
@@ -19,7 +24,7 @@ export function isUIExtension(manifest: IExtensionManifest, productService: IPro
 		case 'workspace': return false;
 		default: {
 			// Tagged as UI extension in product
-			if (isNonEmptyArray(productService.uiExtensions) && productService.uiExtensions.some(id => areSameExtensions({ id }, { id: extensionId }))) {
+			if (isNonEmptyArray(productService.productConfiguration.uiExtensions) && productService.productConfiguration.uiExtensions.some(id => areSameExtensions({ id }, { id: extensionId }))) {
 				return true;
 			}
 			// Not an UI extension if it has main

src/vs/workbench/services/extensions/common/remoteExtensionHostClient.ts

@@ -71,7 +71,7 @@ export class RemoteExtensionHostClient extends Disposable implements IExtensionH
 
 	public start(): Promise<IMessagePassingProtocol> {
 		const options: IConnectionOptions = {
-			commit: this._productService.commit,
+			commit: this._productService.productConfiguration.commit,
 			socketFactory: this._socketFactory,
 			addressProvider: {
 				getAddress: async () => {
@@ -181,16 +181,16 @@ export class RemoteExtensionHostClient extends Disposable implements IExtensionH
 			const hostExtensions = allExtensions.filter(extension => extension.main && extension.api === 'none').map(extension => extension.identifier);
 			const workspace = this._contextService.getWorkspace();
 			const r: IInitData = {
-				commit: this._productService.commit,
-				version: this._productService.version,
-				vscodeVersion: this._productService.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
+				commit: this._productService.productConfiguration.commit,
+				version: this._productService.productConfiguration.version,
+				vscodeVersion: this._productService.productConfiguration.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
 				parentPid: remoteExtensionHostData.pid,
 				environment: {
 					isExtensionDevelopmentDebug,
 					appRoot: remoteExtensionHostData.appRoot,
 					appSettingsHome: remoteExtensionHostData.appSettingsHome,
-					appName: this._productService.nameLong,
-					appUriScheme: this._productService.urlProtocol,
+					appName: this._productService.productConfiguration.nameLong,
+					appUriScheme: this._productService.productConfiguration.urlProtocol,
 					appLanguage: platform.language,
 					extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 					extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,

src/vs/workbench/services/extensions/electron-browser/remoteExtensionManagementIpc.ts

@@ -69,7 +69,7 @@ export class RemoteExtensionManagementChannelClient extends ExtensionManagementC
 		const installed = await this.getInstalled(ExtensionType.User);
 		const compatible = await this.galleryService.getCompatibleExtension(extension);
 		if (!compatible) {
-			return Promise.reject(new Error(localize('incompatible', "Unable to install extension '{0}' as it is not compatible with VS Code '{1}'.", extension.identifier.id, this.productService.version)));
+			return Promise.reject(new Error(localize('incompatible', "Unable to install extension '{0}' as it is not compatible with VS Code '{1}'.", extension.identifier.id, this.productService.productConfiguration.version)));
 		}
 		const manifest = await this.galleryService.getManifest(compatible, CancellationToken.None);
 		if (manifest) {
@@ -140,4 +140,4 @@ export class RemoteExtensionManagementChannelClient extends ExtensionManagementC
 		}
 		return this.getDependenciesAndPackedExtensionsRecursively(toGet, result, uiExtension, token);
 	}
-}
+}

src/vs/workbench/services/extensions/node/extensionPoints.ts

@@ -313,11 +313,6 @@ class ExtensionManifestValidator extends ExtensionManifestHandler {
 		extensionDescription.id = `${extensionDescription.publisher}.${extensionDescription.name}`;
 		extensionDescription.identifier = new ExtensionIdentifier(extensionDescription.id);
 
-		// main := absolutePath(`main`)
-		if (extensionDescription.main) {
-			extensionDescription.main = path.join(this._absoluteFolderPath, extensionDescription.main);
-		}
-
 		extensionDescription.extensionLocation = URI.file(this._absoluteFolderPath);
 
 		return extensionDescription;

src/vs/workbench/services/extensions/node/proxyResolver.ts

@@ -469,26 +469,24 @@ async function readCaCertificates() {
 }
 
 async function readWindowsCaCertificates() {
-	// Not using await to work around minifier bug (https://github.com/microsoft/vscode/issues/79044).
-	return import('vscode-windows-ca-certs')
-		.then(winCA => {
-			let ders: any[] = [];
-			const store = winCA();
-			try {
-				let der: any;
-				while (der = store.next()) {
-					ders.push(der);
-				}
-			} finally {
-				store.done();
-			}
+	const winCA = await import('vscode-windows-ca-certs');
 
-			const certs = new Set(ders.map(derToPem));
-			return {
-				certs: Array.from(certs),
-				append: true
-			};
-		});
+	let ders: any[] = [];
+	const store = winCA();
+	try {
+		let der: any;
+		while (der = store.next()) {
+			ders.push(der);
+		}
+	} finally {
+		store.done();
+	}
+
+	const certs = new Set(ders.map(derToPem));
+	return {
+		certs: Array.from(certs),
+		append: true
+	};
 }
 
 async function readMacCaCertificates() {

src/vs/workbench/services/extensions/worker/extensionHostWorker.ts

@@ -3,7 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IRequestHandler } from 'vs/base/common/worker/simpleWorker';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { Emitter } from 'vs/base/common/event';
@@ -38,21 +37,18 @@ const hostUtil = new class implements IHostUtils {
 
 //todo@joh do not allow extensions to call postMessage and other globals...
 
-class ExtensionWorker implements IRequestHandler {
-
-	// worker-contract
-	readonly _requestHandlerBrand: any;
-	readonly onmessage: (data: any) => any;
+class ExtensionWorker {
 
 	// protocol
 	readonly protocol: IMessagePassingProtocol;
 
-	constructor(postMessage: (message: any, transfer?: Transferable[]) => any) {
+	constructor() {
 
 		let emitter = new Emitter<VSBuffer>();
 		let terminating = false;
 
-		this.onmessage = data => {
+		onmessage = event => {
+			const { data } = event;
 			if (!(data instanceof ArrayBuffer)) {
 				console.warn('UNKNOWN data received', data);
 				return;
@@ -98,8 +94,8 @@ function connectToRenderer(protocol: IMessagePassingProtocol): Promise<IRenderer
 	});
 }
 
-export function create(postMessage: (message: any, transfer?: Transferable[]) => any): IRequestHandler {
-	const res = new ExtensionWorker(postMessage);
+(function create(): void {
+	const res = new ExtensionWorker();
 
 	connectToRenderer(res.protocol).then(data => {
 
@@ -112,6 +108,4 @@ export function create(postMessage: (message: any, transfer?: Transferable[]) =>
 
 		onTerminate = () => extHostMain.terminate();
 	});
-
-	return res;
-}
+})();

src/vs/workbench/services/extensions/worker/extensionHostWorkerMain.ts

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+(function () {
+
+	let MonacoEnvironment = (<any>self).MonacoEnvironment;
+	let monacoBaseUrl = MonacoEnvironment && MonacoEnvironment.baseUrl ? MonacoEnvironment.baseUrl : '../../../../../';
+
+	if (typeof (<any>self).define !== 'function' || !(<any>self).define.amd) {
+		importScripts(monacoBaseUrl + 'vs/loader.js');
+	}
+
+	require.config({
+		baseUrl: monacoBaseUrl,
+		catchError: true
+	});
+
+	require(['vs/workbench/services/extensions/worker/extensionHostWorker'], () => { }, err => console.error(err));
+})();