shared process - add separate whenIpcReady

Author: bpasero

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -100,7 +100,7 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 
 	const onExit = () => disposables.dispose();
 	process.once('exit', onExit);
-	ipcRenderer.once('handshake:goodbye', onExit);
+	ipcRenderer.once('handshake:mainprocess-goodbye', onExit);
 
 	disposables.add(server);
 
@@ -271,13 +271,19 @@ function setupIPC(hook: string): Promise<Server> {
 }
 
 async function handshake(configuration: ISharedProcessConfiguration): Promise<void> {
+
+	// shared process -> main: give me payload for IPC connection
+	// main -> shared process: payload for IPC connection
 	const data = await new Promise<ISharedProcessInitData>(c => {
-		ipcRenderer.once('handshake:hey there', (_: any, r: ISharedProcessInitData) => c(r));
-		ipcRenderer.send('handshake:hello');
+		ipcRenderer.once('handshake:main-payload', (_: any, r: ISharedProcessInitData) => c(r));
+		ipcRenderer.send('handshake:sharedprocess-hello');
 	});
 
+	// shared process => main: IPC connection established
 	const server = await setupIPC(data.sharedIPCHandle);
+	ipcRenderer.send('handshake:sharedprocess-ipc-ready');
 
+	// shared process => main: initialization done
 	await main(server, data, configuration);
-	ipcRenderer.send('handshake:im ready');
+	ipcRenderer.send('handshake:sharedprocess-init-ready');
 }

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

@@ -364,7 +364,8 @@ export class CodeApplication extends Disposable {
 
 		// Spawn shared process after the first window has opened and 3s have passed
 		const sharedProcess = this.instantiationService.createInstance(SharedProcess, machineId, this.userEnv);
-		const sharedProcessClient = sharedProcess.whenReady().then(() => connect(this.environmentService.sharedIPCHandle, 'main'));
+		const sharedProcessClient = sharedProcess.whenIpcReady().then(() => connect(this.environmentService.sharedIPCHandle, 'main'));
+		const sharedProcessReady = sharedProcess.whenReady().then(() => sharedProcessClient);
 		this.lifecycleMainService.when(LifecycleMainPhase.AfterWindowOpen).then(() => {
 			this._register(new RunOnceScheduler(async () => {
 				const userEnv = await getShellEnvironment(this.logService, this.environmentService);
@@ -374,7 +375,7 @@ export class CodeApplication extends Disposable {
 		});
 
 		// Services
-		const appInstantiationService = await this.createServices(machineId, trueMachineId, sharedProcess, sharedProcessClient);
+		const appInstantiationService = await this.createServices(machineId, trueMachineId, sharedProcess, sharedProcessReady);
 
 		// Create driver
 		if (this.environmentService.driverHandle) {
@@ -388,7 +389,7 @@ export class CodeApplication extends Disposable {
 		this._register(new ProxyAuthHandler());
 
 		// Open Windows
-		const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessClient));
+		const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessReady));
 
 		// Post Open Windows Tasks
 		this.afterWindowOpen();

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

@@ -21,17 +21,21 @@ export class SharedProcess implements ISharedProcess {
 
 	private window: BrowserWindow | null = null;
 
+	private readonly _whenReady: Promise<void>;
+
 	constructor(
 		private readonly machineId: string,
 		private userEnv: NodeJS.ProcessEnv,
 		@IEnvironmentService private readonly environmentService: IEnvironmentService,
 		@ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService,
 		@ILogService private readonly logService: ILogService,
 		@IThemeMainService private readonly themeMainService: IThemeMainService
-	) { }
+	) {
+		this._whenReady = new Promise<void>(c => ipcMain.once('handshake:sharedprocess-init-ready', () => c(undefined)));
+	}
 
 	@memoize
-	private get _whenReady(): Promise<void> {
+	private get _whenIpcReady(): Promise<void> {
 		this.window = new BrowserWindow({
 			show: false,
 			backgroundColor: this.themeMainService.getBackgroundColor(),
@@ -98,16 +102,16 @@ export class SharedProcess implements ISharedProcess {
 		});
 
 		return new Promise<void>(c => {
-			const onHello = Event.once(Event.fromNodeEventEmitter(ipcMain, 'handshake:hello', ({ sender }: { sender: WebContents }) => sender));
+			const onHello = Event.once(Event.fromNodeEventEmitter(ipcMain, 'handshake:sharedprocess-hello', ({ sender }: { sender: WebContents }) => sender));
 			disposables.add(onHello(sender => {
-				sender.send('handshake:hey there', {
+				sender.send('handshake:main-payload', {
 					sharedIPCHandle: this.environmentService.sharedIPCHandle,
 					args: this.environmentService.args,
 					logLevel: this.logService.getLevel()
 				});
 
-				disposables.add(toDisposable(() => sender.send('handshake:goodbye')));
-				ipcMain.once('handshake:im ready', () => c(undefined));
+				disposables.add(toDisposable(() => sender.send('handshake:mainprocess-goodbye')));
+				ipcMain.once('handshake:sharedprocess-ipc-ready', () => c(undefined));
 			}));
 		});
 	}
@@ -122,6 +126,11 @@ export class SharedProcess implements ISharedProcess {
 		await this._whenReady;
 	}
 
+	async whenIpcReady(): Promise<void> {
+		await this.barrier.wait();
+		await this._whenIpcReady;
+	}
+
 	toggle(): void {
 		if (!this.window || this.window.isVisible()) {
 			this.hide();