Add a mechanism to be a customer of the extension host (share lifecycle) and begin reducing usage of IThreadService

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

@@ -73,6 +73,20 @@ export interface IInitData {
 	telemetryInfo: ITelemetryInfo;
 }
 
+export interface IExtHostContext {
+	/**
+	 * Returns a proxy to an object addressable/named in the extension host process.
+	 */
+	get<T>(identifier: ProxyIdentifier<T>): T;
+}
+
+export interface IMainContext {
+	/**
+	 * Returns a proxy to an object addressable/named in the main/renderer process.
+	 */
+	get<T>(identifier: ProxyIdentifier<T>): T;
+}
+
 export interface InstanceSetter<T> {
 	set<R extends T>(instance: T): R;
 }

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

@@ -4,14 +4,13 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { validateConstraint } from 'vs/base/common/types';
 import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
 import { TPromise } from 'vs/base/common/winjs.base';
 import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
 import * as extHostTypeConverter from 'vs/workbench/api/node/extHostTypeConverters';
 import { cloneAndChange } from 'vs/base/common/objects';
-import { MainContext, MainThreadCommandsShape, ExtHostCommandsShape, ObjectIdentifier } from './extHost.protocol';
+import { MainContext, MainThreadCommandsShape, ExtHostCommandsShape, ObjectIdentifier, IMainContext } from './extHost.protocol';
 import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
 import * as modes from 'vs/editor/common/modes';
@@ -35,11 +34,11 @@ export class ExtHostCommands extends ExtHostCommandsShape {
 	private _argumentProcessors: ArgumentProcessor[] = [];
 
 	constructor(
-		threadService: IThreadService,
+		mainContext: IMainContext,
 		heapService: ExtHostHeapService
 	) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadCommands);
+		this._proxy = mainContext.get(MainContext.MainThreadCommands);
 		this._converter = new CommandsConverter(this, heapService);
 	}
 

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

@@ -4,17 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { MainContext, MainThreadCredentialsShape, ExtHostCredentialsShape } from 'vs/workbench/api/node/extHost.protocol';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
+import { MainContext, MainThreadCredentialsShape, ExtHostCredentialsShape, IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 
 
 export class ExtHostCredentials extends ExtHostCredentialsShape {
 
 	private _proxy: MainThreadCredentialsShape;
 
-	constructor(threadService: IThreadService) {
+	constructor(mainContext: IMainContext) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadCredentials);
+		this._proxy = mainContext.get(MainContext.MainThreadCredentials);
 	};
 
 	readSecret(service: string, account: string): Thenable<string | undefined> {

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

@@ -7,8 +7,7 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import Event, { Emitter } from 'vs/base/common/event';
 
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, MainThreadDebugServiceShape, ExtHostDebugServiceShape, DebugSessionUUID } from 'vs/workbench/api/node/extHost.protocol';
+import { MainContext, MainThreadDebugServiceShape, ExtHostDebugServiceShape, DebugSessionUUID, IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 
 import * as vscode from 'vscode';
 import URI from 'vs/base/common/uri';
@@ -35,7 +34,7 @@ export class ExtHostDebugService extends ExtHostDebugServiceShape {
 	get onDidReceiveDebugSessionCustomEvent(): Event<vscode.DebugSessionCustomEvent> { return this._onDidReceiveDebugSessionCustomEvent.event; }
 
 
-	constructor(threadService: IThreadService) {
+	constructor(mainContext: IMainContext) {
 		super();
 
 		this._onDidStartDebugSession = new Emitter<vscode.DebugSession>();
@@ -43,7 +42,7 @@ export class ExtHostDebugService extends ExtHostDebugServiceShape {
 		this._onDidChangeActiveDebugSession = new Emitter<vscode.DebugSession>();
 		this._onDidReceiveDebugSessionCustomEvent = new Emitter<vscode.DebugSessionCustomEvent>();
 
-		this._debugServiceProxy = threadService.get(MainContext.MainThreadDebugService);
+		this._debugServiceProxy = mainContext.get(MainContext.MainThreadDebugService);
 	}
 
 	public startDebugging(folder: vscode.WorkspaceFolder | undefined, nameOrConfig: string | vscode.DebugConfiguration): TPromise<boolean> {

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

@@ -5,12 +5,11 @@
 'use strict';
 
 import { localize } from 'vs/nls';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { IMarkerData } from 'vs/platform/markers/common/markers';
 import URI from 'vs/base/common/uri';
 import Severity from 'vs/base/common/severity';
 import * as vscode from 'vscode';
-import { MainContext, MainThreadDiagnosticsShape, ExtHostDiagnosticsShape } from './extHost.protocol';
+import { MainContext, MainThreadDiagnosticsShape, ExtHostDiagnosticsShape, IMainContext } from './extHost.protocol';
 import { DiagnosticSeverity } from './extHostTypes';
 import { mergeSort } from 'vs/base/common/arrays';
 
@@ -224,9 +223,9 @@ export class ExtHostDiagnostics extends ExtHostDiagnosticsShape {
 	private _proxy: MainThreadDiagnosticsShape;
 	private _collections: DiagnosticCollection[];
 
-	constructor(threadService: IThreadService) {
+	constructor(mainContext: IMainContext) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadDiagnostics);
+		this._proxy = mainContext.get(MainContext.MainThreadDiagnostics);
 		this._collections = [];
 	}
 

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

@@ -6,7 +6,6 @@
 
 import { onUnexpectedError } from 'vs/base/common/errors';
 import * as editorCommon from 'vs/editor/common/editorCommon';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import Event, { Emitter } from 'vs/base/common/event';
 import URI from 'vs/base/common/uri';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
@@ -16,7 +15,7 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import * as vscode from 'vscode';
 import { asWinJsPromise } from 'vs/base/common/async';
 import { TextSource } from 'vs/editor/common/model/textSource';
-import { MainContext, MainThreadDocumentsShape, ExtHostDocumentsShape } from './extHost.protocol';
+import { MainContext, MainThreadDocumentsShape, ExtHostDocumentsShape, IMainContext } from './extHost.protocol';
 import { ExtHostDocumentData, setWordDefinitionFor } from './extHostDocumentData';
 import { ExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors';
 import { IModelChangedEvent } from 'vs/editor/common/model/mirrorModel';
@@ -42,9 +41,9 @@ export class ExtHostDocuments extends ExtHostDocumentsShape {
 	private _documentContentProviders = new Map<number, vscode.TextDocumentContentProvider>();
 
 
-	constructor(threadService: IThreadService, documentsAndEditors: ExtHostDocumentsAndEditors) {
+	constructor(mainContext: IMainContext, documentsAndEditors: ExtHostDocumentsAndEditors) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadDocuments);
+		this._proxy = mainContext.get(MainContext.MainThreadDocuments);
 		this._documentsAndEditors = documentsAndEditors;
 
 		this._toDispose = [

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

@@ -6,10 +6,9 @@
 
 import Event, { Emitter } from 'vs/base/common/event';
 import { dispose } from 'vs/base/common/lifecycle';
-import { MainContext, ExtHostDocumentsAndEditorsShape, IDocumentsAndEditorsDelta } from './extHost.protocol';
+import { MainContext, ExtHostDocumentsAndEditorsShape, IDocumentsAndEditorsDelta, IMainContext } from './extHost.protocol';
 import { ExtHostDocumentData } from './extHostDocumentData';
 import { ExtHostTextEditor } from './extHostTextEditor';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import * as assert from 'assert';
 import * as typeConverters from './extHostTypeConverters';
 
@@ -30,7 +29,7 @@ export class ExtHostDocumentsAndEditors extends ExtHostDocumentsAndEditorsShape
 	readonly onDidChangeActiveTextEditor: Event<ExtHostTextEditor> = this._onDidChangeActiveTextEditor.event;
 
 	constructor(
-		@IThreadService private _threadService: IThreadService
+		private readonly _mainContext: IMainContext
 	) {
 		super();
 	}
@@ -54,7 +53,7 @@ export class ExtHostDocumentsAndEditors extends ExtHostDocumentsAndEditorsShape
 				assert.ok(!this._documents.has(data.url.toString()), `document '${data.url} already exists!'`);
 
 				const documentData = new ExtHostDocumentData(
-					this._threadService.get(MainContext.MainThreadDocuments),
+					this._mainContext.get(MainContext.MainThreadDocuments),
 					data.url,
 					data.lines,
 					data.EOL,
@@ -82,7 +81,7 @@ export class ExtHostDocumentsAndEditors extends ExtHostDocumentsAndEditorsShape
 
 				const documentData = this._documents.get(data.document.toString());
 				const editor = new ExtHostTextEditor(
-					this._threadService.get(MainContext.MainThreadEditors),
+					this._mainContext.get(MainContext.MainThreadEditors),
 					data.id,
 					documentData,
 					data.selections.map(typeConverters.toSelection),

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

@@ -7,7 +7,6 @@
 import URI from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { mixin } from 'vs/base/common/objects';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import * as vscode from 'vscode';
 import * as TypeConverters from 'vs/workbench/api/node/extHostTypeConverters';
 import { Range, Disposable, CompletionList, CompletionItem, SnippetString } from 'vs/workbench/api/node/extHostTypes';
@@ -19,7 +18,7 @@ import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/node/extHos
 import { ExtHostDiagnostics } from 'vs/workbench/api/node/extHostDiagnostics';
 import { IWorkspaceSymbolProvider } from 'vs/workbench/parts/search/common/search';
 import { asWinJsPromise } from 'vs/base/common/async';
-import { MainContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, ObjectIdentifier, IRawColorInfo, IRawColorFormatMap } from './extHost.protocol';
+import { MainContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, ObjectIdentifier, IRawColorInfo, IRawColorFormatMap, IMainContext } from './extHost.protocol';
 import { regExpLeadsToEndlessLoop } from 'vs/base/common/strings';
 import { IPosition } from 'vs/editor/common/core/position';
 import { IRange } from 'vs/editor/common/core/range';
@@ -737,14 +736,14 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
 	private _colorFormatCache = new Map<string, number>();
 
 	constructor(
-		threadService: IThreadService,
+		mainContext: IMainContext,
 		documents: ExtHostDocuments,
 		commands: ExtHostCommands,
 		heapMonitor: ExtHostHeapService,
 		diagnostics: ExtHostDiagnostics
 	) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadLanguageFeatures);
+		this._proxy = mainContext.get(MainContext.MainThreadLanguageFeatures);
 		this._documents = documents;
 		this._commands = commands;
 		this._heapService = heapMonitor;

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

@@ -5,17 +5,16 @@
 'use strict';
 
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, MainThreadLanguagesShape } from './extHost.protocol';
+import { MainContext, MainThreadLanguagesShape, IMainContext } from './extHost.protocol';
 
 export class ExtHostLanguages {
 
 	private _proxy: MainThreadLanguagesShape;
 
 	constructor(
-		threadService: IThreadService
+		mainContext: IMainContext
 	) {
-		this._proxy = threadService.get(MainContext.MainThreadLanguages);
+		this._proxy = mainContext.get(MainContext.MainThreadLanguages);
 	}
 
 	getLanguages(): TPromise<string[]> {

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

@@ -4,10 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import Severity from 'vs/base/common/severity';
 import vscode = require('vscode');
-import { MainContext, MainThreadMessageServiceShape } from './extHost.protocol';
+import { MainContext, MainThreadMessageServiceShape, IMainContext } from './extHost.protocol';
 
 const emptyMessageOptions: vscode.MessageOptions = Object.create(null);
 
@@ -27,8 +26,8 @@ export class ExtHostMessageService {
 
 	private _proxy: MainThreadMessageServiceShape;
 
-	constructor(threadService: IThreadService) {
-		this._proxy = threadService.get(MainContext.MainThreadMessageService);
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.get(MainContext.MainThreadMessageService);
 	}
 
 	showMessage(severity: Severity, message: string, optionsOrFirstItem: vscode.MessageOptions | string, rest: string[]): Thenable<string | undefined>;

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

@@ -4,8 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, MainThreadOutputServiceShape } from './extHost.protocol';
+import { MainContext, MainThreadOutputServiceShape, IMainContext } from './extHost.protocol';
 import * as vscode from 'vscode';
 
 export class ExtHostOutputChannel implements vscode.OutputChannel {
@@ -64,8 +63,8 @@ export class ExtHostOutputService {
 
 	private _proxy: MainThreadOutputServiceShape;
 
-	constructor(threadService: IThreadService) {
-		this._proxy = threadService.get(MainContext.MainThreadOutputService);
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.get(MainContext.MainThreadOutputService);
 	}
 
 	createOutputChannel(name: string): vscode.OutputChannel {

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

@@ -7,9 +7,8 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import { wireCancellationToken } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { QuickPickOptions, QuickPickItem, InputBoxOptions } from 'vscode';
-import { MainContext, MainThreadQuickOpenShape, ExtHostQuickOpenShape, MyQuickPickItems } from './extHost.protocol';
+import { MainContext, MainThreadQuickOpenShape, ExtHostQuickOpenShape, MyQuickPickItems, IMainContext } from './extHost.protocol';
 
 export type Item = string | QuickPickItem;
 
@@ -19,9 +18,9 @@ export class ExtHostQuickOpen extends ExtHostQuickOpenShape {
 	private _onDidSelectItem: (handle: number) => void;
 	private _validateInput: (input: string) => string;
 
-	constructor(threadService: IThreadService) {
+	constructor(mainContext: IMainContext) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadQuickOpen);
+		this._proxy = mainContext.get(MainContext.MainThreadQuickOpen);
 	}
 
 	showQuickPick(itemsOrItemsPromise: string[] | Thenable<string[]>, options?: QuickPickOptions, token?: CancellationToken): Thenable<string | undefined>;

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

@@ -8,9 +8,8 @@ import URI from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import Event, { Emitter } from 'vs/base/common/event';
 import { asWinJsPromise } from 'vs/base/common/async';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/node/extHostCommands';
-import { MainContext, MainThreadSCMShape, SCMRawResource } from './extHost.protocol';
+import { MainContext, MainThreadSCMShape, SCMRawResource, IMainContext } from './extHost.protocol';
 import * as vscode from 'vscode';
 
 function getIconPath(decorations: vscode.SourceControlResourceThemableDecorations) {
@@ -277,10 +276,10 @@ export class ExtHostSCM {
 	get inputBox(): ExtHostSCMInputBox { return this._inputBox; }
 
 	constructor(
-		threadService: IThreadService,
+		mainContext: IMainContext,
 		private _commands: ExtHostCommands
 	) {
-		this._proxy = threadService.get(MainContext.MainThreadSCM);
+		this._proxy = mainContext.get(MainContext.MainThreadSCM);
 		this._inputBox = new ExtHostSCMInputBox(this._proxy);
 
 		_commands.registerArgumentProcessor({

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

@@ -4,11 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/platform/statusbar/common/statusbar';
 import { StatusBarAlignment as ExtHostStatusBarAlignment, Disposable, ThemeColor } from './extHostTypes';
 import { StatusBarItem, StatusBarAlignment } from 'vscode';
-import { MainContext, MainThreadStatusBarShape } from './extHost.protocol';
+import { MainContext, MainThreadStatusBarShape, IMainContext } from './extHost.protocol';
 
 export class ExtHostStatusBarEntry implements StatusBarItem {
 	private static ID_GEN = 0;
@@ -163,8 +162,8 @@ export class ExtHostStatusBar {
 	private _proxy: MainThreadStatusBarShape;
 	private _statusMessage: StatusBarMessage;
 
-	constructor(threadService: IThreadService) {
-		this._proxy = threadService.get(MainContext.MainThreadStatusBar);
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.get(MainContext.MainThreadStatusBar);
 		this._statusMessage = new StatusBarMessage(this);
 	}
 

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

@@ -5,15 +5,14 @@
 'use strict';
 
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, MainThreadStorageShape } from './extHost.protocol';
+import { MainContext, MainThreadStorageShape, IMainContext } from './extHost.protocol';
 
 export class ExtHostStorage {
 
 	private _proxy: MainThreadStorageShape;
 
-	constructor(threadService: IThreadService) {
-		this._proxy = threadService.get(MainContext.MainThreadStorage);
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.get(MainContext.MainThreadStorage);
 	}
 
 	getValue<T>(shared: boolean, key: string, defaultValue?: T): TPromise<T> {

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

@@ -12,8 +12,7 @@ import { asWinJsPromise } from 'vs/base/common/async';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import * as TaskSystem from 'vs/workbench/parts/tasks/common/tasks';
 
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, MainThreadTaskShape, ExtHostTaskShape } from 'vs/workbench/api/node/extHost.protocol';
+import { MainContext, MainThreadTaskShape, ExtHostTaskShape, IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 
 import * as types from 'vs/workbench/api/node/extHostTypes';
 import * as vscode from 'vscode';
@@ -402,9 +401,9 @@ export class ExtHostTask extends ExtHostTaskShape {
 	private _handleCounter: number;
 	private _handlers: Map<number, HandlerData>;
 
-	constructor(threadService: IThreadService) {
+	constructor(mainContext: IMainContext) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadTask);
+		this._proxy = mainContext.get(MainContext.MainThreadTask);
 		this._handleCounter = 0;
 		this._handlers = new Map<number, HandlerData>();
 	};

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

@@ -7,8 +7,7 @@
 import { notImplemented } from 'vs/base/common/errors';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { ITelemetryService, ITelemetryInfo } from 'vs/platform/telemetry/common/telemetry';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, MainThreadTelemetryShape } from './extHost.protocol';
+import { MainContext, MainThreadTelemetryShape, IMainContext } from './extHost.protocol';
 
 export class RemoteTelemetryService implements ITelemetryService {
 
@@ -17,9 +16,9 @@ export class RemoteTelemetryService implements ITelemetryService {
 	private _name: string;
 	private _proxy: MainThreadTelemetryShape;
 
-	constructor(name: string, threadService: IThreadService) {
+	constructor(name: string, mainContext: IMainContext) {
 		this._name = name;
-		this._proxy = threadService.get(MainContext.MainThreadTelemetry);
+		this._proxy = mainContext.get(MainContext.MainThreadTelemetry);
 	}
 
 	get isOptedIn(): boolean {

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

@@ -7,8 +7,7 @@
 import vscode = require('vscode');
 import { TPromise, TValueCallback } from 'vs/base/common/winjs.base';
 import Event, { Emitter } from 'vs/base/common/event';
-import { ExtHostTerminalServiceShape, MainContext, MainThreadTerminalServiceShape } from './extHost.protocol';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
+import { ExtHostTerminalServiceShape, MainContext, MainThreadTerminalServiceShape, IMainContext } from './extHost.protocol';
 
 export class ExtHostTerminal implements vscode.Terminal {
 
@@ -101,9 +100,9 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 	private _proxy: MainThreadTerminalServiceShape;
 	private _terminals: ExtHostTerminal[];
 
-	constructor(threadService: IThreadService) {
+	constructor(mainContext: IMainContext) {
 		this._onDidCloseTerminal = new Emitter<vscode.Terminal>();
-		this._proxy = threadService.get(MainContext.MainThreadTerminalService);
+		this._proxy = mainContext.get(MainContext.MainThreadTerminalService);
 		this._terminals = [];
 	}
 

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

@@ -8,13 +8,12 @@ import URI from 'vs/base/common/uri';
 import Event, { Emitter } from 'vs/base/common/event';
 import { toThenable } from 'vs/base/common/async';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { TextEditorSelectionChangeKind } from './extHostTypes';
 import * as TypeConverters from './extHostTypeConverters';
 import { TextEditorDecorationType, ExtHostTextEditor } from './extHostTextEditor';
 import { ExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors';
 import { Position as EditorPosition } from 'vs/platform/editor/common/editor';
-import { MainContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextDocumentShowOptions, ITextEditorPositionData, IResolvedTextEditorConfiguration, ISelectionChangeEvent } from './extHost.protocol';
+import { MainContext, MainThreadEditorsShape, ExtHostEditorsShape, ITextDocumentShowOptions, ITextEditorPositionData, IResolvedTextEditorConfiguration, ISelectionChangeEvent, IMainContext } from './extHost.protocol';
 import * as vscode from 'vscode';
 
 export class ExtHostEditors extends ExtHostEditorsShape {
@@ -36,11 +35,11 @@ export class ExtHostEditors extends ExtHostEditorsShape {
 	private _extHostDocumentsAndEditors: ExtHostDocumentsAndEditors;
 
 	constructor(
-		threadService: IThreadService,
+		mainContext: IMainContext,
 		extHostDocumentsAndEditors: ExtHostDocumentsAndEditors,
 	) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadEditors);
+		this._proxy = mainContext.get(MainContext.MainThreadEditors);
 		this._extHostDocumentsAndEditors = extHostDocumentsAndEditors;
 
 		this._extHostDocumentsAndEditors.onDidChangeVisibleTextEditors(e => this._onDidChangeVisibleTextEditors.fire(e));

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

@@ -10,11 +10,10 @@ import { normalize } from 'vs/base/common/paths';
 import { delta } from 'vs/base/common/arrays';
 import { relative, basename } from 'path';
 import { Workspace } from 'vs/platform/workspace/common/workspace';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
 import { IResourceEdit } from 'vs/editor/common/services/bulkEdit';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { fromRange, EndOfLine } from 'vs/workbench/api/node/extHostTypeConverters';
-import { IWorkspaceData, ExtHostWorkspaceShape, MainContext, MainThreadWorkspaceShape } from './extHost.protocol';
+import { IWorkspaceData, ExtHostWorkspaceShape, MainContext, MainThreadWorkspaceShape, IMainContext } from './extHost.protocol';
 import * as vscode from 'vscode';
 import { compare } from "vs/base/common/strings";
 import { asWinJsPromise } from 'vs/base/common/async';
@@ -76,9 +75,9 @@ export class ExtHostWorkspace extends ExtHostWorkspaceShape {
 
 	readonly onDidChangeWorkspace: Event<vscode.WorkspaceFoldersChangeEvent> = this._onDidChangeWorkspace.event;
 
-	constructor(threadService: IThreadService, data: IWorkspaceData) {
+	constructor(mainContext: IMainContext, data: IWorkspaceData) {
 		super();
-		this._proxy = threadService.get(MainContext.MainThreadWorkspace);
+		this._proxy = mainContext.get(MainContext.MainThreadWorkspace);
 		this._workspace = Workspace2.fromData(data);
 	}