Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

chore: make input actions "strict" in terms of timeout/abort (#36302)

Dmitry Gozman357ebfe67196
diff --git a/packages/playwright-core/src/server/bidi/bidiInput.ts b/packages/playwright-core/src/server/bidi/bidiInput.ts
index 5e9875f3a2..30a6439745 100644
--- a/packages/playwright-core/src/server/bidi/bidiInput.ts
+++ b/packages/playwright-core/src/server/bidi/bidiInput.ts
@@ -59,7 +59,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
}
private async _performActions(progress: Progress, actions: bidi.Input.KeySourceAction[]) {
- await this._session.send('input.performActions', {
+ await progress.race(this._session.send('input.performActions', {
context: this._session.sessionId,
actions: [
{
@@ -68,8 +68,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
actions,
}
]
- });
- progress.throwIfAborted();
+ }));
}
}
@@ -96,7 +95,7 @@ export class RawMouseImpl implements input.RawMouse {
// Bidi throws when x/y are not integers.
x = Math.floor(x);
y = Math.floor(y);
- await this._session.send('input.performActions', {
+ await progress.race(this._session.send('input.performActions', {
context: this._session.sessionId,
actions: [
{
@@ -105,12 +104,11 @@ export class RawMouseImpl implements input.RawMouse {
actions: [{ type: 'scroll', x, y, deltaX, deltaY }],
}
]
- });
- progress.throwIfAborted();
+ }));
}
private async _performActions(progress: Progress, actions: bidi.Input.PointerSourceAction[]) {
- await this._session.send('input.performActions', {
+ await progress.race(this._session.send('input.performActions', {
context: this._session.sessionId,
actions: [
{
@@ -122,8 +120,7 @@ export class RawMouseImpl implements input.RawMouse {
actions,
}
]
- });
- progress.throwIfAborted();
+ }));
}
}
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index cd49380705..5bd2577dad 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -168,8 +168,7 @@ export abstract class BrowserContext extends SdkObject {
async stopPendingOperations(reason: string) {
// When using context reuse, stop pending operations to gracefully terminate all the actions
// with a user-friendly error message containing operation log.
- for (const controller of this._activeProgressControllers)
- controller.abort(new Error(reason));
+ await Promise.all(Array.from(this._activeProgressControllers).map(controller => controller.abort(reason)));
// Let rejections in microtask generate events before returning.
await new Promise(f => setTimeout(f, 0));
}
diff --git a/packages/playwright-core/src/server/chromium/crDragDrop.ts b/packages/playwright-core/src/server/chromium/crDragDrop.ts
index d10c36d370..b54fe50f3f 100644
--- a/packages/playwright-core/src/server/chromium/crDragDrop.ts
+++ b/packages/playwright-core/src/server/chromium/crDragDrop.ts
@@ -55,14 +55,13 @@ export class DragManager {
async interceptDragCausedByMove(progress: Progress, x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, moveCallback: () => Promise<void>): Promise<void> {
this._lastPosition = { x, y };
if (this._dragState) {
- await this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
+ await progress.race(this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
type: 'dragOver',
x,
y,
data: this._dragState,
modifiers: toModifiersMask(modifiers),
- });
- progress.throwIfAborted();
+ }));
return;
}
if (button !== 'left')
@@ -111,18 +110,16 @@ export class DragManager {
}))).some(x => x);
this._dragState = expectingDrag ? (await dragInterceptedPromise).data : null;
client.off('Input.dragIntercepted', onDragIntercepted!);
- await client.send('Input.setInterceptDrags', { enabled: false });
- progress.throwIfAborted();
+ await progress.race(client.send('Input.setInterceptDrags', { enabled: false }));
if (this._dragState) {
- await this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
+ await progress.race(this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
type: 'dragEnter',
x,
y,
data: this._dragState,
modifiers: toModifiersMask(modifiers),
- });
- progress.throwIfAborted();
+ }));
}
}
@@ -132,14 +129,13 @@ export class DragManager {
async drop(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
assert(this._dragState, 'missing drag state');
- await this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
+ await progress.race(this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
type: 'drop',
x,
y,
data: this._dragState,
modifiers: toModifiersMask(modifiers),
- });
+ }));
this._dragState = null;
- progress.throwIfAborted();
}
}
diff --git a/packages/playwright-core/src/server/chromium/crInput.ts b/packages/playwright-core/src/server/chromium/crInput.ts
index 8e045fc5c7..beb030c9bf 100644
--- a/packages/playwright-core/src/server/chromium/crInput.ts
+++ b/packages/playwright-core/src/server/chromium/crInput.ts
@@ -55,11 +55,10 @@ export class RawKeyboardImpl implements input.RawKeyboard {
async keydown(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
const { code, key, location, text } = description;
- if (code === 'Escape' && await this._dragManger.cancelDrag())
+ if (code === 'Escape' && await progress.race(this._dragManger.cancelDrag()))
return;
- progress.throwIfAborted();
const commands = this._commandsForCode(code, modifiers);
- await this._client.send('Input.dispatchKeyEvent', {
+ await progress.race(this._client.send('Input.dispatchKeyEvent', {
type: text ? 'keyDown' : 'rawKeyDown',
modifiers: toModifiersMask(modifiers),
windowsVirtualKeyCode: description.keyCodeWithoutLocation,
@@ -71,26 +70,23 @@ export class RawKeyboardImpl implements input.RawKeyboard {
autoRepeat,
location,
isKeypad: location === input.keypadLocation
- });
- progress.throwIfAborted();
+ }));
}
async keyup(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
const { code, key, location } = description;
- await this._client.send('Input.dispatchKeyEvent', {
+ await progress.race(this._client.send('Input.dispatchKeyEvent', {
type: 'keyUp',
modifiers: toModifiersMask(modifiers),
key,
windowsVirtualKeyCode: description.keyCodeWithoutLocation,
code,
location
- });
- progress.throwIfAborted();
+ }));
}
async sendText(progress: Progress, text: string): Promise<void> {
- await this._client.send('Input.insertText', { text });
- progress.throwIfAborted();
+ await progress.race(this._client.send('Input.insertText', { text }));
}
}
@@ -107,7 +103,7 @@ export class RawMouseImpl implements input.RawMouse {
async move(progress: Progress, x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
const actualMove = async () => {
- await this._client.send('Input.dispatchMouseEvent', {
+ await progress.race(this._client.send('Input.dispatchMouseEvent', {
type: 'mouseMoved',
button,
buttons: toButtonsMask(buttons),
@@ -115,13 +111,12 @@ export class RawMouseImpl implements input.RawMouse {
y,
modifiers: toModifiersMask(modifiers),
force: buttons.size > 0 ? 0.5 : 0,
- });
+ }));
};
if (forClick) {
// Avoid extra protocol calls related to drag and drop, because click relies on
// move-down-up protocol commands being sent synchronously.
await actualMove();
- progress.throwIfAborted();
return;
}
await this._dragManager.interceptDragCausedByMove(progress, x, y, button, buttons, modifiers, actualMove);
@@ -130,7 +125,7 @@ export class RawMouseImpl implements input.RawMouse {
async down(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
if (this._dragManager.isDragging())
return;
- await this._client.send('Input.dispatchMouseEvent', {
+ await progress.race(this._client.send('Input.dispatchMouseEvent', {
type: 'mousePressed',
button,
buttons: toButtonsMask(buttons),
@@ -139,8 +134,7 @@ export class RawMouseImpl implements input.RawMouse {
modifiers: toModifiersMask(modifiers),
clickCount,
force: buttons.size > 0 ? 0.5 : 0,
- });
- progress.throwIfAborted();
+ }));
}
async up(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
@@ -148,7 +142,7 @@ export class RawMouseImpl implements input.RawMouse {
await this._dragManager.drop(progress, x, y, modifiers);
return;
}
- await this._client.send('Input.dispatchMouseEvent', {
+ await progress.race(this._client.send('Input.dispatchMouseEvent', {
type: 'mouseReleased',
button,
buttons: toButtonsMask(buttons),
@@ -156,20 +150,18 @@ export class RawMouseImpl implements input.RawMouse {
y,
modifiers: toModifiersMask(modifiers),
clickCount
- });
- progress.throwIfAborted();
+ }));
}
async wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
- await this._client.send('Input.dispatchMouseEvent', {
+ await progress.race(this._client.send('Input.dispatchMouseEvent', {
type: 'mouseWheel',
x,
y,
modifiers: toModifiersMask(modifiers),
deltaX,
deltaY,
- });
- progress.throwIfAborted();
+ }));
}
}
@@ -180,7 +172,7 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
this._client = client;
}
async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
- await Promise.all([
+ await progress.race(Promise.all([
this._client.send('Input.dispatchTouchEvent', {
type: 'touchStart',
modifiers: toModifiersMask(modifiers),
@@ -193,7 +185,6 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
modifiers: toModifiersMask(modifiers),
touchPoints: []
}),
- ]);
- progress.throwIfAborted();
+ ]));
}
}
diff --git a/packages/playwright-core/src/server/dom.ts b/packages/playwright-core/src/server/dom.ts
index 835c9331b6..d6fb1c8ee1 100644
--- a/packages/playwright-core/src/server/dom.ts
+++ b/packages/playwright-core/src/server/dom.ts
@@ -17,7 +17,7 @@
import fs from 'fs';
import * as js from './javascript';
-import { ProgressController } from './progress';
+import { isAbortError, ProgressController } from './progress';
import { asLocator, isUnderTest } from '../utils';
import { prepareFilesForUpload } from './fileUploadUtils';
import { isSessionClosedError } from './protocolError';
@@ -141,7 +141,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
const utility = await this._frame._utilityContext();
return await utility.evaluate(pageFunction, [await utility.injectedScript(), this, arg]);
} catch (e) {
- if (js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
+ if (isAbortError(e) || js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
throw e;
return 'error:notconnected';
}
@@ -152,7 +152,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
const utility = await this._frame._utilityContext();
return await utility.evaluateHandle(pageFunction, [await utility.injectedScript(), this, arg]);
} catch (e) {
- if (js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
+ if (isAbortError(e) || js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
throw e;
return 'error:notconnected';
}
@@ -240,25 +240,25 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return this._frame.dispatchEvent(metadata, ':scope', type, eventInit, { timeout: 0 }, this);
}
- async _scrollRectIntoViewIfNeeded(rect?: types.Rect): Promise<'error:notvisible' | 'error:notconnected' | 'done'> {
- return await this._page.delegate.scrollRectIntoViewIfNeeded(this, rect);
+ async _scrollRectIntoViewIfNeeded(progress: Progress, rect?: types.Rect): Promise<'error:notvisible' | 'error:notconnected' | 'done'> {
+ return await progress.race(this._page.delegate.scrollRectIntoViewIfNeeded(this, rect));
}
async _waitAndScrollIntoViewIfNeeded(progress: Progress, waitForVisible: boolean): Promise<void> {
const result = await this._retryAction(progress, 'scroll into view', async () => {
progress.log(` waiting for element to be stable`);
- const waitResult = await this.evaluateInUtility(async ([injected, node, { waitForVisible }]) => {
+ const waitResult = await progress.race(this.evaluateInUtility(async ([injected, node, { waitForVisible }]) => {
return await injected.checkElementStates(node, waitForVisible ? ['visible', 'stable'] : ['stable']);
- }, { waitForVisible });
+ }, { waitForVisible }));
if (waitResult)
return waitResult;
- return await this._scrollRectIntoViewIfNeeded();
+ return await this._scrollRectIntoViewIfNeeded(progress);
}, {});
assertDone(throwRetargetableDOMError(result));
}
async scrollIntoViewIfNeeded(metadata: CallMetadata, options: types.TimeoutOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(
progress => this._waitAndScrollIntoViewIfNeeded(progress, false /* waitForVisible */),
options.timeout);
@@ -336,13 +336,14 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
// We progressively wait longer between retries, up to 500ms.
const waitTime = [0, 20, 100, 100, 500];
- while (progress.isRunning()) {
+ while (true) {
+ progress.throwIfAborted();
if (retry) {
progress.log(`retrying ${actionName} action${options.trial ? ' (trial run)' : ''}`);
const timeout = waitTime[Math.min(retry - 1, waitTime.length - 1)];
if (timeout) {
progress.log(` waiting ${timeout}ms`);
- const result = await this.evaluateInUtility(([injected, node, timeout]) => new Promise<void>(f => setTimeout(f, timeout)), timeout);
+ const result = await progress.race(this.evaluateInUtility(([injected, node, timeout]) => new Promise<void>(f => setTimeout(f, timeout)), timeout));
if (result === 'error:notconnected')
return result;
}
@@ -379,11 +380,10 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
return result;
}
- return 'done';
}
async _retryPointerAction(progress: Progress, actionName: ActionName, waitForEnabled: boolean, action: (point: types.Point) => Promise<void>,
- options: { waitAfter: boolean | 'disabled' } & types.PointerActionOptions & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
+ options: Omit<{ waitAfter: boolean | 'disabled' } & types.PointerActionOptions & types.PointerActionWaitOptions, 'timeout'>): Promise<'error:notconnected' | 'done'> {
// Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
const skipActionPreChecks = actionName === 'move and up';
// By default, we scroll with protocol method to reveal the action point.
@@ -414,7 +414,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
waitForEnabled: boolean,
action: (point: types.Point) => Promise<void>,
forceScrollOptions: ScrollIntoViewOptions | undefined,
- options: { waitAfter: boolean | 'disabled' } & types.PointerActionOptions & types.PointerActionWaitOptions,
+ options: Omit<{ waitAfter: boolean | 'disabled' } & types.PointerActionOptions & types.PointerActionWaitOptions, 'timeout'>,
): Promise<PerformActionResult> {
const { force = false, position } = options;
@@ -426,7 +426,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return 'done' as const;
}, forceScrollOptions);
}
- return await this._scrollRectIntoViewIfNeeded(position ? { x: position.x, y: position.y, width: 0, height: 0 } : undefined);
+ return await this._scrollRectIntoViewIfNeeded(progress, position ? { x: position.x, y: position.y, width: 0, height: 0 } : undefined);
};
if (this._frame.parentFrame()) {
@@ -434,53 +434,53 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
// into view and visible, so they are not throttled.
// See https://github.com/microsoft/playwright/issues/27196 for an example.
progress.throwIfAborted(); // Avoid action that has side-effects.
- await doScrollIntoView().catch(() => {});
+ await progress.race(doScrollIntoView().catch(() => {}));
}
if ((options as any).__testHookBeforeStable)
- await (options as any).__testHookBeforeStable();
+ await progress.race((options as any).__testHookBeforeStable());
if (!force) {
const elementStates: ElementState[] = waitForEnabled ? ['visible', 'enabled', 'stable'] : ['visible', 'stable'];
progress.log(` waiting for element to be ${waitForEnabled ? 'visible, enabled and stable' : 'visible and stable'}`);
- const result = await this.evaluateInUtility(async ([injected, node, { elementStates }]) => {
+ const result = await progress.race(this.evaluateInUtility(async ([injected, node, { elementStates }]) => {
return await injected.checkElementStates(node, elementStates);
- }, { elementStates });
+ }, { elementStates }));
if (result)
return result;
progress.log(` element is ${waitForEnabled ? 'visible, enabled and stable' : 'visible and stable'}`);
}
if ((options as any).__testHookAfterStable)
- await (options as any).__testHookAfterStable();
+ await progress.race((options as any).__testHookAfterStable());
progress.log(' scrolling into view if needed');
progress.throwIfAborted(); // Avoid action that has side-effects.
- const scrolled = await doScrollIntoView();
+ const scrolled = await progress.race(doScrollIntoView());
if (scrolled !== 'done')
return scrolled;
progress.log(' done scrolling');
- const maybePoint = position ? await this._offsetPoint(position) : await this._clickablePoint();
+ const maybePoint = position ? await progress.race(this._offsetPoint(position)) : await progress.race(this._clickablePoint());
if (typeof maybePoint === 'string')
return maybePoint;
const point = roundPoint(maybePoint);
progress.metadata.point = point;
- await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+ await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
let hitTargetInterceptionHandle: js.JSHandle<HitTargetInterceptionResult> | undefined;
if (force) {
progress.log(` forcing action`);
} else {
if ((options as any).__testHookBeforeHitTarget)
- await (options as any).__testHookBeforeHitTarget();
+ await progress.race((options as any).__testHookBeforeHitTarget());
- const frameCheckResult = await this._checkFrameIsHitTarget(point);
+ const frameCheckResult = await progress.race(this._checkFrameIsHitTarget(point));
if (frameCheckResult === 'error:notconnected' || ('hitTargetDescription' in frameCheckResult))
return frameCheckResult;
const hitPoint = frameCheckResult.framePoint;
const actionType = actionName === 'move and up' ? 'drag' : ((actionName === 'hover' || actionName === 'tap') ? actionName : 'mouse');
- const handle = await this.evaluateHandleInUtility(([injected, node, { actionType, hitPoint, trial }]) => injected.setupHitTargetInterceptor(node, actionType, hitPoint, trial), { actionType, hitPoint, trial: !!options.trial } as const);
+ const handle = await progress.race(this.evaluateHandleInUtility(([injected, node, { actionType, hitPoint, trial }]) => injected.setupHitTargetInterceptor(node, actionType, hitPoint, trial), { actionType, hitPoint, trial: !!options.trial } as const));
if (handle === 'error:notconnected')
return handle;
if (!handle._objectId) {
@@ -500,7 +500,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
const actionResult = await this._page.frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
if ((options as any).__testHookBeforePointerAction)
- await (options as any).__testHookBeforePointerAction();
+ await progress.race((options as any).__testHookBeforePointerAction());
progress.throwIfAborted(); // Avoid action that has side-effects.
let restoreModifiers: types.KeyboardModifier[] | undefined;
if (options && options.modifiers)
@@ -518,7 +518,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if (options.waitAfter !== false) {
// When noWaitAfter is passed, we do not want to accidentally stall on
// non-committed navigation blocking the evaluate.
- const hitTargetResult = await stopHitTargetInterception;
+ const hitTargetResult = await progress.race(stopHitTargetInterception);
if (hitTargetResult !== 'done')
return hitTargetResult;
}
@@ -526,7 +526,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
progress.log(` ${options.trial ? 'trial ' : ''}${actionName} action done`);
progress.log(' waiting for scheduled navigations to finish');
if ((options as any).__testHookAfterPointerAction)
- await (options as any).__testHookAfterPointerAction();
+ await progress.race((options as any).__testHookAfterPointerAction());
return 'done';
});
if (actionResult !== 'done')
@@ -535,19 +535,19 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return 'done';
}
- private async _markAsTargetElement(metadata: CallMetadata) {
- if (!metadata.id)
+ private async _markAsTargetElement(progress: Progress) {
+ if (!progress.metadata.id)
return;
- await this.evaluateInUtility(([injected, node, callId]) => {
+ await progress.race(this.evaluateInUtility(([injected, node, callId]) => {
if (node.nodeType === 1 /* Node.ELEMENT_NODE */)
injected.markTargetElements(new Set([node as Node as Element]), callId);
- }, metadata.id);
+ }, progress.metadata.id));
}
async hover(metadata: CallMetadata, options: types.PointerActionOptions & types.PointerActionWaitOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._hover(progress, options);
return assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -558,9 +558,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async click(metadata: CallMetadata, options: { noWaitAfter?: boolean } & types.MouseClickOptions & types.PointerActionWaitOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._click(progress, { ...options, waitAfter: !options.noWaitAfter });
return assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -571,9 +571,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async dblclick(metadata: CallMetadata, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._dblclick(progress, options);
return assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -584,9 +584,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async tap(metadata: CallMetadata, options: types.PointerActionWaitOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._tap(progress, options);
return assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -597,9 +597,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async selectOption(metadata: CallMetadata, elements: ElementHandle[], values: types.SelectOption[], options: types.CommonActionOptions): Promise<string[]> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._selectOption(progress, elements, values, options);
return throwRetargetableDOMError(result);
}, options.timeout);
@@ -608,18 +608,18 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _selectOption(progress: Progress, elements: ElementHandle[], values: types.SelectOption[], options: types.CommonActionOptions): Promise<string[] | 'error:notconnected'> {
let resultingOptions: string[] = [];
const result = await this._retryAction(progress, 'select option', async () => {
- await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+ await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
if (!options.force)
progress.log(` waiting for element to be visible and enabled`);
const optionsToSelect = [...elements, ...values];
- const result = await this.evaluateInUtility(async ([injected, node, { optionsToSelect, force }]) => {
+ const result = await progress.race(this.evaluateInUtility(async ([injected, node, { optionsToSelect, force }]) => {
if (!force) {
const checkResult = await injected.checkElementStates(node, ['visible', 'enabled']);
if (checkResult)
return checkResult;
}
return injected.selectOptions(node, optionsToSelect);
- }, { optionsToSelect, force: options.force });
+ }, { optionsToSelect, force: options.force }));
if (Array.isArray(result)) {
progress.log(' selected specified option(s)');
resultingOptions = result;
@@ -633,9 +633,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async fill(metadata: CallMetadata, value: string, options: types.CommonActionOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._fill(progress, value, options);
assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -644,17 +644,17 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _fill(progress: Progress, value: string, options: types.CommonActionOptions): Promise<'error:notconnected' | 'done'> {
progress.log(` fill("${value}")`);
return await this._retryAction(progress, 'fill', async () => {
- await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+ await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
if (!options.force)
progress.log(' waiting for element to be visible, enabled and editable');
- const result = await this.evaluateInUtility(async ([injected, node, { value, force }]) => {
+ const result = await progress.race(this.evaluateInUtility(async ([injected, node, { value, force }]) => {
if (!force) {
const checkResult = await injected.checkElementStates(node, ['visible', 'enabled', 'editable']);
if (checkResult)
return checkResult;
}
return injected.fill(node, value);
- }, { value, force: options.force });
+ }, { value, force: options.force }));
progress.throwIfAborted(); // Avoid action that has side-effects.
if (result === 'needsinput') {
if (value)
@@ -669,29 +669,29 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async selectText(metadata: CallMetadata, options: types.CommonActionOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
const result = await this._retryAction(progress, 'selectText', async () => {
if (!options.force)
progress.log(' waiting for element to be visible');
- return await this.evaluateInUtility(async ([injected, node, { force }]) => {
+ return await progress.race(this.evaluateInUtility(async ([injected, node, { force }]) => {
if (!force) {
const checkResult = await injected.checkElementStates(node, ['visible']);
if (checkResult)
return checkResult;
}
return injected.selectText(node);
- }, { force: options.force });
+ }, { force: options.force }));
}, options);
assertDone(throwRetargetableDOMError(result));
}, options.timeout);
}
async setInputFiles(metadata: CallMetadata, params: channels.ElementHandleSetInputFilesParams) {
- const inputFileItems = await prepareFilesForUpload(this._frame, params);
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ const inputFileItems = await progress.race(prepareFilesForUpload(this._frame, params));
+ await this._markAsTargetElement(progress);
const result = await this._setInputFiles(progress, inputFileItems);
return assertDone(throwRetargetableDOMError(result));
}, params.timeout);
@@ -700,7 +700,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _setInputFiles(progress: Progress, items: InputFilesItems): Promise<'error:notconnected' | 'done'> {
const { filePayloads, localPaths, localDirectory } = items;
const multiple = filePayloads && filePayloads.length > 1 || localPaths && localPaths.length > 1;
- const result = await this.evaluateHandleInUtility(([injected, node, { multiple, directoryUpload }]): Element | undefined => {
+ const result = await progress.race(this.evaluateHandleInUtility(([injected, node, { multiple, directoryUpload }]): Element | undefined => {
const element = injected.retarget(node, 'follow-label');
if (!element)
return;
@@ -714,53 +714,50 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if (!directoryUpload && inputElement.webkitdirectory)
throw injected.createStacklessError('[webkitdirectory] input requires passing a path to a directory');
return inputElement;
- }, { multiple, directoryUpload: !!localDirectory });
+ }, { multiple, directoryUpload: !!localDirectory }));
if (result === 'error:notconnected' || !result.asElement())
return 'error:notconnected';
const retargeted = result.asElement() as ElementHandle<HTMLInputElement>;
- await this.instrumentation.onBeforeInputAction(this, progress.metadata);
- progress.throwIfAborted(); // Avoid action that has side-effects.
+ await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
if (localPaths || localDirectory) {
const localPathsOrDirectory = localDirectory ? [localDirectory] : localPaths!;
- await Promise.all((localPathsOrDirectory).map(localPath => (
+ await progress.race(Promise.all((localPathsOrDirectory).map(localPath => (
fs.promises.access(localPath, fs.constants.F_OK)
- )));
+ ))));
// Browsers traverse the given directory asynchronously and we want to ensure all files are uploaded.
const waitForInputEvent = localDirectory ? this.evaluate(node => new Promise<any>(fulfill => {
node.addEventListener('input', fulfill, { once: true });
})).catch(() => {}) : Promise.resolve();
- await this._page.delegate.setInputFilePaths(retargeted, localPathsOrDirectory);
- await waitForInputEvent;
+ await progress.race(this._page.delegate.setInputFilePaths(retargeted, localPathsOrDirectory));
+ await progress.race(waitForInputEvent);
} else {
- await retargeted.evaluateInUtility(([injected, node, files]) =>
- injected.setInputFiles(node, files), filePayloads!);
+ await progress.race(retargeted.evaluateInUtility(([injected, node, files]) =>
+ injected.setInputFiles(node, files), filePayloads!));
}
return 'done';
}
async focus(metadata: CallMetadata): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
await controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._focus(progress);
return assertDone(throwRetargetableDOMError(result));
}, 0);
}
async _focus(progress: Progress, resetSelectionIfNotFocused?: boolean): Promise<'error:notconnected' | 'done'> {
- progress.throwIfAborted(); // Avoid action that has side-effects.
- return await this.evaluateInUtility(([injected, node, resetSelectionIfNotFocused]) => injected.focusNode(node, resetSelectionIfNotFocused), resetSelectionIfNotFocused);
+ return await progress.race(this.evaluateInUtility(([injected, node, resetSelectionIfNotFocused]) => injected.focusNode(node, resetSelectionIfNotFocused), resetSelectionIfNotFocused));
}
async _blur(progress: Progress): Promise<'error:notconnected' | 'done'> {
- progress.throwIfAborted(); // Avoid action that has side-effects.
- return await this.evaluateInUtility(([injected, node]) => injected.blurNode(node), {});
+ return await progress.race(this.evaluateInUtility(([injected, node]) => injected.blurNode(node), {}));
}
async type(metadata: CallMetadata, text: string, options: { delay?: number } & types.TimeoutOptions & types.StrictOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._type(progress, text, options);
return assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -768,19 +765,18 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _type(progress: Progress, text: string, options: { delay?: number } & types.TimeoutOptions & types.StrictOptions): Promise<'error:notconnected' | 'done'> {
progress.log(`elementHandle.type("${text}")`);
- await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+ await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
if (result !== 'done')
return result;
- progress.throwIfAborted(); // Avoid action that has side-effects.
await this._page.keyboard._type(progress, text, options);
return 'done';
}
async press(metadata: CallMetadata, key: string, options: { delay?: number, noWaitAfter?: boolean } & types.TimeoutOptions & types.StrictOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
- await this._markAsTargetElement(metadata);
+ await this._markAsTargetElement(progress);
const result = await this._press(progress, key, options);
return assertDone(throwRetargetableDOMError(result));
}, options.timeout);
@@ -788,19 +784,18 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _press(progress: Progress, key: string, options: { delay?: number, noWaitAfter?: boolean } & types.TimeoutOptions & types.StrictOptions): Promise<'error:notconnected' | 'done'> {
progress.log(`elementHandle.press("${key}")`);
- await this.instrumentation.onBeforeInputAction(this, progress.metadata);
+ await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
return this._page.frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
if (result !== 'done')
return result;
- progress.throwIfAborted(); // Avoid action that has side-effects.
await this._page.keyboard._press(progress, key, options);
return 'done';
});
}
async check(metadata: CallMetadata, options: { position?: types.Point } & types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
const result = await this._setChecked(progress, true, options);
return assertDone(throwRetargetableDOMError(result));
@@ -808,7 +803,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async uncheck(metadata: CallMetadata, options: { position?: types.Point } & types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
const result = await this._setChecked(progress, false, options);
return assertDone(throwRetargetableDOMError(result));
@@ -817,12 +812,12 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _setChecked(progress: Progress, state: boolean, options: { position?: types.Point } & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
const isChecked = async () => {
- const result = await this.evaluateInUtility(([injected, node]) => injected.elementState(node, 'checked'), {});
+ const result = await progress.race(this.evaluateInUtility(([injected, node]) => injected.elementState(node, 'checked'), {}));
if (result === 'error:notconnected' || result.received === 'error:notconnected')
throwElementIsNotAttached();
return result.matches;
};
- await this._markAsTargetElement(progress.metadata);
+ await this._markAsTargetElement(progress);
if (await isChecked() === state)
return 'done';
const result = await this._click(progress, { ...options, waitAfter: 'disabled' });
@@ -891,13 +886,13 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
async waitForElementState(metadata: CallMetadata, state: 'visible' | 'hidden' | 'stable' | 'enabled' | 'disabled' | 'editable', options: types.TimeoutOptions): Promise<void> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
const actionName = `wait for ${state}`;
const result = await this._retryAction(progress, actionName, async () => {
- return await this.evaluateInUtility(async ([injected, node, state]) => {
+ return await progress.race(this.evaluateInUtility(async ([injected, node, state]) => {
return (await injected.checkElementStates(node, [state])) || 'done';
- }, state);
+ }, state));
}, {});
assertDone(throwRetargetableDOMError(result));
}, options.timeout);
diff --git a/packages/playwright-core/src/server/firefox/ffInput.ts b/packages/playwright-core/src/server/firefox/ffInput.ts
index 9485c4a881..4a497b99f0 100644
--- a/packages/playwright-core/src/server/firefox/ffInput.ts
+++ b/packages/playwright-core/src/server/firefox/ffInput.ts
@@ -68,7 +68,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
if (text === '\r')
text = '';
const { code, key, location } = description;
- await this._client.send('Page.dispatchKeyEvent', {
+ await progress.race(this._client.send('Page.dispatchKeyEvent', {
type: 'keydown',
keyCode: description.keyCodeWithoutLocation,
code,
@@ -76,26 +76,23 @@ export class RawKeyboardImpl implements input.RawKeyboard {
repeat: autoRepeat,
location,
text,
- });
- progress.throwIfAborted();
+ }));
}
async keyup(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
const { code, key, location } = description;
- await this._client.send('Page.dispatchKeyEvent', {
+ await progress.race(this._client.send('Page.dispatchKeyEvent', {
type: 'keyup',
key,
keyCode: description.keyCodeWithoutLocation,
code,
location,
repeat: false
- });
- progress.throwIfAborted();
+ }));
}
async sendText(progress: Progress, text: string): Promise<void> {
- await this._client.send('Page.insertText', { text });
- progress.throwIfAborted();
+ await progress.race(this._client.send('Page.insertText', { text }));
}
}
@@ -108,19 +105,18 @@ export class RawMouseImpl implements input.RawMouse {
}
async move(progress: Progress, x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
- await this._client.send('Page.dispatchMouseEvent', {
+ await progress.race(this._client.send('Page.dispatchMouseEvent', {
type: 'mousemove',
button: 0,
buttons: toButtonsMask(buttons),
x: Math.floor(x),
y: Math.floor(y),
modifiers: toModifiersMask(modifiers)
- });
- progress.throwIfAborted();
+ }));
}
async down(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
- await this._client.send('Page.dispatchMouseEvent', {
+ await progress.race(this._client.send('Page.dispatchMouseEvent', {
type: 'mousedown',
button: toButtonNumber(button),
buttons: toButtonsMask(buttons),
@@ -128,12 +124,11 @@ export class RawMouseImpl implements input.RawMouse {
y: Math.floor(y),
modifiers: toModifiersMask(modifiers),
clickCount
- });
- progress.throwIfAborted();
+ }));
}
async up(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
- await this._client.send('Page.dispatchMouseEvent', {
+ await progress.race(this._client.send('Page.dispatchMouseEvent', {
type: 'mouseup',
button: toButtonNumber(button),
buttons: toButtonsMask(buttons),
@@ -141,22 +136,20 @@ export class RawMouseImpl implements input.RawMouse {
y: Math.floor(y),
modifiers: toModifiersMask(modifiers),
clickCount
- });
- progress.throwIfAborted();
+ }));
}
async wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
// Wheel events hit the compositor first, so wait one frame for it to be synced.
await this._page!.mainFrame().evaluateExpression(`new Promise(requestAnimationFrame)`, { world: 'utility' });
- await this._client.send('Page.dispatchWheelEvent', {
+ await progress.race(this._client.send('Page.dispatchWheelEvent', {
deltaX,
deltaY,
x: Math.floor(x),
y: Math.floor(y),
deltaZ: 0,
modifiers: toModifiersMask(modifiers)
- });
- progress.throwIfAborted();
+ }));
}
setPage(page: Page) {
@@ -171,11 +164,10 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
this._client = client;
}
async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
- await this._client.send('Page.dispatchTapEvent', {
+ await progress.race(this._client.send('Page.dispatchTapEvent', {
x,
y,
modifiers: toModifiersMask(modifiers),
- });
- progress.throwIfAborted();
+ }));
}
}
diff --git a/packages/playwright-core/src/server/frames.ts b/packages/playwright-core/src/server/frames.ts
index d173770292..11981950fc 100644
--- a/packages/playwright-core/src/server/frames.ts
+++ b/packages/playwright-core/src/server/frames.ts
@@ -25,7 +25,7 @@ import { SdkObject, serverSideCallMetadata } from './instrumentation';
import * as js from './javascript';
import * as network from './network';
import { Page } from './page';
-import { ProgressController } from './progress';
+import { isAbortError, ProgressController } from './progress';
import * as types from './types';
import { LongStandingScope, asLocator, assert, constructURLBasedOnBaseURL, makeWaitForNextTask, monotonicTime, renderTitleForCall } from '../utils';
import { isSessionClosedError } from './protocolError';
@@ -160,15 +160,14 @@ export class FrameManager {
}
}
- async waitForSignalsCreatedBy<T>(progress: Progress | null, waitAfter: boolean, action: () => Promise<T>): Promise<T> {
+ async waitForSignalsCreatedBy<T>(progress: Progress, waitAfter: boolean, action: () => Promise<T>): Promise<T> {
if (!waitAfter)
return action();
const barrier = new SignalBarrier(progress);
this._signalBarriers.add(barrier);
- if (progress)
- progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
+ progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
const result = await action();
- await this._page.delegate.inputActionEpilogue();
+ await progress.race(this._page.delegate.inputActionEpilogue());
await barrier.waitFor();
this._signalBarriers.delete(barrier);
// Resolve in the next task, after all waitForNavigations.
@@ -745,15 +744,15 @@ export class Frame extends SdkObject {
}
async waitForSelector(metadata: CallMetadata, selector: string, options: types.WaitForElementOptions, scope?: dom.ElementHandle): Promise<dom.ElementHandle<Element> | null> {
- const controller = new ProgressController(metadata, this);
- if ((options as any).visibility)
- throw new Error('options.visibility is not supported, did you mean options.state?');
- if ((options as any).waitFor && (options as any).waitFor !== 'visible')
- throw new Error('options.waitFor is not supported, did you mean options.state?');
- const { state = 'visible' } = options;
- if (!['attached', 'detached', 'visible', 'hidden'].includes(state))
- throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
+ if ((options as any).visibility)
+ throw new Error('options.visibility is not supported, did you mean options.state?');
+ if ((options as any).waitFor && (options as any).waitFor !== 'visible')
+ throw new Error('options.waitFor is not supported, did you mean options.state?');
+ const { state = 'visible' } = options;
+ if (!['attached', 'detached', 'visible', 'hidden'].includes(state))
+ throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
progress.log(`waiting for ${this._asLocator(selector)}${state === 'attached' ? '' : ' to be ' + state}`);
return await this.waitForSelectorInternal(progress, selector, true, options, scope);
}, options.timeout);
@@ -765,14 +764,13 @@ export class Frame extends SdkObject {
if (performActionPreChecks)
await this._page.performActionPreChecks(progress);
- const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
- progress.throwIfAborted();
+ const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
if (!resolved) {
if (state === 'hidden' || state === 'detached')
return null;
return continuePolling;
}
- const result = await resolved.injected.evaluateHandle((injected, { info, root }) => {
+ const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, root }) => {
if (root && !root.isConnected)
throw injected.createStacklessError('Element is not attached to the DOM');
const elements = injected.querySelectorAll(info.parsed, root || document);
@@ -787,8 +785,8 @@ export class Frame extends SdkObject {
log = ` locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
}
return { log, element, visible, attached: !!element };
- }, { info: resolved.info, root: resolved.frame === this ? scope : undefined });
- const { log, visible, attached } = await result.evaluate(r => ({ log: r.log, visible: r.visible, attached: r.attached }));
+ }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }), handle => handle.dispose());
+ const { log, visible, attached } = await progress.race(result.evaluate(r => ({ log: r.log, visible: r.visible, attached: r.attached })));
if (log)
progress.log(log);
const success = { attached, detached: !attached, visible, hidden: !visible }[state];
@@ -800,14 +798,15 @@ export class Frame extends SdkObject {
result.dispose();
return null;
}
- const element = state === 'attached' || state === 'visible' ? await result.evaluateHandle(r => r.element) : null;
+ const element = state === 'attached' || state === 'visible' ? await progress.race(result.evaluateHandle(r => r.element)) : null;
result.dispose();
if (!element)
return null;
if ((options as any).__testHookBeforeAdoptNode)
- await (options as any).__testHookBeforeAdoptNode();
+ await progress.race((options as any).__testHookBeforeAdoptNode());
try {
- return await element._adoptTo(await resolved.frame._mainContext());
+ const mainContext = await progress.race(resolved.frame._mainContext());
+ return await progress.race(element._adoptTo(mainContext));
} catch (e) {
return continuePolling;
}
@@ -865,7 +864,7 @@ export class Frame extends SdkObject {
return retVal;
});
} catch (e) {
- if (js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
+ if (isAbortError(e) || js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
throw e;
throw new Error(`Unable to retrieve content because the page is navigating and changing the content.`);
}
@@ -1043,18 +1042,17 @@ export class Frame extends SdkObject {
const continuePolling = Symbol('continuePolling');
timeouts = [0, ...timeouts];
let timeoutIndex = 0;
- while (progress.isRunning()) {
+ while (true) {
const timeout = timeouts[Math.min(timeoutIndex++, timeouts.length - 1)];
if (timeout) {
// Make sure we react immediately upon page close or frame detach.
// We need this to show expected/received values in time.
const actionPromise = new Promise(f => setTimeout(f, timeout));
- await LongStandingScope.raceMultiple([
+ await progress.race(LongStandingScope.raceMultiple([
this._page.openScope,
this._detachedScope,
- ], actionPromise);
+ ], actionPromise));
}
- progress.throwIfAborted();
try {
const result = await action(continuePolling);
if (result === continuePolling)
@@ -1066,11 +1064,11 @@ export class Frame extends SdkObject {
continue;
}
}
- progress.throwIfAborted();
- return undefined as any;
}
private _isErrorThatCannotBeRetried(e: Error) {
+ if (isAbortError(e))
+ return true;
// Always fail on JavaScript errors or when the main connection is closed.
if (js.isJavaScriptErrorInEvaluate(e) || isSessionClosedError(e))
return true;
@@ -1095,11 +1093,10 @@ export class Frame extends SdkObject {
if (performActionPreChecks)
await this._page.performActionPreChecks(progress);
- const resolved = await this.selectors.resolveInjectedForSelector(selector, { strict });
- progress.throwIfAborted();
+ const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict }));
if (!resolved)
return continuePolling;
- const result = await resolved.injected.evaluateHandle((injected, { info, callId }) => {
+ const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, callId }) => {
const elements = injected.querySelectorAll(info.parsed, document);
if (callId)
injected.markTargetElements(new Set(elements), callId);
@@ -1113,15 +1110,15 @@ export class Frame extends SdkObject {
log = ` locator resolved to ${injected.previewNode(element)}`;
}
return { log, success: !!element, element };
- }, { info: resolved.info, callId: progress.metadata.id });
- const { log, success } = await result.evaluate(r => ({ log: r.log, success: r.success }));
+ }, { info: resolved.info, callId: progress.metadata.id }), handle => handle.dispose());
+ const { log, success } = await progress.race(result.evaluate(r => ({ log: r.log, success: r.success })));
if (log)
progress.log(log);
if (!success) {
result.dispose();
return continuePolling;
}
- const element = await result.evaluateHandle(r => r.element) as dom.ElementHandle<Element>;
+ const element = await progress.race(result.evaluateHandle(r => r.element)) as dom.ElementHandle<Element>;
result.dispose();
try {
const result = await action(element);
@@ -1144,21 +1141,21 @@ export class Frame extends SdkObject {
}
async click(metadata: CallMetadata, selector: string, options: { noWaitAfter?: boolean } & types.MouseClickOptions & types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._click(progress, { ...options, waitAfter: !options.noWaitAfter })));
}, options.timeout);
}
async dblclick(metadata: CallMetadata, selector: string, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._dblclick(progress, options)));
}, options.timeout);
}
async dragAndDrop(metadata: CallMetadata, source: string, target: string, options: types.DragActionOptions & types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
await controller.run(async progress => {
dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performActionPreChecks */, async handle => {
return handle._retryPointerAction(progress, 'move and down', false, async point => {
@@ -1168,7 +1165,6 @@ export class Frame extends SdkObject {
...options,
waitAfter: 'disabled',
position: options.sourcePosition,
- timeout: progress.timeUntilDeadline(),
});
}));
// Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
@@ -1180,37 +1176,36 @@ export class Frame extends SdkObject {
...options,
waitAfter: 'disabled',
position: options.targetPosition,
- timeout: progress.timeUntilDeadline(),
});
}));
}, options.timeout);
}
async tap(metadata: CallMetadata, selector: string, options: types.PointerActionWaitOptions) {
- if (!this._page.browserContext._options.hasTouch)
- throw new Error('The page does not support tap. Use hasTouch context option to enable touch support.');
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
+ if (!this._page.browserContext._options.hasTouch)
+ throw new Error('The page does not support tap. Use hasTouch context option to enable touch support.');
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._tap(progress, options)));
}, options.timeout);
}
async fill(metadata: CallMetadata, selector: string, value: string, options: types.TimeoutOptions & types.StrictOptions & { force?: boolean }) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._fill(progress, value, options)));
}, options.timeout);
}
async focus(metadata: CallMetadata, selector: string, options: types.TimeoutOptions & types.StrictOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
await controller.run(async progress => {
dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._focus(progress)));
}, options.timeout);
}
async blur(metadata: CallMetadata, selector: string, options: types.TimeoutOptions & types.StrictOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
await controller.run(async progress => {
dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._blur(progress)));
}, options.timeout);
@@ -1274,25 +1269,25 @@ export class Frame extends SdkObject {
}
async isVisible(metadata: CallMetadata, selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
progress.log(` checking visibility of ${this._asLocator(selector)}`);
- return await this.isVisibleInternal(selector, options, scope);
+ return await this.isVisibleInternal(progress, selector, options, scope);
}, 0); // Note: isVisible is a one-shot operation without a timeout.
}
- async isVisibleInternal(selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
+ async isVisibleInternal(progress: Progress, selector: string, options: types.StrictOptions = {}, scope?: dom.ElementHandle): Promise<boolean> {
try {
- const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
+ const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
if (!resolved)
return false;
- return await resolved.injected.evaluate((injected, { info, root }) => {
+ return await progress.race(resolved.injected.evaluate((injected, { info, root }) => {
const element = injected.querySelector(info.parsed, root || document, info.strict);
const state = element ? injected.elementState(element, 'visible') : { matches: false, received: 'error:notconnected' };
return state.matches;
- }, { info: resolved.info, root: resolved.frame === this ? scope : undefined });
+ }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }));
} catch (e) {
- if (js.isJavaScriptErrorInEvaluate(e) || isInvalidSelectorError(e) || isSessionClosedError(e))
+ if (isAbortError(e) || js.isJavaScriptErrorInEvaluate(e) || isInvalidSelectorError(e) || isSessionClosedError(e))
throw e;
return false;
}
@@ -1319,14 +1314,14 @@ export class Frame extends SdkObject {
}
async hover(metadata: CallMetadata, selector: string, options: types.PointerActionOptions & types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._hover(progress, options)));
}, options.timeout);
}
async selectOption(metadata: CallMetadata, selector: string, elements: dom.ElementHandle[], values: types.SelectOption[], options: types.CommonActionOptions): Promise<string[]> {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._selectOption(progress, elements, values, options));
}, options.timeout);
@@ -1334,45 +1329,43 @@ export class Frame extends SdkObject {
async setInputFiles(metadata: CallMetadata, selector: string, params: channels.FrameSetInputFilesParams): Promise<channels.FrameSetInputFilesResult> {
const inputFileItems = await prepareFilesForUpload(this, params);
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performActionPreChecks */, handle => handle._setInputFiles(progress, inputFileItems)));
}, params.timeout);
}
async type(metadata: CallMetadata, selector: string, text: string, options: { delay?: number } & types.TimeoutOptions & types.StrictOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._type(progress, text, options)));
}, options.timeout);
}
async press(metadata: CallMetadata, selector: string, key: string, options: { delay?: number, noWaitAfter?: boolean } & types.TimeoutOptions & types.StrictOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._press(progress, key, options)));
}, options.timeout);
}
async check(metadata: CallMetadata, selector: string, options: types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._setChecked(progress, true, options)));
}, options.timeout);
}
async uncheck(metadata: CallMetadata, selector: string, options: types.PointerActionWaitOptions) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._setChecked(progress, false, options)));
}, options.timeout);
}
async waitForTimeout(metadata: CallMetadata, timeout: number) {
- const controller = new ProgressController(metadata, this);
- return controller.run(async () => {
- await new Promise(resolve => setTimeout(resolve, timeout));
- });
+ const controller = new ProgressController(metadata, this, 'strict');
+ return controller.run(progress => progress.wait(timeout));
}
async ariaSnapshot(metadata: CallMetadata, selector: string, options: { forAI?: boolean } & types.TimeoutOptions): Promise<string> {
@@ -1413,7 +1406,7 @@ export class Frame extends SdkObject {
if (resultOneShot.matches !== options.isNot)
return resultOneShot;
} catch (e) {
- if (js.isJavaScriptErrorInEvaluate(e) || isInvalidSelectorError(e))
+ if (isAbortError(e) || js.isJavaScriptErrorInEvaluate(e) || isInvalidSelectorError(e))
throw e;
// Ignore any other errors from one-shot, we'll handle them during retries.
}
@@ -1593,16 +1586,15 @@ export class Frame extends SdkObject {
}
private async _callOnElementOnceMatches<T, R>(metadata: CallMetadata, selector: string, body: ElementCallback<T, R>, taskData: T, options: types.TimeoutOptions & types.StrictOptions & { mainWorld?: boolean }, scope?: dom.ElementHandle): Promise<R> {
- const callbackText = body.toString();
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
+ const callbackText = body.toString();
progress.log(`waiting for ${this._asLocator(selector)}`);
const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
- const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
- progress.throwIfAborted();
+ const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, options, scope));
if (!resolved)
return continuePolling;
- const { log, success, value } = await resolved.injected.evaluate((injected, { info, callbackText, taskData, callId, root }) => {
+ const { log, success, value } = await progress.race(resolved.injected.evaluate((injected, { info, callbackText, taskData, callId, root }) => {
const callback = injected.eval(callbackText) as ElementCallback<T, R>;
const element = injected.querySelector(info.parsed, root || document, info.strict);
if (!element)
@@ -1611,8 +1603,7 @@ export class Frame extends SdkObject {
if (callId)
injected.markTargetElements(new Set([element]), callId);
return { log, success: true, value: callback(injected, element, taskData as T) };
- }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : undefined });
-
+ }, { info: resolved.info, callbackText, taskData, callId: progress.metadata.id, root: resolved.frame === this ? scope : undefined }));
if (log)
progress.log(log);
if (!success)
@@ -1724,38 +1715,39 @@ export class Frame extends SdkObject {
}
class SignalBarrier {
- private _progress: Progress | null;
+ private _progress: Progress;
private _protectCount = 0;
private _promise = new ManualPromise<void>();
- constructor(progress: Progress | null) {
+ constructor(progress: Progress) {
this._progress = progress;
this.retain();
}
waitFor(): PromiseLike<void> {
this.release();
- return this._promise;
+ return this._progress.race(this._promise);
}
- async addFrameNavigation(frame: Frame) {
+ addFrameNavigation(frame: Frame) {
// Auto-wait top-level navigations only.
if (frame.parentFrame())
return;
this.retain();
- const waiter = helper.waitForEvent(null, frame, Frame.Events.InternalNavigation, (e: NavigationEvent) => {
+ const waiter = helper.waitForEvent(this._progress, frame, Frame.Events.InternalNavigation, (e: NavigationEvent) => {
if (!e.isPublic)
return false;
if (!e.error && this._progress)
this._progress.log(` navigated to "${frame._url}"`);
return true;
});
- await LongStandingScope.raceMultiple([
+ LongStandingScope.raceMultiple([
frame._page.openScope,
frame._detachedScope,
- ], waiter.promise).catch(() => {});
- waiter.dispose();
- this.release();
+ ], waiter.promise).catch(() => {}).finally(() => {
+ waiter.dispose();
+ this.release();
+ });
}
retain() {
diff --git a/packages/playwright-core/src/server/helper.ts b/packages/playwright-core/src/server/helper.ts
index e9fec62419..e5bf38dd77 100644
--- a/packages/playwright-core/src/server/helper.ts
+++ b/packages/playwright-core/src/server/helper.ts
@@ -55,7 +55,7 @@ class Helper {
return null;
}
- static waitForEvent(progress: Progress | null, emitter: EventEmitter, event: string | symbol, predicate?: Function): { promise: Promise<any>, dispose: () => void } {
+ static waitForEvent(progress: Progress, emitter: EventEmitter, event: string | symbol, predicate?: Function): { promise: Promise<any>, dispose: () => void } {
const listeners: RegisteredListener[] = [];
const promise = new Promise((resolve, reject) => {
listeners.push(eventsHelper.addEventListener(emitter, event, eventArg => {
@@ -71,8 +71,7 @@ class Helper {
}));
});
const dispose = () => eventsHelper.removeEventListeners(listeners);
- if (progress)
- progress.cleanupWhenAborted(dispose);
+ progress.cleanupWhenAborted(dispose);
return { promise, dispose };
}
diff --git a/packages/playwright-core/src/server/input.ts b/packages/playwright-core/src/server/input.ts
index a82dc69ae8..99c7fea2dc 100644
--- a/packages/playwright-core/src/server/input.ts
+++ b/packages/playwright-core/src/server/input.ts
@@ -55,7 +55,7 @@ export class Keyboard {
}
async down(metadata: CallMetadata, key: string) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._down(progress, key));
}
@@ -82,7 +82,7 @@ export class Keyboard {
}
async up(metadata: CallMetadata, key: string) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._up(progress, key));
}
@@ -95,7 +95,7 @@ export class Keyboard {
}
async insertText(metadata: CallMetadata, text: string) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._insertText(progress, text));
}
@@ -104,7 +104,7 @@ export class Keyboard {
}
async type(metadata: CallMetadata, text: string, options?: { delay?: number }) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._type(progress, text, options));
}
@@ -115,14 +115,14 @@ export class Keyboard {
await this._press(progress, char, { delay });
} else {
if (delay)
- await wait(progress, delay);
+ await progress.wait(delay);
await this._insertText(progress, char);
}
}
}
async press(metadata: CallMetadata, key: string, options: { delay?: number }) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._press(progress, key, options));
}
@@ -148,7 +148,7 @@ export class Keyboard {
await this._down(progress, tokens[i]);
await this._down(progress, key);
if (options.delay)
- await wait(progress, options.delay);
+ await progress.wait(options.delay);
await this._up(progress, key);
for (let i = tokens.length - 2; i >= 0; --i)
await this._up(progress, tokens[i]);
@@ -214,7 +214,7 @@ export class Mouse {
}
async move(metadata: CallMetadata, x: number, y: number, options: { steps?: number, forClick?: boolean }) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._move(progress, x, y, options));
}
@@ -232,7 +232,7 @@ export class Mouse {
}
async down(metadata: CallMetadata, options: { button?: types.MouseButton, clickCount?: number }) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._down(progress, options));
}
@@ -244,7 +244,7 @@ export class Mouse {
}
async up(metadata: CallMetadata, options: { button?: types.MouseButton, clickCount?: number }) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._up(progress, options));
}
@@ -256,7 +256,7 @@ export class Mouse {
}
async click(metadata: CallMetadata, x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number }) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._click(progress, x, y, options));
}
@@ -266,10 +266,10 @@ export class Mouse {
this._move(progress, x, y, { forClick: true });
for (let cc = 1; cc <= clickCount; ++cc) {
await this._down(progress, { ...options, clickCount: cc });
- await wait(progress, delay);
+ await progress.wait(delay);
await this._up(progress, { ...options, clickCount: cc });
if (cc < clickCount)
- await wait(progress, delay);
+ await progress.wait(delay);
}
} else {
const promises = [];
@@ -283,7 +283,7 @@ export class Mouse {
}
async wheel(metadata: CallMetadata, deltaX: number, deltaY: number) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(async progress => {
await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
});
@@ -364,7 +364,7 @@ export class Touchscreen {
}
async tap(metadata: CallMetadata, x: number, y: number) {
- const controller = new ProgressController(metadata, this._page);
+ const controller = new ProgressController(metadata, this._page, 'strict');
return controller.run(progress => this._tap(progress, x, y));
}
@@ -374,8 +374,3 @@ export class Touchscreen {
await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
}
}
-
-async function wait(progress: Progress, ms: number) {
- await new Promise(f => setTimeout(f, Math.min(ms, progress.timeUntilDeadline())));
- progress.throwIfAborted();
-}
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index b2ca066122..b2a24a620f 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -25,7 +25,7 @@ import { helper } from './helper';
import * as input from './input';
import { SdkObject } from './instrumentation';
import * as js from './javascript';
-import { ProgressController } from './progress';
+import { isAbortError, ProgressController } from './progress';
import { Screenshotter, validateScreenshotOptions } from './screenshotter';
import { LongStandingScope, assert, renderTitleForCall, trimStringWithEllipsis } from '../utils';
import { asLocator } from '../utils';
@@ -36,6 +36,7 @@ import { ManualPromise } from '../utils/isomorphic/manualPromise';
import { parseEvaluationResultValue } from '../utils/isomorphic/utilityScriptSerializers';
import { compressCallLog } from './callLog';
import * as rawBindingsControllerSource from '../generated/bindingsControllerSource';
+import { isSessionClosedError } from './protocolError';
import type { Artifact } from './artifact';
import type * as dom from './dom';
@@ -476,7 +477,7 @@ export class Page extends SdkObject {
return;
for (const [uid, handler] of this._locatorHandlers) {
if (!handler.resolved) {
- if (await this.mainFrame().isVisibleInternal(handler.selector, { strict: true })) {
+ if (await this.mainFrame().isVisibleInternal(progress, handler.selector, { strict: true })) {
handler.resolved = new ManualPromise();
this.emit(Page.Events.LocatorHandlerTriggered, uid);
}
@@ -493,9 +494,7 @@ export class Page extends SdkObject {
progress.log(` locator handler has finished`);
}
});
- await this.openScope.race(promise).finally(() => --this._locatorHandlerRunningCounter);
- // Avoid side-effects after long-running operation.
- progress.throwIfAborted();
+ await progress.race(this.openScope.race(promise)).finally(() => --this._locatorHandlerRunningCounter);
progress.log(` interception handler has finished, continuing`);
}
}
@@ -1005,7 +1004,7 @@ async function snapshotFrameForAI(metadata: CallMetadata, frame: frames.Frame, f
return continuePolling;
return snapshotOrRetry;
} catch (e) {
- if (js.isJavaScriptErrorInEvaluate(e))
+ if (isAbortError(e) || isSessionClosedError(e) || js.isJavaScriptErrorInEvaluate(e))
throw e;
return continuePolling;
}
diff --git a/packages/playwright-core/src/server/progress.ts b/packages/playwright-core/src/server/progress.ts
index 68476ca21d..e01576bbc8 100644
--- a/packages/playwright-core/src/server/progress.ts
+++ b/packages/playwright-core/src/server/progress.ts
@@ -24,27 +24,37 @@ import type { LogName } from './utils/debugLogger';
export interface Progress {
log(message: string): void;
timeUntilDeadline(): number;
- isRunning(): boolean;
cleanupWhenAborted(cleanup: () => any): void;
throwIfAborted(): void;
+ race<T>(promise: Promise<T> | Promise<T>[]): Promise<T>;
+ raceWithCleanup<T>(promise: Promise<T>, cleanup: (result: T) => any): Promise<T>;
+ wait(timeout: number): Promise<void>;
metadata: CallMetadata;
}
export class ProgressController {
private _forceAbortPromise = new ManualPromise<any>();
+ private _donePromise = new ManualPromise<void>();
// Cleanups to be run only in the case of abort.
private _cleanups: (() => any)[] = [];
+ // Lenient mode races against the timeout. This guarantees that timeout is respected,
+ // but may have some work being done after the timeout due to parallel control flow.
+ //
+ // Strict mode aborts the progress and requires the code to react to it. This way,
+ // progress only finishes after the inner callback exits, guaranteeing no work after the timeout.
+ private _strictMode = false;
+
private _logName: LogName;
- private _state: 'before' | 'running' | 'aborted' | 'finished' = 'before';
+ private _state: 'before' | 'running' | { error: Error } | 'finished' = 'before';
private _deadline: number = 0;
- private _timeout: number = 0;
readonly metadata: CallMetadata;
readonly instrumentation: Instrumentation;
readonly sdkObject: SdkObject;
- constructor(metadata: CallMetadata, sdkObject: SdkObject) {
+ constructor(metadata: CallMetadata, sdkObject: SdkObject, strictMode?: 'strict') {
+ this._strictMode = strictMode === 'strict';
this.metadata = metadata;
this.sdkObject = sdkObject;
this.instrumentation = sdkObject.instrumentation;
@@ -56,15 +66,18 @@ export class ProgressController {
this._logName = logName;
}
- abort(error: Error) {
- this._forceAbortPromise.reject(error);
+ async abort(message: string) {
+ if (this._state === 'running') {
+ const error = new AbortedError(message);
+ this._state = { error };
+ this._forceAbortPromise.reject(error);
+ }
+ if (this._strictMode)
+ await this._donePromise;
}
async run<T>(task: (progress: Progress) => Promise<T>, timeout?: number): Promise<T> {
- if (timeout) {
- this._timeout = timeout;
- this._deadline = timeout ? monotonicTime() + timeout : 0;
- }
+ this._deadline = timeout ? monotonicTime() + timeout : 0;
assert(this._state === 'before');
this._state = 'running';
@@ -78,7 +91,6 @@ export class ProgressController {
this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
},
timeUntilDeadline: () => this._deadline ? this._deadline - monotonicTime() : 2147483647, // 2^31-1 safe setTimeout in Node.
- isRunning: () => this._state === 'running',
cleanupWhenAborted: (cleanup: () => any) => {
if (this._state === 'running')
this._cleanups.push(cleanup);
@@ -86,26 +98,47 @@ export class ProgressController {
runCleanup(cleanup);
},
throwIfAborted: () => {
- if (this._state === 'aborted')
- throw new AbortedError();
+ if (typeof this._state === 'object')
+ throw this._state.error;
+ },
+ metadata: this.metadata,
+ race: <T>(promise: Promise<T> | Promise<T>[]) => {
+ const promises = Array.isArray(promise) ? promise : [promise];
+ return Promise.race([...promises, this._forceAbortPromise]);
+ },
+ raceWithCleanup: <T>(promise: Promise<T>, cleanup: (result: T) => any) => {
+ return progress.race(promise.then(result => {
+ progress.cleanupWhenAborted(() => cleanup(result));
+ return result;
+ }));
+ },
+ wait: async (timeout: number) => {
+ let timer: NodeJS.Timeout;
+ const promise = new Promise<void>(f => timer = setTimeout(f, timeout));
+ return progress.race(promise).finally(() => clearTimeout(timer));
},
- metadata: this.metadata
};
- const timeoutError = new TimeoutError(`Timeout ${this._timeout}ms exceeded.`);
- const timer = setTimeout(() => this._forceAbortPromise.reject(timeoutError), progress.timeUntilDeadline());
+ const timeoutError = new TimeoutError(`Timeout ${timeout}ms exceeded.`);
+ const timer = setTimeout(() => {
+ if (this._state === 'running') {
+ this._state = { error: timeoutError };
+ this._forceAbortPromise.reject(timeoutError);
+ }
+ }, progress.timeUntilDeadline());
try {
const promise = task(progress);
- const result = await Promise.race([promise, this._forceAbortPromise]);
+ const result = this._strictMode ? await promise : await Promise.race([promise, this._forceAbortPromise]);
this._state = 'finished';
return result;
- } catch (e) {
- this._state = 'aborted';
+ } catch (error) {
+ this._state = { error };
await Promise.all(this._cleanups.splice(0).map(runCleanup));
- throw e;
+ throw error;
} finally {
this.sdkObject.attribution.context?._activeProgressControllers.delete(this);
clearTimeout(timer);
+ this._donePromise.resolve();
}
}
}
@@ -118,3 +151,7 @@ async function runCleanup(cleanup: () => any) {
}
class AbortedError extends Error {}
+
+export function isAbortError(error: Error): boolean {
+ return error instanceof AbortedError || error instanceof TimeoutError;
+}
diff --git a/packages/playwright-core/src/server/webkit/wkInput.ts b/packages/playwright-core/src/server/webkit/wkInput.ts
index 148e96b29d..3d1dffd196 100644
--- a/packages/playwright-core/src/server/webkit/wkInput.ts
+++ b/packages/playwright-core/src/server/webkit/wkInput.ts
@@ -73,7 +73,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
let commands = macEditingCommands[shortcut];
if (isString(commands))
commands = [commands];
- await this._pageProxySession.send('Input.dispatchKeyEvent', {
+ await progress.race(this._pageProxySession.send('Input.dispatchKeyEvent', {
type: 'keyDown',
modifiers: toModifiersMask(modifiers),
windowsVirtualKeyCode: keyCode,
@@ -84,26 +84,23 @@ export class RawKeyboardImpl implements input.RawKeyboard {
autoRepeat,
macCommands: commands,
isKeypad: description.location === input.keypadLocation
- });
- progress.throwIfAborted();
+ }));
}
async keyup(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
const { code, key } = description;
- await this._pageProxySession.send('Input.dispatchKeyEvent', {
+ await progress.race(this._pageProxySession.send('Input.dispatchKeyEvent', {
type: 'keyUp',
modifiers: toModifiersMask(modifiers),
key,
windowsVirtualKeyCode: description.keyCode,
code,
isKeypad: description.location === input.keypadLocation
- });
- progress.throwIfAborted();
+ }));
}
async sendText(progress: Progress, text: string): Promise<void> {
- await this._session!.send('Page.insertText', { text });
- progress.throwIfAborted();
+ await progress.race(this._session!.send('Page.insertText', { text }));
}
}
@@ -121,19 +118,18 @@ export class RawMouseImpl implements input.RawMouse {
}
async move(progress: Progress, x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
- await this._pageProxySession.send('Input.dispatchMouseEvent', {
+ await progress.race(this._pageProxySession.send('Input.dispatchMouseEvent', {
type: 'move',
button,
buttons: toButtonsMask(buttons),
x,
y,
modifiers: toModifiersMask(modifiers)
- });
- progress.throwIfAborted();
+ }));
}
async down(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
- await this._pageProxySession.send('Input.dispatchMouseEvent', {
+ await progress.race(this._pageProxySession.send('Input.dispatchMouseEvent', {
type: 'down',
button,
buttons: toButtonsMask(buttons),
@@ -141,12 +137,11 @@ export class RawMouseImpl implements input.RawMouse {
y,
modifiers: toModifiersMask(modifiers),
clickCount
- });
- progress.throwIfAborted();
+ }));
}
async up(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
- await this._pageProxySession.send('Input.dispatchMouseEvent', {
+ await progress.race(this._pageProxySession.send('Input.dispatchMouseEvent', {
type: 'up',
button,
buttons: toButtonsMask(buttons),
@@ -154,8 +149,7 @@ export class RawMouseImpl implements input.RawMouse {
y,
modifiers: toModifiersMask(modifiers),
clickCount
- });
- progress.throwIfAborted();
+ }));
}
async wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
@@ -163,16 +157,14 @@ export class RawMouseImpl implements input.RawMouse {
throw new Error('Mouse wheel is not supported in mobile WebKit');
await this._session!.send('Page.updateScrollingState');
// Wheel events hit the compositor first, so wait one frame for it to be synced.
- await this._page!.mainFrame().evaluateExpression(`new Promise(requestAnimationFrame)`, { world: 'utility' });
- progress.throwIfAborted();
- await this._pageProxySession.send('Input.dispatchWheelEvent', {
+ await progress.race(this._page!.mainFrame().evaluateExpression(`new Promise(requestAnimationFrame)`, { world: 'utility' }));
+ await progress.race(this._pageProxySession.send('Input.dispatchWheelEvent', {
x,
y,
deltaX,
deltaY,
modifiers: toModifiersMask(modifiers),
- });
- progress.throwIfAborted();
+ }));
}
setPage(page: Page) {
@@ -188,11 +180,10 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
}
async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
- await this._pageProxySession.send('Input.dispatchTapEvent', {
+ await progress.race(this._pageProxySession.send('Input.dispatchTapEvent', {
x,
y,
modifiers: toModifiersMask(modifiers),
- });
- progress.throwIfAborted();
+ }));
}
}
diff --git a/tests/page/page-add-locator-handler.spec.ts b/tests/page/page-add-locator-handler.spec.ts
index f8b1bb6ba7..605e63da82 100644
--- a/tests/page/page-add-locator-handler.spec.ts
+++ b/tests/page/page-add-locator-handler.spec.ts
@@ -313,7 +313,7 @@ test('should wait for hidden by default 2', async ({ page, server }) => {
});
const error = await page.locator('#target').click({ timeout: 3000 }).catch(e => e);
expect(await page.evaluate('window.clicked')).toBe(0);
- await expect(page.locator('#interstitial')).toBeVisible();
+ expect(await page.locator('#interstitial').isVisible()).toBe(true);
expect(called).toBe(1);
expect(error.message).toContain(`locator handler has finished, waiting for getByRole('button', { name: 'close' }) to be hidden`);
});