Merge from vscode ec07311dab2556c9d66a4cb3eecdc21c524202e1 (#6739)

src/vs/workbench/api/worker/extHostExtensionService.ts

@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createApiFactoryAndRegisterActors, IExtensionApiFactory } from 'vs/workbench/api/common/extHost.api.impl';
+import { ExtensionActivationTimesBuilder } from 'vs/workbench/api/common/extHostExtensionActivator';
+import { AbstractExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
+import { endsWith } from 'vs/base/common/strings';
+import { IExtensionDescription, ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { ExtHostConfigProvider } from 'vs/workbench/api/common/extHostConfiguration';
+import * as vscode from 'vscode';
+import { TernarySearchTree } from 'vs/base/common/map';
+import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+
+class ApiInstances {
+
+	private readonly _apiInstances = new Map<string, typeof vscode>();
+
+	constructor(
+		private readonly _apiFactory: IExtensionApiFactory,
+		private readonly _extensionPaths: TernarySearchTree<IExtensionDescription>,
+		private readonly _extensionRegistry: ExtensionDescriptionRegistry,
+		private readonly _configProvider: ExtHostConfigProvider,
+	) {
+		//
+	}
+
+	get(modulePath: string): typeof vscode {
+		const extension = this._extensionPaths.findSubstr(modulePath) || nullExtensionDescription;
+		const id = ExtensionIdentifier.toKey(extension.identifier);
+
+		let apiInstance = this._apiInstances.get(id);
+		if (!apiInstance) {
+			apiInstance = this._apiFactory(extension, this._extensionRegistry, this._configProvider);
+			this._apiInstances.set(id, apiInstance);
+		}
+		return apiInstance;
+	}
+}
+
+export class ExtHostExtensionService extends AbstractExtHostExtensionService {
+
+	private _apiInstances?: ApiInstances;
+
+	protected async _beforeAlmostReadyToRunExtensions(): Promise<void> {
+		// initialize API and register actors
+		const apiFactory = this._instaService.invokeFunction(createApiFactoryAndRegisterActors);
+		const configProvider = await this._extHostConfiguration.getConfigProvider();
+		const extensionPath = await this.getExtensionPathIndex();
+		this._apiInstances = new ApiInstances(apiFactory, extensionPath, this._registry, configProvider);
+	}
+
+	protected _loadCommonJSModule<T>(modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T> {
+
+		// make sure modulePath ends with `.js`
+		const suffix = '.js';
+		modulePath = endsWith(modulePath, suffix) ? modulePath : modulePath + suffix;
+
+		interface FakeCommonJSSelf {
+			module?: object;
+			exports?: object;
+			require?: (module: string) => any;
+			window?: object;
+			__dirname: never;
+			__filename: never;
+		}
+
+		// FAKE commonjs world that only collects exports
+		const patchSelf: FakeCommonJSSelf = <any>self;
+		const module = { exports: {} };
+		patchSelf.module = module;
+		patchSelf.exports = module.exports;
+		patchSelf.window = self; // <- that's improper but might help extensions that aren't authored correctly
+
+		// FAKE require function that only works for the vscode-module
+		patchSelf.require = (module: string) => {
+			if (module !== 'vscode') {
+				throw new Error(`Cannot load module '${module}'`);
+			}
+			return this._apiInstances!.get(modulePath);
+		};
+
+		try {
+			activationTimesBuilder.codeLoadingStart();
+			importScripts(modulePath);
+		} finally {
+			activationTimesBuilder.codeLoadingStop();
+		}
+
+		return Promise.resolve(module.exports as T);
+	}
+
+	async $setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void> {
+		throw new Error('Not supported');
+	}
+}

src/vs/workbench/api/worker/extHostLogService.ts

@@ -0,0 +1,84 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ILogService, LogLevel, AbstractLogService } from 'vs/platform/log/common/log';
+import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
+import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+import * as vscode from 'vscode';
+
+export class ExtHostLogService extends AbstractLogService implements ILogService, ExtHostLogServiceShape {
+
+	_serviceBrand: any;
+
+	private readonly _logChannel: vscode.OutputChannel;
+
+	constructor(
+		@IExtHostInitDataService initData: IExtHostInitDataService,
+		@IExtHostOutputService extHostOutputService: IExtHostOutputService
+	) {
+		super();
+		this.setLevel(initData.logLevel);
+		this._logChannel = extHostOutputService.createOutputChannel('Log (Worker Extension Host)');
+	}
+
+	$setLevel(level: LogLevel): void {
+		this.setLevel(level);
+	}
+
+	trace(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Trace) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	debug(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Debug) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	info(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Info) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	warn(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Warning) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	error(_message: string | Error, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Error) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	critical(_message: string | Error, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Critical) {
+			this._logChannel.appendLine(String(arguments));
+		}
+	}
+
+	private _format(args: any): string {
+		let result = '';
+
+		for (let i = 0; i < args.length; i++) {
+			let a = args[i];
+
+			if (typeof a === 'object') {
+				try {
+					a = JSON.stringify(a);
+				} catch (e) { }
+			}
+
+			result += (i > 0 ? ' ' : '') + a;
+		}
+
+		return result;
+	}
+}