Merge from vscode ec07311dab2556c9d66a4cb3eecdc21c524202e1 (#6739)

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

@@ -18,6 +18,8 @@ import { ExtensionHostProcessManager } from 'vs/workbench/services/extensions/co
 import { RemoteExtensionHostClient, IInitDataProvider } from 'vs/workbench/services/extensions/common/remoteExtensionHostClient';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
 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';
 
 export class ExtensionService extends AbstractExtensionService implements IExtensionService {
 
@@ -62,6 +64,11 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		const result: ExtensionHostProcessManager[] = [];
 
 		const remoteAgentConnection = this._remoteAgentService.getConnection()!;
+
+		const webHostProcessWorker = this._instantiationService.createInstance(WebWorkerExtensionHostStarter, true, Promise.resolve([]), 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 remoteExtHostProcessManager = this._instantiationService.createInstance(ExtensionHostProcessManager, false, remoteExtHostProcessWorker, remoteAgentConnection.remoteAuthority, initialActivationEvents);
 		result.push(remoteExtHostProcessManager);

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

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DefaultWorkerFactory } from 'vs/base/worker/defaultWorkerFactory';
+import { Emitter, Event } from 'vs/base/common/event';
+import { DisposableStore } 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';
+import { IInitData } from 'vs/workbench/api/common/extHost.protocol';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
+import { ILabelService } from 'vs/platform/label/common/label';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import * as platform from 'vs/base/common/platform';
+import { URI } from 'vs/base/common/uri';
+import { IExtensionHostStarter } from 'vs/workbench/services/extensions/common/extensions';
+import { IProductService } from 'vs/platform/product/common/product';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+
+export class WebWorkerExtensionHostStarter implements IExtensionHostStarter {
+
+	private _toDispose = new DisposableStore();
+	private _isTerminating: boolean = false;
+	private _protocol?: IMessagePassingProtocol;
+
+	private readonly _onDidExit = new Emitter<[number, string | null]>();
+	readonly onExit: Event<[number, string | null]> = this._onDidExit.event;
+
+	constructor(
+		private readonly _autoStart: boolean,
+		private readonly _extensions: Promise<IExtensionDescription[]>,
+		private readonly _extensionHostLogsLocation: URI,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IWorkspaceContextService private readonly _contextService: IWorkspaceContextService,
+		@ILabelService private readonly _labelService: ILabelService,
+		@ILogService private readonly _logService: ILogService,
+		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
+		@IProductService private readonly _productService: IProductService,
+	) {
+
+	}
+
+	async start(): Promise<IMessagePassingProtocol> {
+
+		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);
+				}
+			);
+
+			// keep for cleanup
+			this._toDispose.add(emitter);
+			this._toDispose.add(worker);
+
+			const protocol: IMessagePassingProtocol = {
+				onMessage: emitter.event,
+				send: vsbuf => {
+					const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);
+					worker.postMessage(data, [data]);
+				}
+			};
+
+			// extension host handshake happens below
+			// (1) <== wait for: Ready
+			// (2) ==> send: init data
+			// (3) <== wait for: Initialized
+
+			await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Ready)));
+			protocol.send(VSBuffer.fromString(JSON.stringify(await this._createExtHostInitData())));
+			await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Initialized)));
+
+			this._protocol = protocol;
+		}
+		return this._protocol;
+
+	}
+
+	dispose(): void {
+		if (!this._protocol) {
+			this._toDispose.dispose();
+			return;
+		}
+		if (this._isTerminating) {
+			return;
+		}
+		this._isTerminating = true;
+		this._protocol.send(createMessageOfType(MessageType.Terminate));
+		setTimeout(() => this._toDispose.dispose(), 10 * 1000);
+	}
+
+	getInspectPort(): number | undefined {
+		return undefined;
+	}
+
+	private async _createExtHostInitData(): Promise<IInitData> {
+		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,
+			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,
+				appLanguage: platform.language,
+				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
+				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
+				globalStorageHome: URI.parse('fake:globalStorageHome'), //todo@joh URI.file(this._environmentService.globalStorageHome),
+				userHome: URI.parse('fake:userHome'), //todo@joh URI.file(this._environmentService.userHome),
+				webviewResourceRoot: this._environmentService.webviewResourceRoot,
+				webviewCspSource: this._environmentService.webviewCspSource,
+			},
+			workspace: this._contextService.getWorkbenchState() === WorkbenchState.EMPTY ? undefined : {
+				configuration: workspace.configuration || undefined,
+				id: workspace.id,
+				name: this._labelService.getWorkspaceLabel(workspace)
+			},
+			resolvedExtensions: [],
+			hostExtensions: [],
+			extensions: extensionDescriptions,
+			telemetryInfo,
+			logLevel: this._logService.getLevel(),
+			logsLocation: this._extensionHostLogsLocation,
+			autoStart: this._autoStart,
+			remote: {
+				authority: this._environmentService.configuration.remoteAuthority,
+				isRemote: false
+			},
+		};
+	}
+}