fixes #38796

src/vs/base/common/async.ts

@@ -260,29 +260,35 @@ export class ThrottledDelayer<T> extends Delayer<TPromise<T>> {
 	}
 }
 
-export class PromiseSource<T> {
+/**
+ * A barrier that is initially closed and then becomes opened permanently.
+ */
+export class Barrier {
 
-	private _value: TPromise<T>;
-	private _completeCallback: Function;
-	private _errorCallback: Function;
+	private _isOpen: boolean;
+	private _promise: TPromise<boolean>;
+	private _completePromise: (v: boolean) => void;
 
 	constructor() {
-		this._value = new TPromise<T>((c, e) => {
-			this._completeCallback = c;
-			this._errorCallback = e;
+		this._isOpen = false;
+		this._promise = new TPromise<boolean>((c, e, p) => {
+			this._completePromise = c;
+		}, () => {
+			console.warn('You should really not try to cancel this ready promise!');
 		});
 	}
 
-	get value(): TPromise<T> {
-		return this._value;
+	isOpen(): boolean {
+		return this._isOpen;
 	}
 
-	complete(value?: T): void {
-		this._completeCallback(value);
+	open(): void {
+		this._isOpen = true;
+		this._completePromise(true);
 	}
 
-	error(err?: any): void {
-		this._errorCallback(err);
+	wait(): TPromise<boolean> {
+		return this._promise;
 	}
 }
 

src/vs/code/electron-main/sharedProcess.ts

@@ -10,12 +10,12 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IProcessEnvironment } from 'vs/base/common/platform';
 import { BrowserWindow, ipcMain } from 'electron';
-import { PromiseSource } from 'vs/base/common/async';
 import { ISharedProcess } from 'vs/platform/windows/electron-main/windows';
+import { Barrier } from 'vs/base/common/async';
 
 export class SharedProcess implements ISharedProcess {
 
-	private spawnPromiseSource: PromiseSource<void>;
+	private barrier = new Barrier();
 
 	private window: Electron.BrowserWindow;
 	private disposables: IDisposable[] = [];
@@ -79,19 +79,17 @@ export class SharedProcess implements ISharedProcess {
 	constructor(
 		private environmentService: IEnvironmentService,
 		private userEnv: IProcessEnvironment
-	) {
-		this.spawnPromiseSource = new PromiseSource<void>();
-	}
+	) { }
 
-	public spawn(): void {
-		this.spawnPromiseSource.complete();
+	spawn(): void {
+		this.barrier.open();
 	}
 
-	public whenReady(): TPromise<void> {
-		return this.spawnPromiseSource.value.then(() => this._whenReady);
+	whenReady(): TPromise<void> {
+		return this.barrier.wait().then(() => this._whenReady);
 	}
 
-	public toggle(): void {
+	toggle(): void {
 		if (this.window.isVisible()) {
 			this.hide();
 		} else {
@@ -99,17 +97,17 @@ export class SharedProcess implements ISharedProcess {
 		}
 	}
 
-	public show(): void {
+	show(): void {
 		this.window.show();
 		this.window.webContents.openDevTools();
 	}
 
-	public hide(): void {
+	hide(): void {
 		this.window.webContents.closeDevTools();
 		this.window.hide();
 	}
 
-	public dispose(): void {
+	dispose(): void {
 		this.disposables = dispose(this.disposables);
 	}
 }

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

@@ -15,12 +15,12 @@ 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 { IExtensionMemento, ExtensionsActivator, ActivatedExtension, IExtensionAPI, IExtensionContext, EmptyExtension, IExtensionModule, ExtensionActivationTimesBuilder, ExtensionActivationTimes } from 'vs/workbench/api/node/extHostExtensionActivator';
-import { Barrier } from 'vs/workbench/services/extensions/node/barrier';
 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 { realpath } from 'fs';
 import { TernarySearchTree } from 'vs/base/common/map';
+import { Barrier } from 'vs/base/common/async';
 
 class ExtensionMemento implements IExtensionMemento {
 

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

@@ -26,7 +26,6 @@ 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 { Barrier } from 'vs/workbench/services/extensions/node/barrier';
 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';
@@ -34,6 +33,7 @@ import { Action } from 'vs/base/common/actions';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { mark, time } from 'vs/base/common/performance';
 import { ILifecycleService, LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
+import { Barrier } from 'vs/base/common/async';
 
 const SystemExtensionsRoot = path.normalize(path.join(URI.parse(require.toUrl('')).fsPath, '..', 'extensions'));
 

src/vs/workbench/services/extensions/node/barrier.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 { TPromise } from 'vs/base/common/winjs.base';
-
-/**
- * A barrier that is initially closed and then becomes opened permanently.
- */
-export class Barrier {
-
-	private _isOpen: boolean;
-	private _promise: TPromise<boolean>;
-	private _completePromise: (v: boolean) => void;
-
-	constructor() {
-		this._isOpen = false;
-		this._promise = new TPromise<boolean>((c, e, p) => {
-			this._completePromise = c;
-		}, () => {
-			console.warn('You should really not try to cancel this ready promise!');
-		});
-	}
-
-	public isOpen(): boolean {
-		return this._isOpen;
-	}
-
-	public open(): void {
-		this._isOpen = true;
-		this._completePromise(true);
-	}
-
-	public wait(): TPromise<boolean> {
-		return this._promise;
-	}
-}

src/vs/workbench/services/lifecycle/electron-browser/lifecycleService.ts

@@ -14,7 +14,7 @@ import { ipcRenderer as ipc } from 'electron';
 import Event, { Emitter } from 'vs/base/common/event';
 import { IWindowService } from 'vs/platform/windows/common/windows';
 import { mark } from 'vs/base/common/performance';
-import { Barrier } from 'vs/workbench/services/extensions/node/barrier';
+import { Barrier } from 'vs/base/common/async';
 
 export class LifecycleService implements ILifecycleService {