Simplify AbstractThreadService usage (#36972)

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -46,10 +46,9 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import * as vscode from 'vscode';
 import * as paths from 'vs/base/common/paths';
-import { MainContext, ExtHostContext, IInitData } from './extHost.protocol';
+import { MainContext, ExtHostContext, IInitData, IExtHostContext } from './extHost.protocol';
 import * as languageConfiguration from 'vs/editor/common/modes/languageConfiguration';
 import { TextEditorCursorStyle } from 'vs/editor/common/config/editorOptions';
-import { ExtHostThreadService } from 'vs/workbench/services/thread/node/extHostThreadService';
 import { ProxyIdentifier } from 'vs/workbench/services/thread/common/threadService';
 import { ExtHostDialogs } from 'vs/workbench/api/node/extHostDialogs';
 import { ExtHostFileSystem } from 'vs/workbench/api/node/extHostFileSystem';
@@ -79,7 +78,7 @@ function proposedApiFunction<T>(extension: IExtensionDescription, fn: T): T {
  */
 export function createApiFactory(
 	initData: IInitData,
-	threadService: ExtHostThreadService,
+	threadService: IExtHostContext,
 	extHostWorkspace: ExtHostWorkspace,
 	extHostConfiguration: ExtHostConfiguration,
 	extensionService: ExtHostExtensionService,

src/vs/workbench/api/node/extHost.protocol.ts

@@ -100,6 +100,11 @@ export interface IExtHostContext {
 	 * Register manually created instance.
 	 */
 	set<T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R;
+
+	/**
+	 * Assert these identifiers are already registered via `.set`.
+	 */
+	assertRegistered(identifiers: ProxyIdentifier<any>[]): void;
 }
 
 export interface IMainContext {

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

@@ -13,9 +13,8 @@ import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/n
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { ExtHostStorage } from 'vs/workbench/api/node/extHostStorage';
 import { createApiFactory, initializeExtensionApi } from 'vs/workbench/api/node/extHost.api.impl';
-import { MainContext, MainThreadExtensionServiceShape, IWorkspaceData, IEnvironment, IInitData, ExtHostExtensionServiceShape, MainThreadTelemetryShape } from './extHost.protocol';
+import { MainContext, MainThreadExtensionServiceShape, IWorkspaceData, IEnvironment, IInitData, ExtHostExtensionServiceShape, MainThreadTelemetryShape, IExtHostContext } from './extHost.protocol';
 import { IExtensionMemento, ExtensionsActivator, ActivatedExtension, IExtensionAPI, IExtensionContext, EmptyExtension, IExtensionModule, ExtensionActivationTimesBuilder, ExtensionActivationTimes, ExtensionActivationReason, ExtensionActivatedByEvent } from 'vs/workbench/api/node/extHostExtensionActivator';
-import { ExtHostThreadService } from 'vs/workbench/services/thread/node/extHostThreadService';
 import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
 import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
 import { TernarySearchTree } from 'vs/base/common/map';
@@ -112,7 +111,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 
 	private readonly _barrier: Barrier;
 	private readonly _registry: ExtensionDescriptionRegistry;
-	private readonly _threadService: ExtHostThreadService;
+	private readonly _threadService: IExtHostContext;
 	private readonly _mainThreadTelemetry: MainThreadTelemetryShape;
 	private readonly _storage: ExtHostStorage;
 	private readonly _storagePath: ExtensionStoragePath;
@@ -124,7 +123,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	 * This class is constructed manually because it is a service, so it doesn't use any ctor injection
 	 */
 	constructor(initData: IInitData,
-		threadService: ExtHostThreadService,
+		threadService: IExtHostContext,
 		extHostWorkspace: ExtHostWorkspace,
 		extHostConfiguration: ExtHostConfiguration,
 		logService: ILogService

src/vs/workbench/api/node/extHostWindow.ts

@@ -5,8 +5,7 @@
 'use strict';
 
 import Event, { Emitter } from 'vs/base/common/event';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { ExtHostWindowShape, MainContext, MainThreadWindowShape } from './extHost.protocol';
+import { ExtHostWindowShape, MainContext, MainThreadWindowShape, IMainContext } from './extHost.protocol';
 import { WindowState } from 'vscode';
 
 export class ExtHostWindow implements ExtHostWindowShape {
@@ -23,8 +22,8 @@ export class ExtHostWindow implements ExtHostWindowShape {
 	private _state = ExtHostWindow.InitialState;
 	get state(): WindowState { return this._state; }
 
-	constructor(threadService: IThreadService) {
-		this._proxy = threadService.get(MainContext.MainThreadWindow);
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.get(MainContext.MainThreadWindow);
 		this._proxy.$getWindowVisibility().then(isFocused => this.$onDidChangeWindowFocus(isFocused));
 	}
 
@@ -36,4 +35,4 @@ export class ExtHostWindow implements ExtHostWindowShape {
 		this._state = { ...this._state, focused };
 		this._onDidChangeWindowState.fire(this._state);
 	}
-}
\ No newline at end of file
+}

src/vs/workbench/node/extensionHostMain.ts

@@ -9,9 +9,7 @@ import nls = require('vs/nls');
 import pfs = require('vs/base/node/pfs');
 import { TPromise } from 'vs/base/common/winjs.base';
 import { join } from 'path';
-import { RPCProtocol } from 'vs/workbench/services/extensions/node/rpcProtocol';
 import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
-import { ExtHostThreadService } from 'vs/workbench/services/thread/node/extHostThreadService';
 import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
 import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
@@ -27,6 +25,7 @@ import { createLogService } from 'vs/platform/log/node/spdlogService';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
+import { AbstractThreadService } from 'vs/workbench/services/thread/node/abstractThreadService';
 
 // const nativeExit = process.exit.bind(process);
 function patchProcess(allowExit: boolean) {
@@ -89,7 +88,7 @@ export class ExtensionHostMain {
 		patchProcess(allowExit);
 
 		// services
-		const threadService = new ExtHostThreadService(new RPCProtocol(protocol));
+		const threadService = new AbstractThreadService(protocol, false);
 		const extHostWorkspace = new ExtHostWorkspace(threadService, initData.workspace);
 		const environmentService = new EnvironmentService(initData.args, initData.execPath);
 		this._logService = createLogService(`exthost${initData.windowId}`, environmentService);

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

@@ -28,7 +28,6 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
 import { IStorageService } from 'vs/platform/storage/common/storage';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ExtensionHostProcessWorker } from 'vs/workbench/services/extensions/electron-browser/extensionHost';
-import { MainThreadService } from 'vs/workbench/services/thread/electron-browser/threadService';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { ExtHostCustomersRegistry } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { IWindowService } from 'vs/platform/windows/common/windows';
@@ -42,6 +41,7 @@ import { ExtensionHostProfiler } from 'vs/workbench/services/extensions/electron
 import { ReloadWindowAction } from 'vs/workbench/electron-browser/actions';
 import product from 'vs/platform/node/product';
 import * as strings from 'vs/base/common/strings';
+import { AbstractThreadService } from 'vs/workbench/services/thread/node/abstractThreadService';
 
 const SystemExtensionsRoot = path.normalize(path.join(URI.parse(require.toUrl('')).fsPath, '..', 'extensions'));
 
@@ -85,7 +85,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 	private _extensionHostProcessActivationTimes: { [id: string]: ActivationTimes; };
 	private _extensionHostExtensionRuntimeErrors: { [id: string]: Error[]; };
 	private _extensionHostProcessWorker: ExtensionHostProcessWorker;
-	private _extensionHostProcessThreadService: MainThreadService;
+	private _extensionHostProcessThreadService: AbstractThreadService;
 	private _extensionHostProcessCustomers: IDisposable[];
 	/**
 	 * winjs believes a proxy is a promise because it has a `then` method, so wrap the result in an object.
@@ -238,7 +238,7 @@ export class ExtensionService extends Disposable implements IExtensionService {
 			protocol = asLoggingProtocol(protocol);
 		}
 
-		this._extensionHostProcessThreadService = new MainThreadService(protocol);
+		this._extensionHostProcessThreadService = new AbstractThreadService(protocol, true);
 		const extHostContext: IExtHostContext = this._extensionHostProcessThreadService;
 
 		// Named customers

src/vs/workbench/services/thread/common/threadService.ts

@@ -4,23 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-export interface IThreadService {
-	/**
-	 * Always returns a proxy.
-	 */
-	get<T>(identifier: ProxyIdentifier<T>): T;
-
-	/**
-	 * Register instance.
-	 */
-	set<T, R extends T>(identifier: ProxyIdentifier<T>, value: R): R;
-
-	/**
-	 * Assert these identifiers are already registered via `.set`.
-	 */
-	assertRegistered(identifiers: ProxyIdentifier<any>[]): void;
-}
-
 export class ProxyIdentifier<T> {
 	_proxyIdentifierBrand: void;
 	_suppressCompilerUnusedWarning: T;

src/vs/workbench/services/thread/electron-browser/threadService.ts

-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-
-import { RPCProtocol } from 'vs/workbench/services/extensions/node/rpcProtocol';
-import { AbstractThreadService } from 'vs/workbench/services/thread/node/abstractThreadService';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
-
-export class MainThreadService extends AbstractThreadService implements IThreadService {
-	constructor(protocol: IMessagePassingProtocol) {
-		super(new RPCProtocol(protocol), true);
-	}
-}

src/vs/workbench/services/thread/node/abstractThreadService.ts

@@ -8,18 +8,19 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { IDispatcher, RPCProtocol } from 'vs/workbench/services/extensions/node/rpcProtocol';
 import { ProxyIdentifier } from 'vs/workbench/services/thread/common/threadService';
 import { CharCode } from 'vs/base/common/charCode';
+import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 
 declare var Proxy: any; // TODO@TypeScript
 
-export abstract class AbstractThreadService implements IDispatcher {
+export class AbstractThreadService implements IDispatcher {
 
 	private readonly _rpcProtocol: RPCProtocol;
 	private readonly _isMain: boolean;
 	protected readonly _locals: { [id: string]: any; };
 	private readonly _proxies: { [id: string]: any; } = Object.create(null);
 
-	constructor(rpcProtocol: RPCProtocol, isMain: boolean) {
-		this._rpcProtocol = rpcProtocol;
+	constructor(protocol: IMessagePassingProtocol, isMain: boolean) {
+		this._rpcProtocol = new RPCProtocol(protocol);
 		this._isMain = isMain;
 		this._locals = Object.create(null);
 		this._proxies = Object.create(null);

src/vs/workbench/services/thread/node/extHostThreadService.ts

-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-'use strict';
-
-import { RPCProtocol } from 'vs/workbench/services/extensions/node/rpcProtocol';
-import { AbstractThreadService } from 'vs/workbench/services/thread/node/abstractThreadService';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-
-export class ExtHostThreadService extends AbstractThreadService implements IThreadService {
-	constructor(rpcProtocol: RPCProtocol) {
-		super(rpcProtocol, false);
-	}
-}

src/vs/workbench/test/electron-browser/api/testThreadService.ts

@@ -6,9 +6,9 @@
 'use strict';
 
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IThreadService, ProxyIdentifier } from 'vs/workbench/services/thread/common/threadService';
+import { ProxyIdentifier } from 'vs/workbench/services/thread/common/threadService';
 
-export function OneGetThreadService(thing: any): IThreadService {
+export function OneGetThreadService(thing: any) {
 	return {
 		get<T>(): T {
 			return thing;
@@ -75,7 +75,7 @@ export abstract class AbstractTestThreadService {
 	protected abstract _callOnRemote(proxyId: string, path: string, args: any[]): TPromise<any>;
 }
 
-export class TestThreadService extends AbstractTestThreadService implements IThreadService {
+export class TestThreadService extends AbstractTestThreadService {
 	constructor(isMainProcess: boolean = false) {
 		super(isMainProcess);
 	}