Fixes #1692: setImmediate Implementation in browser RAL for json-rpc is not ideal. (#1702)

Author: dbaeumer

jsonrpc/src/browser/ril.ts

@@ -130,6 +130,39 @@ interface RIL extends RAL {
 	};
 }
 
+export class QueueMicrotaskImpl implements Disposable {
+	private isDisposed: boolean;
+	constructor(callback: (...args: any[]) => void, ...args: any[]) {
+		this.isDisposed = false;
+		queueMicrotask(() => {
+			if (!this.isDisposed) {
+				callback(...args);
+			}
+		});
+	}
+
+	dispose(): void {
+		this.isDisposed = true;
+	}
+}
+
+export class PromiseImpl implements Disposable {
+	private isDisposed: boolean;
+	constructor(callback: (...args: any[]) => void, ...args: any[]) {
+		this.isDisposed = false;
+		Promise.resolve().then(() => {
+			if (!this.isDisposed) {
+				callback(...args);
+			}
+		}, () => {
+		});
+	}
+
+	dispose(): void {
+		this.isDisposed = true;
+	}
+}
+
 const _textEncoder = new TextEncoder();
 const _ril: RIL = Object.freeze<RIL>({
 	messageBuffer: Object.freeze({
@@ -166,8 +199,16 @@ const _ril: RIL = Object.freeze<RIL>({
 			return { dispose: () => clearTimeout(handle) };
 		},
 		setImmediate(callback: (...args: any[]) => void, ...args: any[]): Disposable {
-			const handle = setTimeout(callback, 0, ...args);
-			return { dispose: () => clearTimeout(handle) };
+			// Browser don't have setImmediate and setTimeout with 0 delay of 0 can cause problems
+			// in webviews and similar environments due to throttling.
+			if (typeof globalThis.queueMicrotask === 'function') {
+				return new QueueMicrotaskImpl(callback, ...args);
+			} else if (Promise !== undefined) {
+				return new PromiseImpl(callback, ...args);
+			} else {
+				const handle = setTimeout(callback, 0, ...args);
+				return { dispose: () => clearTimeout(handle) };
+			}
 		},
 		setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): Disposable {
 			const handle =  setInterval(callback, ms, ...args);

jsonrpc/src/browser/test/test.ts

@@ -8,7 +8,7 @@ import * as assert from 'assert';
 import { CancellationTokenSource, RequestMessage, RequestType0, ResponseMessage } from '../../common/api';
 import { SharedArrayReceiverStrategy, SharedArraySenderStrategy } from '../../common/sharedArrayCancellation';
 import { BrowserMessageReader, BrowserMessageWriter, createMessageConnection } from '../main';
-import RIL from '../ril';
+import RIL, { QueueMicrotaskImpl, PromiseImpl } from '../ril';
 
 function assertDefined<T>(value: T | undefined | null): asserts value is T {
 	assert.ok(value !== undefined && value !== null);
@@ -106,4 +106,61 @@ suite('Browser IPC Reader / Writer', () => {
 		const result = await promise;
 		assert.ok(result, 'Cancellation failed');
 	});
+
+	test('QueueMicrotaskImpl', async() => {
+		let called = false;
+		new QueueMicrotaskImpl(() => {
+			called = true;
+		});
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.strictEqual(called, true, 'QueueMicrotaskImpl callback not called');
+	});
+
+	test('QueueMicrotaskImpl dispose', async() => {
+		let called = false;
+		const queueMicrotask = new QueueMicrotaskImpl(() => {
+			called = true;
+		});
+		queueMicrotask.dispose();
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.strictEqual(called, false, 'QueueMicrotaskImpl callback called after dispose');
+	});
+
+	test('PromiseImpl', async() => {
+		let called = false;
+		new PromiseImpl(() => {
+			called = true;
+		});
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.strictEqual(called, true, 'PromiseImpl callback not called');
+	});
+
+	test('PromiseImpl dispose', async() => {
+		let called = false;
+		const promiseImpl = new PromiseImpl(() => {
+			called = true;
+		});
+		promiseImpl.dispose();
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.strictEqual(called, false, 'PromiseImpl callback called after dispose');
+	});
+
+	test('setImmediate', async() => {
+		let called = false;
+		RIL().timer.setImmediate(() => {
+			called = true;
+		});
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.strictEqual(called, true, 'setImmediate callback not called');
+	});
+
+	test('setImmediate dispose', async() => {
+		let called = false;
+		const disposable = RIL().timer.setImmediate(() => {
+			called = true;
+		});
+		disposable.dispose();
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.strictEqual(called, false, 'setImmediate callback called after dispose');
+	});
 });