Skip to content

Commit 6daba77

Browse files
alexdimaalexdima
committed
Migrate to native Promise in web worker related code (microsoft#53526)
1 parent 99d97b5 commit 6daba77

7 files changed

Lines changed: 104 additions & 110 deletions

File tree

‎src/vs/base/common/worker/simpleWorker.ts‎

Lines changed: 41 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55

66
import { transformErrorForSerialization } from 'vs/base/common/errors';
77
import { Disposable } from 'vs/base/common/lifecycle';
8-
import { ErrorCallback, TPromise, ValueCallback } from 'vs/base/common/winjs.base';
98
import { isWeb } from 'vs/base/common/platform';
109

1110
const INITIALIZE = '$initialize';
@@ -56,13 +55,13 @@ interface IReplyMessage extends IMessage {
5655
}
5756

5857
interface IMessageReply {
59-
c: ValueCallback;
60-
e: ErrorCallback;
58+
resolve: (value?: any) => void;
59+
reject: (error?: any) => void;
6160
}
6261

6362
interface IMessageHandler {
6463
sendMessage(msg: string): void;
65-
handleMessage(method: string, args: any[]): TPromise<any>;
64+
handleMessage(method: string, args: any[]): Promise<any>;
6665
}
6766

6867
class SimpleWorkerProtocol {
@@ -83,15 +82,15 @@ class SimpleWorkerProtocol {
8382
this._workerId = workerId;
8483
}
8584

86-
public sendMessage(method: string, args: any[]): TPromise<any> {
85+
public sendMessage(method: string, args: any[]): Promise<any> {
8786
let req = String(++this._lastSentReq);
8887
let reply: IMessageReply = {
89-
c: null,
90-
e: null
88+
resolve: null,
89+
reject: null
9190
};
92-
let result = new TPromise<any>((c, e) => {
93-
reply.c = c;
94-
reply.e = e;
91+
let result = new Promise<any>((resolve, reject) => {
92+
reply.resolve = resolve;
93+
reply.reject = reject;
9594
});
9695
this._pendingReplies[req] = reply;
9796

@@ -140,11 +139,11 @@ class SimpleWorkerProtocol {
140139
err.message = replyMessage.err.message;
141140
err.stack = replyMessage.err.stack;
142141
}
143-
reply.e(err);
142+
reply.reject(err);
144143
return;
145144
}
146145

147-
reply.c(replyMessage.res);
146+
reply.resolve(replyMessage.res);
148147
return;
149148
}
150149

@@ -185,14 +184,14 @@ class SimpleWorkerProtocol {
185184
export class SimpleWorkerClient<T> extends Disposable {
186185

187186
private _worker: IWorker;
188-
private _onModuleLoaded: TPromise<string[]>;
187+
private _onModuleLoaded: Promise<string[]>;
189188
private _protocol: SimpleWorkerProtocol;
190-
private _lazyProxy: TPromise<T>;
189+
private _lazyProxy: Promise<T>;
191190

192191
constructor(workerFactory: IWorkerFactory, moduleId: string) {
193192
super();
194193

195-
let lazyProxyFulfill: (v: T) => void = null;
194+
let lazyProxyResolve: (v: T) => void = null;
196195
let lazyProxyReject: (err: any) => void = null;
197196

198197
this._worker = this._register(workerFactory.create(
@@ -211,9 +210,9 @@ export class SimpleWorkerClient<T> extends Disposable {
211210
sendMessage: (msg: string): void => {
212211
this._worker.postMessage(msg);
213212
},
214-
handleMessage: (method: string, args: any[]): TPromise<any> => {
213+
handleMessage: (method: string, args: any[]): Promise<any> => {
215214
// Intentionally not supporting worker -> main requests
216-
return TPromise.as(null);
215+
return Promise.resolve(null);
217216
}
218217
});
219218
this._protocol.setWorkerId(this._worker.getId());
@@ -228,9 +227,9 @@ export class SimpleWorkerClient<T> extends Disposable {
228227
loaderConfiguration = (<any>self).requirejs.s.contexts._.config;
229228
}
230229

231-
this._lazyProxy = new TPromise<T>((c, e) => {
232-
lazyProxyFulfill = c;
233-
lazyProxyReject = e;
230+
this._lazyProxy = new Promise<T>((resolve, reject) => {
231+
lazyProxyResolve = resolve;
232+
lazyProxyReject = reject;
234233
});
235234

236235
// Send initialize message
@@ -244,34 +243,34 @@ export class SimpleWorkerClient<T> extends Disposable {
244243
for (let i = 0; i < availableMethods.length; i++) {
245244
(proxy as any)[availableMethods[i]] = createProxyMethod(availableMethods[i], proxyMethodRequest);
246245
}
247-
lazyProxyFulfill(proxy);
246+
lazyProxyResolve(proxy);
248247
}, (e) => {
249248
lazyProxyReject(e);
250249
this._onError('Worker failed to load ' + moduleId, e);
251250
});
252251

253252
// Create proxy to loaded code
254-
let proxyMethodRequest = (method: string, args: any[]): TPromise<any> => {
253+
let proxyMethodRequest = (method: string, args: any[]): Promise<any> => {
255254
return this._request(method, args);
256255
};
257256

258-
let createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => TPromise<any>): Function => {
257+
let createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => Promise<any>): Function => {
259258
return function () {
260259
let args = Array.prototype.slice.call(arguments, 0);
261260
return proxyMethodRequest(method, args);
262261
};
263262
};
264263
}
265264

266-
public getProxyObject(): TPromise<T> {
265+
public getProxyObject(): Promise<T> {
267266
return this._lazyProxy;
268267
}
269268

270-
private _request(method: string, args: any[]): TPromise<any> {
271-
return new TPromise<any>((c, e) => {
269+
private _request(method: string, args: any[]): Promise<any> {
270+
return new Promise<any>((resolve, reject) => {
272271
this._onModuleLoaded.then(() => {
273-
this._protocol.sendMessage(method, args).then(c, e);
274-
}, e);
272+
this._protocol.sendMessage(method, args).then(resolve, reject);
273+
}, reject);
275274
});
276275
}
277276

@@ -300,31 +299,31 @@ export class SimpleWorkerServer {
300299
sendMessage: (msg: string): void => {
301300
postSerializedMessage(msg);
302301
},
303-
handleMessage: (method: string, args: any[]): TPromise<any> => this._handleMessage(method, args)
302+
handleMessage: (method: string, args: any[]): Promise<any> => this._handleMessage(method, args)
304303
});
305304
}
306305

307306
public onmessage(msg: string): void {
308307
this._protocol.handleMessage(msg);
309308
}
310309

311-
private _handleMessage(method: string, args: any[]): TPromise<any> {
310+
private _handleMessage(method: string, args: any[]): Promise<any> {
312311
if (method === INITIALIZE) {
313312
return this.initialize(<number>args[0], <string>args[1], <any>args[2]);
314313
}
315314

316315
if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {
317-
return TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));
316+
return Promise.reject(new Error('Missing requestHandler or method: ' + method));
318317
}
319318

320319
try {
321-
return TPromise.as(this._requestHandler[method].apply(this._requestHandler, args));
320+
return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));
322321
} catch (e) {
323-
return TPromise.wrapError(e);
322+
return Promise.reject(e);
324323
}
325324
}
326325

327-
private initialize(workerId: number, moduleId: string, loaderConfig: any): TPromise<any> {
326+
private initialize(workerId: number, moduleId: string, loaderConfig: any): Promise<string[]> {
328327
this._protocol.setWorkerId(workerId);
329328

330329
if (this._requestHandler) {
@@ -335,7 +334,7 @@ export class SimpleWorkerServer {
335334
methods.push(prop);
336335
}
337336
}
338-
return TPromise.as(methods);
337+
return Promise.resolve(methods);
339338
}
340339

341340
if (loaderConfig) {
@@ -354,11 +353,11 @@ export class SimpleWorkerServer {
354353
(<any>self).require.config(loaderConfig);
355354
}
356355

357-
let cc: ValueCallback;
358-
let ee: ErrorCallback;
359-
let r = new TPromise<any>((c, e) => {
360-
cc = c;
361-
ee = e;
356+
let resolve: (value?: string[]) => void;
357+
let reject: (error?: any) => void;
358+
let r = new Promise<string[]>((_resolve, _reject) => {
359+
resolve = _resolve;
360+
reject = _reject;
362361
});
363362

364363
// Use the global require to be sure to get the global config
@@ -373,8 +372,8 @@ export class SimpleWorkerServer {
373372
}
374373
}
375374

376-
cc(methods);
377-
}, ee);
375+
resolve(methods);
376+
}, reject);
378377

379378
return r;
380379
}

‎src/vs/editor/common/services/editorSimpleWorker.ts‎

Lines changed: 23 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,6 @@
44
*--------------------------------------------------------------------------------------------*/
55

66
import { URI } from 'vs/base/common/uri';
7-
import { TPromise } from 'vs/base/common/winjs.base';
87
import { IDisposable } from 'vs/base/common/lifecycle';
98
import { IRequestHandler } from 'vs/base/common/worker/simpleWorker';
109
import { Range, IRange } from 'vs/editor/common/core/range';
@@ -336,7 +335,7 @@ export abstract class BaseEditorSimpleWorker {
336335

337336
// ---- BEGIN diff --------------------------------------------------------------------------
338337

339-
public computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): TPromise<editorCommon.ILineChange[]> {
338+
public computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<editorCommon.ILineChange[]> {
340339
let original = this._getModel(originalUrl);
341340
let modified = this._getModel(modifiedUrl);
342341
if (!original || !modified) {
@@ -351,10 +350,10 @@ export abstract class BaseEditorSimpleWorker {
351350
shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
352351
shouldMakePrettyDiff: true
353352
});
354-
return TPromise.as(diffComputer.computeDiff());
353+
return Promise.resolve(diffComputer.computeDiff());
355354
}
356355

357-
public computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): TPromise<editorCommon.IChange[]> {
356+
public computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<editorCommon.IChange[]> {
358357
let original = this._getModel(originalUrl);
359358
let modified = this._getModel(modifiedUrl);
360359
if (!original || !modified) {
@@ -369,7 +368,7 @@ export abstract class BaseEditorSimpleWorker {
369368
shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
370369
shouldMakePrettyDiff: true
371370
});
372-
return TPromise.as(diffComputer.computeDiff());
371+
return Promise.resolve(diffComputer.computeDiff());
373372
}
374373

375374
// ---- END diff --------------------------------------------------------------------------
@@ -379,10 +378,10 @@ export abstract class BaseEditorSimpleWorker {
379378

380379
private static readonly _diffLimit = 10000;
381380

382-
public computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[]): TPromise<TextEdit[]> {
381+
public computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[]): Promise<TextEdit[]> {
383382
const model = this._getModel(modelUrl);
384383
if (!model) {
385-
return TPromise.as(edits);
384+
return Promise.resolve(edits);
386385
}
387386

388387
const result: TextEdit[] = [];
@@ -437,25 +436,25 @@ export abstract class BaseEditorSimpleWorker {
437436
result.push({ eol: lastEol, text: undefined, range: undefined });
438437
}
439438

440-
return TPromise.as(result);
439+
return Promise.resolve(result);
441440
}
442441

443442
// ---- END minimal edits ---------------------------------------------------------------
444443

445-
public computeLinks(modelUrl: string): TPromise<ILink[]> {
444+
public computeLinks(modelUrl: string): Promise<ILink[]> {
446445
let model = this._getModel(modelUrl);
447446
if (!model) {
448447
return null;
449448
}
450449

451-
return TPromise.as(computeLinks(model));
450+
return Promise.resolve(computeLinks(model));
452451
}
453452

454453
// ---- BEGIN suggest --------------------------------------------------------------------------
455454

456455
private static readonly _suggestionsLimit = 10000;
457456

458-
public textualSuggest(modelUrl: string, position: IPosition, wordDef: string, wordDefFlags: string): TPromise<CompletionList> {
457+
public textualSuggest(modelUrl: string, position: IPosition, wordDef: string, wordDefFlags: string): Promise<CompletionList> {
459458
const model = this._getModel(modelUrl);
460459
if (model) {
461460
const suggestions: CompletionItem[] = [];
@@ -488,7 +487,7 @@ export abstract class BaseEditorSimpleWorker {
488487
});
489488
}
490489

491-
return TPromise.as({ suggestions });
490+
return Promise.resolve({ suggestions });
492491
}
493492
return undefined;
494493
}
@@ -529,7 +528,7 @@ export abstract class BaseEditorSimpleWorker {
529528

530529
//#endregion
531530

532-
public navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): TPromise<IInplaceReplaceSupportResult> {
531+
public navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): Promise<IInplaceReplaceSupportResult> {
533532
let model = this._getModel(modelUrl);
534533
if (!model) {
535534
return null;
@@ -555,12 +554,12 @@ export abstract class BaseEditorSimpleWorker {
555554
}
556555

557556
let result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
558-
return TPromise.as(result);
557+
return Promise.resolve(result);
559558
}
560559

561560
// ---- BEGIN foreign module support --------------------------------------------------------------------------
562561

563-
public loadForeignModule(moduleId: string, createData: any): TPromise<string[]> {
562+
public loadForeignModule(moduleId: string, createData: any): Promise<string[]> {
564563
let ctx: IWorkerContext = {
565564
getMirrorModels: (): IMirrorModel[] => {
566565
return this._getModels();
@@ -576,10 +575,10 @@ export abstract class BaseEditorSimpleWorker {
576575
methods.push(prop);
577576
}
578577
}
579-
return TPromise.as(methods);
578+
return Promise.resolve(methods);
580579
}
581580
// ESM-comment-begin
582-
return new TPromise<any>((c, e) => {
581+
return new Promise<any>((resolve, reject) => {
583582
require([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {
584583
this._foreignModule = foreignModule.create(ctx, createData);
585584

@@ -590,27 +589,27 @@ export abstract class BaseEditorSimpleWorker {
590589
}
591590
}
592591

593-
c(methods);
592+
resolve(methods);
594593

595-
}, e);
594+
}, reject);
596595
});
597596
// ESM-comment-end
598597

599598
// ESM-uncomment-begin
600-
// return TPromise.wrapError(new Error(`Unexpected usage`));
599+
// return Promise.reject(new Error(`Unexpected usage`));
601600
// ESM-uncomment-end
602601
}
603602

604603
// foreign method request
605-
public fmr(method: string, args: any[]): TPromise<any> {
604+
public fmr(method: string, args: any[]): Promise<any> {
606605
if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
607-
return TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));
606+
return Promise.reject(new Error('Missing requestHandler or method: ' + method));
608607
}
609608

610609
try {
611-
return TPromise.as(this._foreignModule[method].apply(this._foreignModule, args));
610+
return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
612611
} catch (e) {
613-
return TPromise.wrapError(e);
612+
return Promise.reject(e);
614613
}
615614
}
616615

0 commit comments

Comments
 (0)