Move terminate() to IExtHostExtensionService

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

@@ -110,6 +110,7 @@ export abstract class AbstractExtHostExtensionService extends Disposable impleme
 	private readonly _resolvers: { [authorityPrefix: string]: vscode.RemoteAuthorityResolver };
 
 	private _started: boolean;
+	private _isTerminating: boolean = false;
 	private _remoteConnectionData: IRemoteConnectionData | null;
 
 	constructor(
@@ -204,7 +205,7 @@ export abstract class AbstractExtHostExtensionService extends Disposable impleme
 		}
 	}
 
-	public async deactivateAll(): Promise<void> {
+	private async _deactivateAll(): Promise<void> {
 		this._storagePath.onWillDeactivateAll();
 
 		let allPromises: Promise<void>[] = [];
@@ -222,6 +223,40 @@ export abstract class AbstractExtHostExtensionService extends Disposable impleme
 		await Promise.all(allPromises);
 	}
 
+	public terminate(reason: string): void {
+		if (this._isTerminating) {
+			// we are already shutting down...
+			return;
+		}
+		this._isTerminating = true;
+		this._logService.info(`extension host terminating: ${reason}`);
+		this._logService.flush();
+
+		this._extHostTerminalService.dispose();
+		this._activator.dispose();
+
+		errors.setUnexpectedErrorHandler((err) => {
+			this._logService.error(err);
+		});
+
+		// Invalidate all proxies
+		this._extHostContext.dispose();
+
+		const extensionsDeactivated = this._deactivateAll();
+
+		// Give extensions at most 5 seconds to wrap up any async deactivate, then exit
+		Promise.race([timeout(5000), extensionsDeactivated]).finally(() => {
+			if (this._hostUtils.pid) {
+				this._logService.info(`Extension host with pid ${this._hostUtils.pid} exiting with code 0`);
+			} else {
+				this._logService.info(`Extension host exiting with code 0`);
+			}
+			this._logService.flush();
+			this._logService.dispose();
+			this._hostUtils.exit(0);
+		});
+	}
+
 	public isActivated(extensionId: ExtensionIdentifier): boolean {
 		if (this._readyToRunExtensions.isOpen()) {
 			return this._activator.isActivated(extensionId);
@@ -894,10 +929,10 @@ export const IExtHostExtensionService = createDecorator<IExtHostExtensionService
 export interface IExtHostExtensionService extends AbstractExtHostExtensionService {
 	readonly _serviceBrand: undefined;
 	initialize(): Promise<void>;
+	terminate(reason: string): void;
 	getExtension(extensionId: string): Promise<IExtensionDescription | undefined>;
 	isActivated(extensionId: ExtensionIdentifier): boolean;
 	activateByIdWithErrors(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
-	deactivateAll(): Promise<void>;
 	getExtensionExports(extensionId: ExtensionIdentifier): IExtensionAPI | null | undefined;
 	getExtensionRegistry(): Promise<ExtensionDescriptionRegistry>;
 	getExtensionPathIndex(): Promise<TernarySearchTree<URI, IExtensionDescription>>;

src/vs/workbench/api/common/extHostRpcService.ts

@@ -17,12 +17,14 @@ export class ExtHostRpcService implements IExtHostRpcService {
 
 	readonly getProxy: <T>(identifier: ProxyIdentifier<T>) => Proxied<T>;
 	readonly set: <T, R extends T> (identifier: ProxyIdentifier<T>, instance: R) => R;
+	readonly dispose: () => void;
 	readonly assertRegistered: (identifiers: ProxyIdentifier<any>[]) => void;
 	readonly drain: () => Promise<void>;
 
 	constructor(rpcProtocol: IRPCProtocol) {
 		this.getProxy = rpcProtocol.getProxy.bind(rpcProtocol);
 		this.set = rpcProtocol.set.bind(rpcProtocol);
+		this.dispose = rpcProtocol.dispose.bind(rpcProtocol);
 		this.assertRegistered = rpcProtocol.assertRegistered.bind(rpcProtocol);
 		this.drain = rpcProtocol.drain.bind(rpcProtocol);
 	}

src/vs/workbench/api/common/extensionHostMain.ts

@@ -3,10 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { timeout } from 'vs/base/common/async';
 import * as errors from 'vs/base/common/errors';
 import * as performance from 'vs/base/common/performance';
-import { DisposableStore } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { IURITransformer } from 'vs/base/common/uriIpc';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
@@ -23,7 +21,6 @@ import { IInstantiationService } from 'vs/platform/instantiation/common/instanti
 import { IExtHostRpcService, ExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
 import { IURITransformerService, URITransformerService } from 'vs/workbench/api/common/extHostUriTransformerService';
 import { IExtHostExtensionService, IHostUtils } from 'vs/workbench/api/common/extHostExtensionService';
-import { IExtHostTerminalService } from 'vs/workbench/api/common/extHostTerminalService';
 
 export interface IExitFn {
 	(code?: number): any;
@@ -35,12 +32,10 @@ export interface IConsolePatchFn {
 
 export class ExtensionHostMain {
 
-	private _isTerminating: boolean;
 	private readonly _hostUtils: IHostUtils;
 	private readonly _rpcProtocol: RPCProtocol;
 	private readonly _extensionService: IExtHostExtensionService;
 	private readonly _logService: ILogService;
-	private readonly _disposables = new DisposableStore();
 
 	constructor(
 		protocol: IMessagePassingProtocol,
@@ -49,7 +44,6 @@ export class ExtensionHostMain {
 		uriTransformer: IURITransformer | null,
 		messagePorts?: ReadonlyMap<string, MessagePort>
 	) {
-		this._isTerminating = false;
 		this._hostUtils = hostUtils;
 		this._rpcProtocol = new RPCProtocol(protocol, null, uriTransformer);
 
@@ -66,9 +60,6 @@ export class ExtensionHostMain {
 		const instaService: IInstantiationService = new InstantiationService(services, true);
 
 		// ugly self - inject
-		this._disposables.add(instaService.invokeFunction(accessor => accessor.get(IExtHostTerminalService)));
-		this._disposables.add(instaService.invokeFunction(accessor => accessor.get(IExtHostExtensionService)));
-
 		this._logService = instaService.invokeFunction(accessor => accessor.get(ILogService));
 
 		performance.mark(`code/extHost/didCreateServices`);
@@ -125,36 +116,7 @@ export class ExtensionHostMain {
 	}
 
 	terminate(reason: string): void {
-		if (this._isTerminating) {
+		this._extensionService.terminate(reason);
-			// we are already shutting down...
-			return;
-		}
-		this._isTerminating = true;
-		this._logService.info(`extension host terminating: ${reason}`);
-		this._logService.flush();
-
-		this._disposables.dispose();
-
-		errors.setUnexpectedErrorHandler((err) => {
-			this._logService.error(err);
-		});
-
-		// Invalidate all proxies
-		this._rpcProtocol.dispose();
-
-		const extensionsDeactivated = this._extensionService.deactivateAll();
-
-		// Give extensions at most 5 seconds to wrap up any async deactivate, then exit
-		Promise.race([timeout(5000), extensionsDeactivated]).finally(() => {
-			if (this._hostUtils.pid) {
-				this._logService.info(`Extension host with pid ${this._hostUtils.pid} exiting with code 0`);
-			} else {
-				this._logService.info(`Extension host exiting with code 0`);
-			}
-			this._logService.flush();
-			this._logService.dispose();
-			this._hostUtils.exit(0);
-		});
 	}
 
 	private static _transform(initData: IExtensionHostInitData, rpcProtocol: RPCProtocol): IExtensionHostInitData {

src/vs/workbench/api/test/browser/extHostDiagnostics.test.ts

@@ -392,6 +392,7 @@ suite('ExtHostDiagnostics', () => {
 			set(): any {
 				return null;
 			}
+			dispose() { }
 			assertRegistered(): void {
 
 			}
@@ -444,6 +445,7 @@ suite('ExtHostDiagnostics', () => {
 			set(): any {
 				return null;
 			}
+			dispose() { }
 			assertRegistered(): void {
 
 			}
@@ -484,6 +486,7 @@ suite('ExtHostDiagnostics', () => {
 			set(): any {
 				return null;
 			}
+			dispose() { }
 			assertRegistered(): void {
 
 			}

src/vs/workbench/api/test/browser/extHostFileSystemEventService.test.ts

@@ -14,6 +14,7 @@ suite('ExtHostFileSystemEventService', () => {
 		const protocol: IMainContext = {
 			getProxy: () => { return undefined!; },
 			set: undefined!,
+			dispose: undefined!,
 			assertRegistered: undefined!,
 			drain: undefined!
 		};

src/vs/workbench/api/test/browser/extHostWorkspace.test.ts

@@ -290,6 +290,7 @@ suite('ExtHostWorkspace', function () {
 		const protocol: IMainContext = {
 			getProxy: () => { return undefined!; },
 			set: () => { return undefined!; },
+			dispose: () => { },
 			assertRegistered: () => { },
 			drain: () => { return undefined!; },
 		};

src/vs/workbench/api/test/browser/mainThreadDiagnostics.test.ts

@@ -30,6 +30,7 @@ suite('MainThreadDiagnostics', function () {
 			new class implements IExtHostContext {
 				remoteAuthority = '';
 				extensionHostKind = ExtensionHostKind.LocalProcess;
+				dispose() { }
 				assertRegistered() { }
 				set(v: any): any { return null; }
 				getProxy(): any {
@@ -71,6 +72,7 @@ suite('MainThreadDiagnostics', function () {
 				new class implements IExtHostContext {
 					remoteAuthority = '';
 					extensionHostKind = ExtensionHostKind.LocalProcess;
+					dispose() { }
 					assertRegistered() { }
 					set(v: any): any { return null; }
 					getProxy(): any {
@@ -134,6 +136,7 @@ suite('MainThreadDiagnostics', function () {
 				new class implements IExtHostContext {
 					remoteAuthority = '';
 					extensionHostKind = ExtensionHostKind.LocalProcess;
+					dispose() { }
 					assertRegistered() { }
 					set(v: any): any { return null; }
 					getProxy(): any {

src/vs/workbench/api/test/browser/mainThreadTreeViews.test.ts

@@ -67,6 +67,7 @@ suite('MainThreadHostTreeView', function () {
 			new class implements IExtHostContext {
 				remoteAuthority = '';
 				extensionHostKind = ExtensionHostKind.LocalProcess;
+				dispose() { }
 				assertRegistered() { }
 				set(v: any): any { return null; }
 				getProxy(): any {

src/vs/workbench/api/test/common/testRPCProtocol.ts

@@ -21,6 +21,7 @@ export function SingleProxyRPCProtocol(thing: any): IExtHostContext & IExtHostRp
 		set<T, R extends T>(identifier: ProxyIdentifier<T>, value: R): R {
 			return value;
 		},
+		dispose: undefined!,
 		assertRegistered: undefined!,
 		drain: undefined!,
 		extensionHostKind: ExtensionHostKind.LocalProcess
@@ -135,6 +136,10 @@ export class TestRPCProtocol implements IExtHostContext, IExtHostRpcService {
 		});
 	}
 
+	public dispose() {
+		throw new Error('Not implemented!');
+	}
+
 	public assertRegistered(identifiers: ProxyIdentifier<any>[]): void {
 		throw new Error('Not implemented!');
 	}

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

@@ -272,6 +272,7 @@ class ExtensionHostManager extends Disposable implements IExtensionHostManager {
 			extensionHostKind: this.kind,
 			getProxy: <T>(identifier: ProxyIdentifier<T>): Proxied<T> => this._rpcProtocol!.getProxy(identifier),
 			set: <T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R => this._rpcProtocol!.set(identifier, instance),
+			dispose: (): void => this._rpcProtocol!.dispose(),
 			assertRegistered: (identifiers: ProxyIdentifier<any>[]): void => this._rpcProtocol!.assertRegistered(identifiers),
 			drain: (): Promise<void> => this._rpcProtocol!.drain(),
 

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

@@ -26,6 +26,8 @@ export interface IRPCProtocol {
 	 * Wait for the write buffer (if applicable) to become empty.
 	 */
 	drain(): Promise<void>;
+
+	dispose(): void;
 }
 
 export class ProxyIdentifier<T> {