Skip to content

Commit a901902

Browse files
joaomorenojoaomoreno
committed
remove TPromise.wrapError
related to microsoft#63897
1 parent 2f863c6 commit a901902

4 files changed

Lines changed: 124 additions & 117 deletions

File tree

‎src/vs/platform/driver/electron-browser/driver.ts‎

Lines changed: 32 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,6 @@
33
* Licensed under the MIT License. See License.txt in the project root for license information.
44
*--------------------------------------------------------------------------------------------*/
55

6-
import { TPromise } from 'vs/base/common/winjs.base';
76
import { IDisposable, toDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
87
import { IWindowDriver, IElement, WindowDriverChannel, WindowDriverRegistryChannelClient } from 'vs/platform/driver/node/driver';
98
import { IPCClient } from 'vs/base/parts/ipc/node/ipc';
@@ -50,19 +49,19 @@ class WindowDriver implements IWindowDriver {
5049
@IWindowService private windowService: IWindowService
5150
) { }
5251

53-
click(selector: string, xoffset?: number, yoffset?: number): TPromise<void> {
52+
click(selector: string, xoffset?: number, yoffset?: number): Promise<void> {
5453
return this._click(selector, 1, xoffset, yoffset);
5554
}
5655

57-
doubleClick(selector: string): TPromise<void> {
56+
doubleClick(selector: string): Promise<void> {
5857
return this._click(selector, 2);
5958
}
6059

61-
private _getElementXY(selector: string, xoffset?: number, yoffset?: number): TPromise<{ x: number; y: number; }> {
60+
private async _getElementXY(selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number; y: number; }> {
6261
const element = document.querySelector(selector);
6362

6463
if (!element) {
65-
return TPromise.wrapError(new Error(`Element not found: ${selector}`));
64+
return Promise.reject(new Error(`Element not found: ${selector}`));
6665
}
6766

6867
const { left, top } = getTopLeftOffset(element as HTMLElement);
@@ -80,43 +79,39 @@ class WindowDriver implements IWindowDriver {
8079
x = Math.round(x);
8180
y = Math.round(y);
8281

83-
return TPromise.as({ x, y });
82+
return { x, y };
8483
}
8584

86-
private _click(selector: string, clickCount: number, xoffset?: number, yoffset?: number): TPromise<void> {
87-
return this._getElementXY(selector, xoffset, yoffset).then(({ x, y }) => {
85+
private async _click(selector: string, clickCount: number, xoffset?: number, yoffset?: number): Promise<void> {
86+
const { x, y } = await this._getElementXY(selector, xoffset, yoffset);
8887

89-
const webContents: electron.WebContents = (electron as any).remote.getCurrentWebContents();
90-
webContents.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount } as any);
88+
const webContents: electron.WebContents = (electron as any).remote.getCurrentWebContents();
89+
webContents.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount } as any);
90+
await timeout(10);
9191

92-
return TPromise.wrap(timeout(10)).then(() => {
93-
webContents.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount } as any);
94-
return TPromise.wrap(timeout(100));
95-
});
96-
});
92+
webContents.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount } as any);
93+
await timeout(100);
9794
}
9895

99-
setValue(selector: string, text: string): TPromise<void> {
96+
async setValue(selector: string, text: string): Promise<void> {
10097
const element = document.querySelector(selector);
10198

10299
if (!element) {
103-
return TPromise.wrapError(new Error(`Element not found: ${selector}`));
100+
return Promise.reject(new Error(`Element not found: ${selector}`));
104101
}
105102

106103
const inputElement = element as HTMLInputElement;
107104
inputElement.value = text;
108105

109106
const event = new Event('input', { bubbles: true, cancelable: true });
110107
inputElement.dispatchEvent(event);
111-
112-
return TPromise.as(null);
113108
}
114109

115-
getTitle(): TPromise<string> {
116-
return TPromise.as(document.title);
110+
async getTitle(): Promise<string> {
111+
return document.title;
117112
}
118113

119-
isActiveElement(selector: string): TPromise<boolean> {
114+
async isActiveElement(selector: string): Promise<boolean> {
120115
const element = document.querySelector(selector);
121116

122117
if (element !== document.activeElement) {
@@ -132,13 +127,13 @@ class WindowDriver implements IWindowDriver {
132127
el = el.parentElement;
133128
}
134129

135-
return TPromise.wrapError(new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`));
130+
throw new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`);
136131
}
137132

138-
return TPromise.as(true);
133+
return true;
139134
}
140135

141-
getElements(selector: string, recursive: boolean): TPromise<IElement[]> {
136+
async getElements(selector: string, recursive: boolean): Promise<IElement[]> {
142137
const query = document.querySelectorAll(selector);
143138
const result: IElement[] = [];
144139

@@ -147,14 +142,14 @@ class WindowDriver implements IWindowDriver {
147142
result.push(serializeElement(element, recursive));
148143
}
149144

150-
return TPromise.as(result);
145+
return result;
151146
}
152147

153-
typeInEditor(selector: string, text: string): TPromise<void> {
148+
async typeInEditor(selector: string, text: string): Promise<void> {
154149
const element = document.querySelector(selector);
155150

156151
if (!element) {
157-
return TPromise.wrapError(new Error(`Editor not found: ${selector}`));
152+
throw new Error(`Editor not found: ${selector}`);
158153
}
159154

160155
const textarea = element as HTMLTextAreaElement;
@@ -168,21 +163,19 @@ class WindowDriver implements IWindowDriver {
168163

169164
const event = new Event('input', { 'bubbles': true, 'cancelable': true });
170165
textarea.dispatchEvent(event);
171-
172-
return TPromise.as(null);
173166
}
174167

175-
getTerminalBuffer(selector: string): TPromise<string[]> {
168+
async getTerminalBuffer(selector: string): Promise<string[]> {
176169
const element = document.querySelector(selector);
177170

178171
if (!element) {
179-
return TPromise.wrapError(new Error(`Terminal not found: ${selector}`));
172+
throw new Error(`Terminal not found: ${selector}`);
180173
}
181174

182175
const xterm: Terminal = (element as any).xterm;
183176

184177
if (!xterm) {
185-
return TPromise.wrapError(new Error(`Xterm not found: ${selector}`));
178+
throw new Error(`Xterm not found: ${selector}`);
186179
}
187180

188181
const lines: string[] = [];
@@ -191,29 +184,27 @@ class WindowDriver implements IWindowDriver {
191184
lines.push(xterm._core.buffer.translateBufferLineToString(i, true));
192185
}
193186

194-
return TPromise.as(lines);
187+
return lines;
195188
}
196189

197-
writeInTerminal(selector: string, text: string): TPromise<void> {
190+
async writeInTerminal(selector: string, text: string): Promise<void> {
198191
const element = document.querySelector(selector);
199192

200193
if (!element) {
201-
return TPromise.wrapError(new Error(`Element not found: ${selector}`));
194+
throw new Error(`Element not found: ${selector}`);
202195
}
203196

204197
const xterm: Terminal = (element as any).xterm;
205198

206199
if (!xterm) {
207-
return TPromise.wrapError(new Error(`Xterm not found: ${selector}`));
200+
throw new Error(`Xterm not found: ${selector}`);
208201
}
209202

210203
xterm._core.handler(text);
211-
212-
return TPromise.as(null);
213204
}
214205

215-
openDevTools(): TPromise<void> {
216-
return this.windowService.openDevTools({ mode: 'detach' });
206+
async openDevTools(): Promise<void> {
207+
await this.windowService.openDevTools({ mode: 'detach' });
217208
}
218209
}
219210

0 commit comments

Comments
 (0)