Merge from vscode 31e03b8ffbb218a87e3941f2b63a249f061fe0e4 (#4986)

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

@@ -294,30 +294,19 @@ export class CachedExtensionScanner {
 
 		// Always load developed extensions while extensions development
 		let developedExtensions: Promise<IExtensionDescription[]> = Promise.resolve([]);
-		if (environmentService.isExtensionDevelopment) {
-
-			if (Array.isArray(environmentService.extensionDevelopmentLocationURI)) {
-
-				const extDescsP = environmentService.extensionDevelopmentLocationURI.filter(extLoc => extLoc.scheme === Schemas.file).map(extLoc => {
-					return ExtensionScanner.scanOneOrMultipleExtensions(
-						new ExtensionScannerInput(version, commit, locale, devMode, originalFSPath(extLoc), false, true, translations), log
-					);
-				});
-				developedExtensions = Promise.all(extDescsP).then((extDescArrays: IExtensionDescription[][]) => {
-					let extDesc: IExtensionDescription[] = [];
-					for (let eds of extDescArrays) {
-						extDesc = extDesc.concat(eds);
-					}
-					return extDesc;
-				});
-
-			} else if (environmentService.extensionDevelopmentLocationURI) {
-				if (environmentService.extensionDevelopmentLocationURI.scheme === Schemas.file) {
-					developedExtensions = ExtensionScanner.scanOneOrMultipleExtensions(
-						new ExtensionScannerInput(version, commit, locale, devMode, originalFSPath(environmentService.extensionDevelopmentLocationURI), false, true, translations), log
-					);
+		if (environmentService.isExtensionDevelopment && environmentService.extensionDevelopmentLocationURI) {
+			const extDescsP = environmentService.extensionDevelopmentLocationURI.filter(extLoc => extLoc.scheme === Schemas.file).map(extLoc => {
+				return ExtensionScanner.scanOneOrMultipleExtensions(
+					new ExtensionScannerInput(version, commit, locale, devMode, originalFSPath(extLoc), false, true, translations), log
+				);
+			});
+			developedExtensions = Promise.all(extDescsP).then((extDescArrays: IExtensionDescription[][]) => {
+				let extDesc: IExtensionDescription[] = [];
+				for (let eds of extDescArrays) {
+					extDesc = extDesc.concat(eds);
 				}
-			}
+				return extDesc;
+			});
 		}
 
 		return Promise.all([finalBuiltinExtensions, userExtensions, developedExtensions]).then((extensionDescriptions: IExtensionDescription[][]) => {

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

@@ -22,7 +22,7 @@ import { findFreePort, randomPort } from 'vs/base/node/ports';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { PersistentProtocol } from 'vs/base/parts/ipc/common/ipc.net';
 import { generateRandomPipeName, NodeSocket } from 'vs/base/parts/ipc/node/ipc.net';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { ILabelService } from 'vs/platform/label/common/label';
 import { ILifecycleService, WillShutdownEvent } from 'vs/platform/lifecycle/common/lifecycle';
 import { ILogService } from 'vs/platform/log/common/log';
@@ -32,7 +32,7 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IWindowService, IWindowsService } from 'vs/platform/windows/common/windows';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IInitData } from 'vs/workbench/api/common/extHost.protocol';
-import { MessageType, createMessageOfType, isMessageOfType } from 'vs/workbench/services/extensions/node/extensionHostProtocol';
+import { MessageType, createMessageOfType, isMessageOfType } from 'vs/workbench/services/extensions/common/extensionHostProtocol';
 import { withNullAsUndefined } from 'vs/base/common/types';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { parseExtensionDevOptions } from '../common/extensionDevOptions';
@@ -78,7 +78,7 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 		@IWindowsService private readonly _windowsService: IWindowsService,
 		@IWindowService private readonly _windowService: IWindowService,
 		@ILifecycleService private readonly _lifecycleService: ILifecycleService,
-		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
 		@ITelemetryService private readonly _telemetryService: ITelemetryService,
 		@ILogService private readonly _logService: ILogService,
 		@ILabelService private readonly _labelService: ILabelService,
@@ -124,10 +124,8 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 	private matchesExtDevLocations(resource: URI): boolean {
 
 		const extDevLocs = this._environmentService.extensionDevelopmentLocationURI;
-		if (Array.isArray(extDevLocs)) {
+		if (extDevLocs) {
 			return extDevLocs.some(extDevLoc => isEqual(extDevLoc, resource));
-		} else if (extDevLocs) {
-			return isEqual(extDevLocs, resource);
 		}
 		return false;
 	}
@@ -240,7 +238,7 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 
 				// Help in case we fail to start it
 				let startupTimeoutHandle: any;
-				if (!this._environmentService.isBuilt && !this._windowService.getConfiguration().remoteAuthority || this._isExtensionDevHost) {
+				if (!this._environmentService.isBuilt && !this._environmentService.configuration.remoteAuthority || this._isExtensionDevHost) {
 					startupTimeoutHandle = setTimeout(() => {
 						const msg = this._isExtensionDevDebugBrk
 							? nls.localize('extensionHostProcess.startupFailDebug', "Extension host did not start in 10 seconds, it might be stopped on the first line and needs a debugger to continue.")

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

@@ -6,7 +6,7 @@
 import { Event, Emitter } from 'vs/base/common/event';
 import { IWindowService } from 'vs/platform/windows/common/windows';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
-import { IExtensionHostDebugService } from 'vs/workbench/services/extensions/common/extensionHostDebug';
+import { IExtensionHostDebugService, IAttachSessionEvent, ITerminateSessionEvent, ILogToSessionEvent } from 'vs/workbench/services/extensions/common/extensionHostDebug';
 import { URI } from 'vs/base/common/uri';
 import { IRemoteConsoleLog } from 'vs/base/common/console';
 import { ipcRenderer as ipc } from 'electron';
@@ -16,10 +16,8 @@ interface IReloadBroadcast {
 	resource: string;
 }
 
-interface IAttachSessionBroadcast {
+interface IAttachSessionBroadcast extends IAttachSessionEvent {
 	type: 'vscode:extensionAttach';
-	id: string;
-	port: number;
 }
 
 interface ICloseBroadcast {
@@ -27,15 +25,12 @@ interface ICloseBroadcast {
 	resource: string;
 }
 
-interface ILogToSessionBroadcast {
+interface ILogToSessionBroadcast extends ILogToSessionEvent {
 	type: 'vscode:extensionLog';
-	id: string;
-	log: IRemoteConsoleLog;
 }
 
-interface ITerminateSessionBroadcast {
+interface ITerminateSessionBroadcast extends ITerminateSessionEvent {
 	type: 'vscode:extensionTerminate';
-	id: string;
 }
 
 const CHANNEL = 'vscode:extensionHostDebug';
@@ -46,30 +41,32 @@ class ExtensionHostDebugService implements IExtensionHostDebugService {
 	private windowId: number;
 	private readonly _onReload = new Emitter<URI>();
 	private readonly _onClose = new Emitter<URI>();
-	private readonly _onAttachSession = new Emitter<{ id: string, port: number }>();
-	private readonly _onLogToSession = new Emitter<{ id: string, log: IRemoteConsoleLog }>();
-	private readonly _onTerminateSession = new Emitter<string>();
+	private readonly _onAttachSession = new Emitter<IAttachSessionEvent>();
+	private readonly _onLogToSession = new Emitter<ILogToSessionEvent>();
+	private readonly _onTerminateSession = new Emitter<ITerminateSessionEvent>();
 
 	constructor(
 		@IWindowService readonly windowService: IWindowService,
 	) {
-		this.windowId = windowService.getCurrentWindowId();
+		this.windowId = windowService.windowId;
 
 		ipc.on(CHANNEL, (_: unknown, broadcast: IReloadBroadcast | ICloseBroadcast | IAttachSessionBroadcast | ILogToSessionBroadcast | ITerminateSessionBroadcast) => {
-			if (broadcast.type === 'vscode:extensionReload') {
-				this._onReload.fire(URI.parse(broadcast.resource));
-			}
-			if (broadcast.type === 'vscode:extensionCloseExtensionHost') {
-				this._onClose.fire(URI.parse(broadcast.resource));
-			}
-			if (broadcast.type === 'vscode:extensionAttach') {
-				this._onAttachSession.fire({ id: broadcast.id, port: broadcast.port });
-			}
-			if (broadcast.type === 'vscode:extensionLog') {
-				this._onLogToSession.fire({ id: broadcast.id, log: broadcast.log });
-			}
-			if (broadcast.type === 'vscode:extensionTerminate') {
-				this._onTerminateSession.fire(broadcast.id);
+			switch (broadcast.type) {
+				case 'vscode:extensionReload':
+					this._onReload.fire(URI.parse(broadcast.resource));
+					break;
+				case 'vscode:extensionCloseExtensionHost':
+					this._onClose.fire(URI.parse(broadcast.resource));
+					break;
+				case 'vscode:extensionAttach':
+					this._onAttachSession.fire(broadcast);
+					break;
+				case 'vscode:extensionLog':
+					this._onLogToSession.fire(broadcast);
+					break;
+				case 'vscode:extensionTerminate':
+					this._onTerminateSession.fire(broadcast);
+					break;
 			}
 		});
 	}
@@ -96,38 +93,40 @@ class ExtensionHostDebugService implements IExtensionHostDebugService {
 		return this._onClose.event;
 	}
 
-	attachSession(id: string, port: number): void {
+	attachSession(sessionId: string, port: number, subId?: string): void {
 		ipc.send(CHANNEL, this.windowId, <IAttachSessionBroadcast>{
 			type: 'vscode:extensionAttach',
-			id,
-			port
+			sessionId,
+			port,
+			subId
 		});
 	}
 
-	get onAttachSession(): Event<{ id: string, port: number }> {
+	get onAttachSession(): Event<IAttachSessionEvent> {
 		return this._onAttachSession.event;
 	}
 
-	logToSession(id: string, log: IRemoteConsoleLog): void {
+	logToSession(sessionId: string, log: IRemoteConsoleLog): void {
 		ipc.send(CHANNEL, this.windowId, <ILogToSessionBroadcast>{
 			type: 'vscode:extensionLog',
-			id,
+			sessionId,
 			log
 		});
 	}
 
-	get onLogToSession(): Event<{ id: string, log: IRemoteConsoleLog }> {
+	get onLogToSession(): Event<ILogToSessionEvent> {
 		return this._onLogToSession.event;
 	}
 
-	terminateSession(id: string): void {
+	terminateSession(sessionId: string, subId?: string): void {
 		ipc.send(CHANNEL, this.windowId, <ITerminateSessionBroadcast>{
 			type: 'vscode:extensionTerminate',
-			id
+			sessionId,
+			subId
 		});
 	}
 
-	get onTerminateSession(): Event<string> {
+	get onTerminateSession(): Event<ITerminateSessionEvent> {
 		return this._onTerminateSession.event;
 	}
 }

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

@@ -16,7 +16,7 @@ import { ProfileSession } from 'vs/workbench/services/extensions/common/extensio
 import { IExtensionHostStarter } from 'vs/workbench/services/extensions/electron-browser/extensionHost';
 import { ExtensionHostProfiler } from 'vs/workbench/services/extensions/electron-browser/extensionHostProfiler';
 import { ProxyIdentifier } from 'vs/workbench/services/extensions/common/proxyIdentifier';
-import { IRPCProtocolLogger, RPCProtocol, RequestInitiator, ResponsiveState } from 'vs/workbench/services/extensions/node/rpcProtocol';
+import { IRPCProtocolLogger, RPCProtocol, RequestInitiator, ResponsiveState } from 'vs/workbench/services/extensions/common/rpcProtocol';
 import { ResolvedAuthority } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import * as nls from 'vs/nls';
@@ -27,6 +27,7 @@ import { Extensions as ActionExtensions, IWorkbenchActionRegistry } from 'vs/wor
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IUntitledResourceInput } from 'vs/workbench/common/editor';
 import { StopWatch } from 'vs/base/common/stopwatch';
+import { VSBuffer } from 'vs/base/common/buffer';
 
 // Enable to see detailed message communication between window and extension host
 const LOG_EXTENSION_HOST_COMMUNICATION = false;
@@ -154,7 +155,7 @@ export class ExtensionHostProcessManager extends Disposable {
 
 		let b = Buffer.alloc(SIZE, Math.random() % 256);
 		const sw = StopWatch.create(true);
-		await proxy.$test_up(b);
+		await proxy.$test_up(VSBuffer.wrap(b));
 		sw.stop();
 		return ExtensionHostProcessManager._convert(SIZE, sw.elapsed());
 	}

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

@@ -33,7 +33,7 @@ export class ExtensionManagementServerService implements IExtensionManagementSer
 		const remoteAgentConnection = remoteAgentService.getConnection();
 		if (remoteAgentConnection) {
 			const extensionManagementService = new ExtensionManagementChannelClient(remoteAgentConnection.getChannel<IChannel>('extensions'));
-			this.remoteExtensionManagementServer = { authority: remoteAgentConnection.remoteAuthority, extensionManagementService, label: remoteAgentConnection.remoteAuthority };
+			this.remoteExtensionManagementServer = { authority: remoteAgentConnection.remoteAuthority, extensionManagementService, label: localize('remote', "Remote") };
 		}
 	}
 

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

@@ -13,7 +13,7 @@ import { Disposable } from 'vs/base/common/lifecycle';
 import * as perf from 'vs/base/common/performance';
 import { isEqualOrParent } from 'vs/base/common/resources';
 import { URI } from 'vs/base/common/uri';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { EnablementState, IExtensionEnablementService, IExtensionIdentifier, IExtensionManagementService } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { BetterMergeId, areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -26,8 +26,8 @@ import { IWindowService, IWindowsService } from 'vs/platform/windows/common/wind
 import { ActivationTimes, ExtensionPointContribution, IExtensionService, IExtensionsStatus, IMessage, ProfileSession, IWillActivateEvent, IResponsiveStateChangeEvent, toExtension } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtensionMessageCollector, ExtensionPoint, ExtensionsRegistry, IExtensionPoint, IExtensionPointUser, schema } from 'vs/workbench/services/extensions/common/extensionsRegistry';
 import { ExtensionHostProcessWorker } from 'vs/workbench/services/extensions/electron-browser/extensionHost';
-import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
-import { ResponsiveState } from 'vs/workbench/services/extensions/node/rpcProtocol';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import { ResponsiveState } from 'vs/workbench/services/extensions/common/rpcProtocol';
 import { CachedExtensionScanner, Logger } from 'vs/workbench/services/extensions/electron-browser/cachedExtensionScanner';
 import { ExtensionHostProcessManager } from 'vs/workbench/services/extensions/electron-browser/extensionHostProcessManager';
 import { ExtensionIdentifier, IExtension, ExtensionType, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
@@ -97,7 +97,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 	constructor(
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
 		@INotificationService private readonly _notificationService: INotificationService,
-		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
 		@ITelemetryService private readonly _telemetryService: ITelemetryService,
 		@IExtensionEnablementService private readonly _extensionEnablementService: IExtensionEnablementService,
 		@IExtensionManagementService private readonly _extensionManagementService: IExtensionManagementService,
@@ -112,7 +112,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 			e.join(this.activateByEvent(`onFileSystem:${e.scheme}`));
 		}));
 
-		this._extensionHostLogsLocation = URI.file(path.join(this._environmentService.logsPath, `exthost${this._windowService.getCurrentWindowId()}`));
+		this._extensionHostLogsLocation = URI.file(path.join(this._environmentService.logsPath, `exthost${this._windowService.windowId}`));
 		this._registry = new ExtensionDescriptionRegistry([]);
 		this._installedExtensionsReady = new Barrier();
 		this._isDev = !this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment;
@@ -189,7 +189,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 	}
 
 	private async _deltaExtensions(_toAdd: IExtension[], _toRemove: string[]): Promise<void> {
-		if (this._windowService.getConfiguration().remoteAuthority) {
+		if (this._environmentService.configuration.remoteAuthority) {
 			return;
 		}
 
@@ -283,7 +283,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 	}
 
 	public canAddExtension(extension: IExtensionDescription): boolean {
-		if (this._windowService.getConfiguration().remoteAuthority) {
+		if (this._environmentService.configuration.remoteAuthority) {
 			return false;
 		}
 
@@ -303,7 +303,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 	}
 
 	public canRemoveExtension(extension: IExtensionDescription): boolean {
-		if (this._windowService.getConfiguration().remoteAuthority) {
+		if (this._environmentService.configuration.remoteAuthority) {
 			return false;
 		}
 
@@ -647,16 +647,14 @@ export class ExtensionService extends Disposable implements IExtensionService {
 
 	private isExtensionUnderDevelopment(extension: IExtensionDescription): boolean {
 		if (this._environmentService.isExtensionDevelopment) {
-			const extDevLoc = this._environmentService.extensionDevelopmentLocationURI;
-			const extLocation = extension.extensionLocation;
-			if (Array.isArray(extDevLoc)) {
-				for (let p of extDevLoc) {
+			const extDevLocs = this._environmentService.extensionDevelopmentLocationURI;
+			if (extDevLocs) {
+				const extLocation = extension.extensionLocation;
+				for (let p of extDevLocs) {
 					if (isEqualOrParent(extLocation, p)) {
 						return true;
 					}
 				}
-			} else if (extDevLoc) {
-				return isEqualOrParent(extLocation, extDevLoc);
 			}
 		}
 		return false;