Skip to content

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

chore: accept Progress instance for raw input (#36280)

Dmitry Gozman33d87d93dd8c
diff --git a/packages/playwright-core/src/server/bidi/bidiInput.ts b/packages/playwright-core/src/server/bidi/bidiInput.ts
index e67c07ba8f..5e9875f3a2 100644
--- a/packages/playwright-core/src/server/bidi/bidiInput.ts
+++ b/packages/playwright-core/src/server/bidi/bidiInput.ts
@@ -21,6 +21,7 @@ import * as bidi from './third_party/bidiProtocol';
import type * as input from '../input';
import type * as types from '../types';
import type { BidiSession } from './bidiConnection';
+import type { Progress } from '../progress';
export class RawKeyboardImpl implements input.RawKeyboard {
private _session: BidiSession;
@@ -33,31 +34,31 @@ export class RawKeyboardImpl implements input.RawKeyboard {
this._session = session;
}
- async keydown(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
+ async keydown(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
keyName = resolveSmartModifierString(keyName);
const actions: bidi.Input.KeySourceAction[] = [];
actions.push({ type: 'keyDown', value: getBidiKeyValue(keyName) });
- await this._performActions(actions);
+ await this._performActions(progress, actions);
}
- async keyup(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
+ async keyup(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
keyName = resolveSmartModifierString(keyName);
const actions: bidi.Input.KeySourceAction[] = [];
actions.push({ type: 'keyUp', value: getBidiKeyValue(keyName) });
- await this._performActions(actions);
+ await this._performActions(progress, actions);
}
- async sendText(text: string): Promise<void> {
+ async sendText(progress: Progress, text: string): Promise<void> {
const actions: bidi.Input.KeySourceAction[] = [];
for (const char of text) {
const value = getBidiKeyValue(char);
actions.push({ type: 'keyDown', value });
actions.push({ type: 'keyUp', value });
}
- await this._performActions(actions);
+ await this._performActions(progress, actions);
}
- private async _performActions(actions: bidi.Input.KeySourceAction[]) {
+ private async _performActions(progress: Progress, actions: bidi.Input.KeySourceAction[]) {
await this._session.send('input.performActions', {
context: this._session.sessionId,
actions: [
@@ -68,6 +69,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
}
]
});
+ progress.throwIfAborted();
}
}
@@ -78,19 +80,19 @@ export class RawMouseImpl implements input.RawMouse {
this._session = session;
}
- async move(x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
- await this._performActions([{ type: 'pointerMove', x, y }]);
+ 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._performActions(progress, [{ type: 'pointerMove', x, y }]);
}
- async down(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
- await this._performActions([{ type: 'pointerDown', button: toBidiButton(button) }]);
+ 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._performActions(progress, [{ type: 'pointerDown', button: toBidiButton(button) }]);
}
- async up(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
- await this._performActions([{ type: 'pointerUp', button: toBidiButton(button) }]);
+ 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._performActions(progress, [{ type: 'pointerUp', button: toBidiButton(button) }]);
}
- async wheel(x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
+ async wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
// Bidi throws when x/y are not integers.
x = Math.floor(x);
y = Math.floor(y);
@@ -104,9 +106,10 @@ export class RawMouseImpl implements input.RawMouse {
}
]
});
+ progress.throwIfAborted();
}
- private async _performActions(actions: bidi.Input.PointerSourceAction[]) {
+ private async _performActions(progress: Progress, actions: bidi.Input.PointerSourceAction[]) {
await this._session.send('input.performActions', {
context: this._session.sessionId,
actions: [
@@ -120,6 +123,7 @@ export class RawMouseImpl implements input.RawMouse {
}
]
});
+ progress.throwIfAborted();
}
}
@@ -130,7 +134,7 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
this._session = session;
}
- async tap(x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
+ async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
}
}
diff --git a/packages/playwright-core/src/server/bidi/bidiPage.ts b/packages/playwright-core/src/server/bidi/bidiPage.ts
index f8d379d179..eacbe3e88f 100644
--- a/packages/playwright-core/src/server/bidi/bidiPage.ts
+++ b/packages/playwright-core/src/server/bidi/bidiPage.ts
@@ -510,7 +510,7 @@ export class BidiPage implements PageDelegate {
async inputActionEpilogue(): Promise<void> {
}
- async resetForReuse(): Promise<void> {
+ async resetForReuse(progress: Progress): Promise<void> {
}
async pdf(options: channels.PagePdfParams): Promise<Buffer> {
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index 5d9857d61a..cd49380705 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -36,13 +36,14 @@ import { RecorderApp } from './recorder/recorderApp';
import { Selectors } from './selectors';
import { Tracing } from './trace/recorder/tracing';
import * as rawStorageSource from '../generated/storageScriptSource';
+import { ProgressController } from './progress';
import type { Artifact } from './artifact';
import type { Browser, BrowserOptions } from './browser';
import type { Download } from './download';
import type * as frames from './frames';
import type { CallMetadata } from './instrumentation';
-import type { Progress, ProgressController } from './progress';
+import type { Progress } from './progress';
import type { ClientCertificatesProxy } from './socksClientCertificatesInterceptor';
import type { SerializedStorage } from '@injected/storageScript';
import type * as types from './types';
@@ -191,6 +192,11 @@ export abstract class BrowserContext extends SdkObject {
}
async resetForReuse(metadata: CallMetadata, params: channels.BrowserNewContextForReuseParams | null) {
+ const controller = new ProgressController(metadata, this);
+ return controller.run(progress => this.resetForReuseImpl(progress, params));
+ }
+
+ async resetForReuseImpl(progress: Progress, params: channels.BrowserNewContextForReuseParams | null) {
await this.tracing.resetForReuse();
if (params) {
@@ -204,14 +210,14 @@ export abstract class BrowserContext extends SdkObject {
let page: Page | undefined = this.pages()[0];
const [, ...otherPages] = this.pages();
for (const p of otherPages)
- await p.close(metadata);
+ await p.close();
if (page && page.hasCrashed()) {
- await page.close(metadata);
+ await page.close();
page = undefined;
}
// Navigate to about:blank first to ensure no page scripts are running after this point.
- await page?.mainFrame().goto(metadata, 'about:blank', { timeout: 0 });
+ await page?.mainFrame().gotoImpl(progress, 'about:blank', {});
await this._resetStorage();
await this.clock.resetForReuse();
@@ -227,7 +233,7 @@ export abstract class BrowserContext extends SdkObject {
await this.clearCache();
await this._resetCookies();
- await page?.resetForReuse(metadata);
+ await page?.resetForReuse(progress);
}
_browserClosed() {
@@ -398,7 +404,7 @@ export abstract class BrowserContext extends SdkObject {
// - chromium fails to change isMobile for existing page;
// - webkit fails to change locale for existing page.
await this.newPage(progress.metadata);
- await defaultPage.close(progress.metadata);
+ await defaultPage.close();
}
}
@@ -564,7 +570,7 @@ export abstract class BrowserContext extends SdkObject {
if (storage.localStorage.length || storage.indexedDB?.length)
result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
}
- await page.close(internalMetadata);
+ await page.close();
}
return result;
}
@@ -632,7 +638,7 @@ export abstract class BrowserContext extends SdkObject {
})()`;
await frame.evaluateExpression(restoreScript, { world: 'utility' });
}
- await page.close(internalMetadata);
+ await page.close();
}
} finally {
this._settingStorageState = false;
diff --git a/packages/playwright-core/src/server/chromium/crDragDrop.ts b/packages/playwright-core/src/server/chromium/crDragDrop.ts
index f94a306701..d10c36d370 100644
--- a/packages/playwright-core/src/server/chromium/crDragDrop.ts
+++ b/packages/playwright-core/src/server/chromium/crDragDrop.ts
@@ -19,6 +19,7 @@ import { assert } from '../../utils';
import type { CRPage } from './crPage';
import type * as types from '../types';
import type { Protocol } from './protocol';
+import type { Progress } from '../progress';
declare global {
@@ -51,7 +52,7 @@ export class DragManager {
return true;
}
- async interceptDragCausedByMove(x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, moveCallback: () => Promise<void>): Promise<void> {
+ 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', {
@@ -61,6 +62,7 @@ export class DragManager {
data: this._dragState,
modifiers: toModifiersMask(modifiers),
});
+ progress.throwIfAborted();
return;
}
if (button !== 'left')
@@ -91,6 +93,7 @@ export class DragManager {
}
await this._crPage._page.safeNonStallingEvaluateInAllFrames(`(${setupDragListeners.toString()})()`, 'utility');
+ progress.cleanupWhenAborted(() => this._crPage._page.safeNonStallingEvaluateInAllFrames('window.__cleanupDrag && window.__cleanupDrag()', 'utility'));
client.on('Input.dragIntercepted', onDragIntercepted!);
try {
@@ -109,7 +112,7 @@ export class DragManager {
this._dragState = expectingDrag ? (await dragInterceptedPromise).data : null;
client.off('Input.dragIntercepted', onDragIntercepted!);
await client.send('Input.setInterceptDrags', { enabled: false });
-
+ progress.throwIfAborted();
if (this._dragState) {
await this._crPage._mainFrameSession._client.send('Input.dispatchDragEvent', {
@@ -119,6 +122,7 @@ export class DragManager {
data: this._dragState,
modifiers: toModifiersMask(modifiers),
});
+ progress.throwIfAborted();
}
}
@@ -126,7 +130,7 @@ export class DragManager {
return !!this._dragState;
}
- async drop(x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
+ 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', {
type: 'drop',
@@ -136,5 +140,6 @@ export class DragManager {
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 2ec52432fb..8e045fc5c7 100644
--- a/packages/playwright-core/src/server/chromium/crInput.ts
+++ b/packages/playwright-core/src/server/chromium/crInput.ts
@@ -24,6 +24,7 @@ import type * as types from '../types';
import type { CRSession } from './crConnection';
import type { DragManager } from './crDragDrop';
import type { CRPage } from './crPage';
+import type { Progress } from '../progress';
export class RawKeyboardImpl implements input.RawKeyboard {
@@ -52,10 +53,11 @@ export class RawKeyboardImpl implements input.RawKeyboard {
return commands.map(c => c.substring(0, c.length - 1));
}
- async keydown(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
+ 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())
return;
+ progress.throwIfAborted();
const commands = this._commandsForCode(code, modifiers);
await this._client.send('Input.dispatchKeyEvent', {
type: text ? 'keyDown' : 'rawKeyDown',
@@ -70,9 +72,10 @@ export class RawKeyboardImpl implements input.RawKeyboard {
location,
isKeypad: location === input.keypadLocation
});
+ progress.throwIfAborted();
}
- async keyup(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
+ 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', {
type: 'keyUp',
@@ -82,10 +85,12 @@ export class RawKeyboardImpl implements input.RawKeyboard {
code,
location
});
+ progress.throwIfAborted();
}
- async sendText(text: string): Promise<void> {
+ async sendText(progress: Progress, text: string): Promise<void> {
await this._client.send('Input.insertText', { text });
+ progress.throwIfAborted();
}
}
@@ -100,7 +105,7 @@ export class RawMouseImpl implements input.RawMouse {
this._dragManager = dragManager;
}
- async move(x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
+ 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', {
type: 'mouseMoved',
@@ -115,12 +120,14 @@ export class RawMouseImpl implements input.RawMouse {
if (forClick) {
// Avoid extra protocol calls related to drag and drop, because click relies on
// move-down-up protocol commands being sent synchronously.
- return actualMove();
+ await actualMove();
+ progress.throwIfAborted();
+ return;
}
- await this._dragManager.interceptDragCausedByMove(x, y, button, buttons, modifiers, actualMove);
+ await this._dragManager.interceptDragCausedByMove(progress, x, y, button, buttons, modifiers, actualMove);
}
- async down(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
+ 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', {
@@ -133,11 +140,12 @@ export class RawMouseImpl implements input.RawMouse {
clickCount,
force: buttons.size > 0 ? 0.5 : 0,
});
+ progress.throwIfAborted();
}
- async up(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
+ async up(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()) {
- await this._dragManager.drop(x, y, modifiers);
+ await this._dragManager.drop(progress, x, y, modifiers);
return;
}
await this._client.send('Input.dispatchMouseEvent', {
@@ -149,9 +157,10 @@ export class RawMouseImpl implements input.RawMouse {
modifiers: toModifiersMask(modifiers),
clickCount
});
+ progress.throwIfAborted();
}
- async wheel(x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
+ 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', {
type: 'mouseWheel',
x,
@@ -160,6 +169,7 @@ export class RawMouseImpl implements input.RawMouse {
deltaX,
deltaY,
});
+ progress.throwIfAborted();
}
}
@@ -169,7 +179,7 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
constructor(client: CRSession) {
this._client = client;
}
- async tap(x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
+ async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
await Promise.all([
this._client.send('Input.dispatchTouchEvent', {
type: 'touchStart',
@@ -184,5 +194,6 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
touchPoints: []
}),
]);
+ progress.throwIfAborted();
}
}
diff --git a/packages/playwright-core/src/server/chromium/crPage.ts b/packages/playwright-core/src/server/chromium/crPage.ts
index 6a9f4d6613..0edd05aa47 100644
--- a/packages/playwright-core/src/server/chromium/crPage.ts
+++ b/packages/playwright-core/src/server/chromium/crPage.ts
@@ -339,9 +339,9 @@ export class CRPage implements PageDelegate {
await this._mainFrameSession._client.send('Page.enable').catch(e => {});
}
- async resetForReuse(): Promise<void> {
+ async resetForReuse(progress: Progress): Promise<void> {
// See https://github.com/microsoft/playwright/issues/22432.
- await this.rawMouse.move(-1, -1, 'none', new Set(), new Set(), true);
+ await this.rawMouse.move(progress, -1, -1, 'none', new Set(), new Set(), true);
}
async pdf(options: channels.PagePdfParams): Promise<Buffer> {
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index b824297c88..4d633c7f2c 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -238,7 +238,7 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
async close(params: channels.PageCloseParams, metadata: CallMetadata): Promise<void> {
if (!params.runBeforeUnload)
metadata.potentiallyClosesScope = true;
- await this._page.close(metadata, params);
+ await this._page.close(params);
}
async updateSubscription(params: channels.PageUpdateSubscriptionParams): Promise<void> {
@@ -251,47 +251,52 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
}
async keyboardDown(params: channels.PageKeyboardDownParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.down(params.key);
+ await this._page.keyboard.down(metadata, params.key);
}
async keyboardUp(params: channels.PageKeyboardUpParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.up(params.key);
+ await this._page.keyboard.up(metadata, params.key);
}
async keyboardInsertText(params: channels.PageKeyboardInsertTextParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.insertText(params.text);
+ await this._page.keyboard.insertText(metadata, params.text);
}
async keyboardType(params: channels.PageKeyboardTypeParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.type(params.text, params);
+ await this._page.keyboard.type(metadata, params.text, params);
}
async keyboardPress(params: channels.PageKeyboardPressParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.press(params.key, params);
+ await this._page.keyboard.press(metadata, params.key, params);
}
async mouseMove(params: channels.PageMouseMoveParams, metadata: CallMetadata): Promise<void> {
- await this._page.mouse.move(params.x, params.y, params, metadata);
+ metadata.point = { x: params.x, y: params.y };
+ await this._page.mouse.move(metadata, params.x, params.y, params);
}
async mouseDown(params: channels.PageMouseDownParams, metadata: CallMetadata): Promise<void> {
- await this._page.mouse.down(params, metadata);
+ metadata.point = this._page.mouse.currentPoint();
+ await this._page.mouse.down(metadata, params);
}
async mouseUp(params: channels.PageMouseUpParams, metadata: CallMetadata): Promise<void> {
- await this._page.mouse.up(params, metadata);
+ metadata.point = this._page.mouse.currentPoint();
+ await this._page.mouse.up(metadata, params);
}
async mouseClick(params: channels.PageMouseClickParams, metadata: CallMetadata): Promise<void> {
- await this._page.mouse.click(params.x, params.y, params, metadata);
+ metadata.point = { x: params.x, y: params.y };
+ await this._page.mouse.click(metadata, params.x, params.y, params);
}
async mouseWheel(params: channels.PageMouseWheelParams, metadata: CallMetadata): Promise<void> {
- await this._page.mouse.wheel(params.deltaX, params.deltaY);
+ await this._page.mouse.wheel(metadata, params.deltaX, params.deltaY);
}
async touchscreenTap(params: channels.PageTouchscreenTapParams, metadata: CallMetadata): Promise<void> {
- await this._page.touchscreen.tap(params.x, params.y, metadata);
+ metadata.point = { x: params.x, y: params.y };
+ await this._page.touchscreen.tap(metadata, params.x, params.y);
}
async accessibilitySnapshot(params: channels.PageAccessibilitySnapshotParams, metadata: CallMetadata): Promise<channels.PageAccessibilitySnapshotResult> {
diff --git a/packages/playwright-core/src/server/dom.ts b/packages/playwright-core/src/server/dom.ts
index c2f422b864..835c9331b6 100644
--- a/packages/playwright-core/src/server/dom.ts
+++ b/packages/playwright-core/src/server/dom.ts
@@ -504,11 +504,11 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
progress.throwIfAborted(); // Avoid action that has side-effects.
let restoreModifiers: types.KeyboardModifier[] | undefined;
if (options && options.modifiers)
- restoreModifiers = await this._page.keyboard.ensureModifiers(options.modifiers);
+ restoreModifiers = await this._page.keyboard.ensureModifiers(progress, options.modifiers);
progress.log(` performing ${actionName} action`);
await action(point);
if (restoreModifiers)
- await this._page.keyboard.ensureModifiers(restoreModifiers);
+ await this._page.keyboard.ensureModifiers(progress, restoreModifiers);
if (hitTargetInterceptionHandle) {
const stopHitTargetInterception = this._frame.raceAgainstEvaluationStallingEvents(() => {
return hitTargetInterceptionHandle.evaluate(h => h.stop());
@@ -554,7 +554,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
_hover(progress: Progress, options: types.PointerActionOptions & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
- return this._retryPointerAction(progress, 'hover', false /* waitForEnabled */, point => this._page.mouse.move(point.x, point.y), { ...options, waitAfter: 'disabled' });
+ return this._retryPointerAction(progress, 'hover', false /* waitForEnabled */, point => this._page.mouse._move(progress, point.x, point.y), { ...options, waitAfter: 'disabled' });
}
async click(metadata: CallMetadata, options: { noWaitAfter?: boolean } & types.MouseClickOptions & types.PointerActionWaitOptions): Promise<void> {
@@ -567,7 +567,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
_click(progress: Progress, options: { waitAfter: boolean | 'disabled' } & types.MouseClickOptions & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
- return this._retryPointerAction(progress, 'click', true /* waitForEnabled */, point => this._page.mouse.click(point.x, point.y, options), options);
+ return this._retryPointerAction(progress, 'click', true /* waitForEnabled */, point => this._page.mouse._click(progress, point.x, point.y, options), options);
}
async dblclick(metadata: CallMetadata, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions): Promise<void> {
@@ -580,7 +580,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
_dblclick(progress: Progress, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
- return this._retryPointerAction(progress, 'dblclick', true /* waitForEnabled */, point => this._page.mouse.dblclick(point.x, point.y, options), { ...options, waitAfter: 'disabled' });
+ return this._retryPointerAction(progress, 'dblclick', true /* waitForEnabled */, point => this._page.mouse._click(progress, point.x, point.y, { ...options, clickCount: 2 }), { ...options, waitAfter: 'disabled' });
}
async tap(metadata: CallMetadata, options: types.PointerActionWaitOptions): Promise<void> {
@@ -593,7 +593,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
_tap(progress: Progress, options: types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
- return this._retryPointerAction(progress, 'tap', true /* waitForEnabled */, point => this._page.touchscreen.tap(point.x, point.y), { ...options, waitAfter: 'disabled' });
+ return this._retryPointerAction(progress, 'tap', true /* waitForEnabled */, point => this._page.touchscreen._tap(progress, point.x, point.y), { ...options, waitAfter: 'disabled' });
}
async selectOption(metadata: CallMetadata, elements: ElementHandle[], values: types.SelectOption[], options: types.CommonActionOptions): Promise<string[]> {
@@ -658,9 +658,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
progress.throwIfAborted(); // Avoid action that has side-effects.
if (result === 'needsinput') {
if (value)
- await this._page.keyboard.insertText(value);
+ await this._page.keyboard._insertText(progress, value);
else
- await this._page.keyboard.press('Delete');
+ await this._page.keyboard._press(progress, 'Delete');
return 'done';
} else {
return result;
@@ -773,7 +773,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if (result !== 'done')
return result;
progress.throwIfAborted(); // Avoid action that has side-effects.
- await this._page.keyboard.type(text, options);
+ await this._page.keyboard._type(progress, text, options);
return 'done';
}
@@ -794,7 +794,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if (result !== 'done')
return result;
progress.throwIfAborted(); // Avoid action that has side-effects.
- await this._page.keyboard.press(key, options);
+ await this._page.keyboard._press(progress, key, options);
return 'done';
});
}
diff --git a/packages/playwright-core/src/server/firefox/ffInput.ts b/packages/playwright-core/src/server/firefox/ffInput.ts
index 42d2c71ebf..9485c4a881 100644
--- a/packages/playwright-core/src/server/firefox/ffInput.ts
+++ b/packages/playwright-core/src/server/firefox/ffInput.ts
@@ -17,6 +17,7 @@
import type * as input from '../input';
import type { Page } from '../page';
+import type { Progress } from '../progress';
import type * as types from '../types';
import type { FFSession } from './ffConnection';
@@ -61,7 +62,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
this._client = client;
}
- async keydown(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
+ async keydown(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
let text = description.text;
// Firefox will figure out Enter by itself
if (text === '\r')
@@ -76,9 +77,10 @@ export class RawKeyboardImpl implements input.RawKeyboard {
location,
text,
});
+ progress.throwIfAborted();
}
- async keyup(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
+ 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', {
type: 'keyup',
@@ -88,10 +90,12 @@ export class RawKeyboardImpl implements input.RawKeyboard {
location,
repeat: false
});
+ progress.throwIfAborted();
}
- async sendText(text: string): Promise<void> {
+ async sendText(progress: Progress, text: string): Promise<void> {
await this._client.send('Page.insertText', { text });
+ progress.throwIfAborted();
}
}
@@ -103,7 +107,7 @@ export class RawMouseImpl implements input.RawMouse {
this._client = client;
}
- async move(x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
+ 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', {
type: 'mousemove',
button: 0,
@@ -112,9 +116,10 @@ export class RawMouseImpl implements input.RawMouse {
y: Math.floor(y),
modifiers: toModifiersMask(modifiers)
});
+ progress.throwIfAborted();
}
- async down(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
+ 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', {
type: 'mousedown',
button: toButtonNumber(button),
@@ -124,9 +129,10 @@ export class RawMouseImpl implements input.RawMouse {
modifiers: toModifiersMask(modifiers),
clickCount
});
+ progress.throwIfAborted();
}
- async up(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
+ 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', {
type: 'mouseup',
button: toButtonNumber(button),
@@ -136,9 +142,10 @@ export class RawMouseImpl implements input.RawMouse {
modifiers: toModifiersMask(modifiers),
clickCount
});
+ progress.throwIfAborted();
}
- async wheel(x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
+ 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', {
@@ -149,6 +156,7 @@ export class RawMouseImpl implements input.RawMouse {
deltaZ: 0,
modifiers: toModifiersMask(modifiers)
});
+ progress.throwIfAborted();
}
setPage(page: Page) {
@@ -162,11 +170,12 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
constructor(client: FFSession) {
this._client = client;
}
- async tap(x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
+ async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
await this._client.send('Page.dispatchTapEvent', {
x,
y,
modifiers: toModifiersMask(modifiers),
});
+ progress.throwIfAborted();
}
}
diff --git a/packages/playwright-core/src/server/firefox/ffPage.ts b/packages/playwright-core/src/server/firefox/ffPage.ts
index c4bf23a6ac..49ddf5a5c9 100644
--- a/packages/playwright-core/src/server/firefox/ffPage.ts
+++ b/packages/playwright-core/src/server/firefox/ffPage.ts
@@ -545,12 +545,12 @@ export class FFPage implements PageDelegate {
async inputActionEpilogue(): Promise<void> {
}
- async resetForReuse(): Promise<void> {
+ async resetForReuse(progress: Progress): Promise<void> {
// Firefox sometimes keeps the last mouse position in the page,
// which affects things like hovered state.
// See https://github.com/microsoft/playwright/issues/22432.
// Move mouse to (-1, -1) to avoid anything being hovered.
- await this.rawMouse.move(-1, -1, 'none', new Set(), new Set(), false);
+ await this.rawMouse.move(progress, -1, -1, 'none', new Set(), new Set(), false);
}
async getFrameElement(frame: frames.Frame): Promise<dom.ElementHandle> {
diff --git a/packages/playwright-core/src/server/frames.ts b/packages/playwright-core/src/server/frames.ts
index c6f4791410..d173770292 100644
--- a/packages/playwright-core/src/server/frames.ts
+++ b/packages/playwright-core/src/server/frames.ts
@@ -604,7 +604,7 @@ export class Frame extends SdkObject {
const controller = new ProgressController(serverSideCallMetadata(), this);
const data = {
url,
- gotoPromise: controller.run(progress => this._gotoAction(progress, url, { referer }), 0),
+ gotoPromise: controller.run(progress => this.gotoImpl(progress, url, { referer }), 0),
};
this._redirectedNavigations.set(documentId, data);
data.gotoPromise.finally(() => this._redirectedNavigations.delete(documentId));
@@ -614,11 +614,11 @@ export class Frame extends SdkObject {
const constructedNavigationURL = constructURLBasedOnBaseURL(this._page.browserContext._options.baseURL, url);
const controller = new ProgressController(metadata, this);
return controller.run(progress => {
- return this.raceNavigationAction(progress, options, async () => this._gotoAction(progress, constructedNavigationURL, options));
+ return this.raceNavigationAction(progress, options, async () => this.gotoImpl(progress, constructedNavigationURL, options));
}, options.timeout);
}
- private async _gotoAction(progress: Progress, url: string, options: Omit<types.GotoOptions, 'timeout'>): Promise<network.Response | null> {
+ async gotoImpl(progress: Progress, url: string, options: Omit<types.GotoOptions, 'timeout'>): Promise<network.Response | null> {
const waitUntil = verifyLifecycle('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
progress.log(`navigating to "${url}", waiting until "${waitUntil}"`);
const headers = this._page.extraHTTPHeaders() || [];
@@ -1162,8 +1162,8 @@ export class Frame extends SdkObject {
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 => {
- await this._page.mouse.move(point.x, point.y);
- await this._page.mouse.down();
+ await this._page.mouse._move(progress, point.x, point.y);
+ await this._page.mouse._down(progress);
}, {
...options,
waitAfter: 'disabled',
@@ -1174,8 +1174,8 @@ export class Frame extends SdkObject {
// Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performActionPreChecks */, async handle => {
return handle._retryPointerAction(progress, 'move and up', false, async point => {
- await this._page.mouse.move(point.x, point.y);
- await this._page.mouse.up();
+ await this._page.mouse._move(progress, point.x, point.y);
+ await this._page.mouse._up(progress);
}, {
...options,
waitAfter: 'disabled',
diff --git a/packages/playwright-core/src/server/input.ts b/packages/playwright-core/src/server/input.ts
index 9c8a72fccf..a82dc69ae8 100644
--- a/packages/playwright-core/src/server/input.ts
+++ b/packages/playwright-core/src/server/input.ts
@@ -16,8 +16,10 @@
import { assert } from '../utils';
import * as keyboardLayout from './usKeyboardLayout';
+import { ProgressController } from './progress';
-import type { CallMetadata } from './instrumentation';
+import type { CallMetadata } from '@protocol/callMetadata';
+import type { Progress } from './progress';
import type { Page } from './page';
import type * as types from './types';
@@ -36,27 +38,34 @@ export type KeyDescription = {
const kModifiers: types.KeyboardModifier[] = ['Alt', 'Control', 'Meta', 'Shift'];
export interface RawKeyboard {
- keydown(modifiers: Set<types.KeyboardModifier>, keyName: string, description: KeyDescription, autoRepeat: boolean): Promise<void>;
- keyup(modifiers: Set<types.KeyboardModifier>, keyName: string, description: KeyDescription): Promise<void>;
- sendText(text: string): Promise<void>;
+ keydown(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: KeyDescription, autoRepeat: boolean): Promise<void>;
+ keyup(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: KeyDescription): Promise<void>;
+ sendText(progress: Progress, text: string): Promise<void>;
}
export class Keyboard {
private _pressedModifiers = new Set<types.KeyboardModifier>();
private _pressedKeys = new Set<string>();
private _raw: RawKeyboard;
+ private _page: Page;
- constructor(raw: RawKeyboard) {
+ constructor(raw: RawKeyboard, page: Page) {
this._raw = raw;
+ this._page = page;
+ }
+
+ async down(metadata: CallMetadata, key: string) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._down(progress, key));
}
- async down(key: string) {
+ async _down(progress: Progress, key: string) {
const description = this._keyDescriptionForString(key);
const autoRepeat = this._pressedKeys.has(description.code);
this._pressedKeys.add(description.code);
if (kModifiers.includes(description.key as types.KeyboardModifier))
this._pressedModifiers.add(description.key as types.KeyboardModifier);
- await this._raw.keydown(this._pressedModifiers, key, description, autoRepeat);
+ await this._raw.keydown(progress, this._pressedModifiers, key, description, autoRepeat);
}
private _keyDescriptionForString(str: string): KeyDescription {
@@ -72,32 +81,52 @@ export class Keyboard {
return description;
}
- async up(key: string) {
+ async up(metadata: CallMetadata, key: string) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._up(progress, key));
+ }
+
+ async _up(progress: Progress, key: string) {
const description = this._keyDescriptionForString(key);
if (kModifiers.includes(description.key as types.KeyboardModifier))
this._pressedModifiers.delete(description.key as types.KeyboardModifier);
this._pressedKeys.delete(description.code);
- await this._raw.keyup(this._pressedModifiers, key, description);
+ await this._raw.keyup(progress, this._pressedModifiers, key, description);
+ }
+
+ async insertText(metadata: CallMetadata, text: string) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._insertText(progress, text));
+ }
+
+ async _insertText(progress: Progress, text: string) {
+ await this._raw.sendText(progress, text);
}
- async insertText(text: string) {
- await this._raw.sendText(text);
+ async type(metadata: CallMetadata, text: string, options?: { delay?: number }) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._type(progress, text, options));
}
- async type(text: string, options?: { delay?: number }) {
+ async _type(progress: Progress, text: string, options?: { delay?: number }) {
const delay = (options && options.delay) || undefined;
for (const char of text) {
if (usKeyboardLayout.has(char)) {
- await this.press(char, { delay });
+ await this._press(progress, char, { delay });
} else {
if (delay)
- await new Promise(f => setTimeout(f, delay));
- await this.insertText(char);
+ await wait(progress, delay);
+ await this._insertText(progress, char);
}
}
}
- async press(key: string, options: { delay?: number } = {}) {
+ async press(metadata: CallMetadata, key: string, options: { delay?: number }) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._press(progress, key, options));
+ }
+
+ async _press(progress: Progress, key: string, options: { delay?: number } = {}) {
function split(keyString: string) {
const keys = [];
let building = '';
@@ -116,16 +145,16 @@ export class Keyboard {
const tokens = split(key);
key = tokens[tokens.length - 1];
for (let i = 0; i < tokens.length - 1; ++i)
- await this.down(tokens[i]);
- await this.down(key);
+ await this._down(progress, tokens[i]);
+ await this._down(progress, key);
if (options.delay)
- await new Promise(f => setTimeout(f, options.delay));
- await this.up(key);
+ await wait(progress, options.delay);
+ await this._up(progress, key);
for (let i = tokens.length - 2; i >= 0; --i)
- await this.up(tokens[i]);
+ await this._up(progress, tokens[i]);
}
- async ensureModifiers(mm: types.SmartKeyboardModifier[]): Promise<types.KeyboardModifier[]> {
+ async ensureModifiers(progress: Progress, mm: types.SmartKeyboardModifier[]): Promise<types.KeyboardModifier[]> {
const modifiers = mm.map(resolveSmartModifier);
for (const modifier of modifiers) {
if (!kModifiers.includes(modifier))
@@ -136,9 +165,9 @@ export class Keyboard {
const needDown = modifiers.includes(key);
const isDown = this._pressedModifiers.has(key);
if (needDown && !isDown)
- await this.down(key);
+ await this._down(progress, key);
else if (!needDown && isDown)
- await this.up(key);
+ await this._up(progress, key);
}
return restore;
}
@@ -159,10 +188,10 @@ export function resolveSmartModifier(m: types.SmartKeyboardModifier): types.Keyb
}
export interface RawMouse {
- move(x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void>;
- down(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void>;
- up(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void>;
- wheel(x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void>;
+ move(progress: Progress, x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void>;
+ down(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void>;
+ up(progress: Progress, x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void>;
+ wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void>;
}
export class Mouse {
@@ -180,9 +209,16 @@ export class Mouse {
this._keyboard = this._page.keyboard;
}
- async move(x: number, y: number, options: { steps?: number, forClick?: boolean } = {}, metadata?: CallMetadata) {
- if (metadata)
- metadata.point = { x, y };
+ currentPoint() {
+ return { x: this._x, y: this._y };
+ }
+
+ async move(metadata: CallMetadata, x: number, y: number, options: { steps?: number, forClick?: boolean }) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._move(progress, x, y, options));
+ }
+
+ async _move(progress: Progress, x: number, y: number, options: { steps?: number, forClick?: boolean } = {}) {
const { steps = 1 } = options;
const fromX = this._x;
const fromY = this._y;
@@ -191,58 +227,66 @@ export class Mouse {
for (let i = 1; i <= steps; i++) {
const middleX = fromX + (x - fromX) * (i / steps);
const middleY = fromY + (y - fromY) * (i / steps);
- await this._raw.move(middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
+ await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
}
}
- async down(options: { button?: types.MouseButton, clickCount?: number } = {}, metadata?: CallMetadata) {
- if (metadata)
- metadata.point = { x: this._x, y: this._y };
+ async down(metadata: CallMetadata, options: { button?: types.MouseButton, clickCount?: number }) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._down(progress, options));
+ }
+
+ async _down(progress: Progress, options: { button?: types.MouseButton, clickCount?: number } = {}) {
const { button = 'left', clickCount = 1 } = options;
this._lastButton = button;
this._buttons.add(button);
- await this._raw.down(this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
+ await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
}
- async up(options: { button?: types.MouseButton, clickCount?: number } = {}, metadata?: CallMetadata) {
- if (metadata)
- metadata.point = { x: this._x, y: this._y };
+ async up(metadata: CallMetadata, options: { button?: types.MouseButton, clickCount?: number }) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._up(progress, options));
+ }
+
+ async _up(progress: Progress, options: { button?: types.MouseButton, clickCount?: number } = {}) {
const { button = 'left', clickCount = 1 } = options;
this._lastButton = 'none';
this._buttons.delete(button);
- await this._raw.up(this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
+ await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
+ }
+
+ async click(metadata: CallMetadata, x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number }) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._click(progress, x, y, options));
}
- async click(x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number } = {}, metadata?: CallMetadata) {
- if (metadata)
- metadata.point = { x, y };
+ async _click(progress: Progress, x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number } = {}) {
const { delay = null, clickCount = 1 } = options;
if (delay) {
- this.move(x, y, { forClick: true });
+ this._move(progress, x, y, { forClick: true });
for (let cc = 1; cc <= clickCount; ++cc) {
- await this.down({ ...options, clickCount: cc });
- await new Promise(f => setTimeout(f, delay));
- await this.up({ ...options, clickCount: cc });
+ await this._down(progress, { ...options, clickCount: cc });
+ await wait(progress, delay);
+ await this._up(progress, { ...options, clickCount: cc });
if (cc < clickCount)
- await new Promise(f => setTimeout(f, delay));
+ await wait(progress, delay);
}
} else {
const promises = [];
- promises.push(this.move(x, y, { forClick: true }));
+ promises.push(this._move(progress, x, y, { forClick: true }));
for (let cc = 1; cc <= clickCount; ++cc) {
- promises.push(this.down({ ...options, clickCount: cc }));
- promises.push(this.up({ ...options, clickCount: cc }));
+ promises.push(this._down(progress, { ...options, clickCount: cc }));
+ promises.push(this._up(progress, { ...options, clickCount: cc }));
}
await Promise.all(promises);
}
}
- async dblclick(x: number, y: number, options: { delay?: number, button?: types.MouseButton } = {}) {
- await this.click(x, y, { ...options, clickCount: 2 });
- }
-
- async wheel(deltaX: number, deltaY: number) {
- await this._raw.wheel(this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+ async wheel(metadata: CallMetadata, deltaX: number, deltaY: number) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(async progress => {
+ await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+ });
}
}
@@ -307,7 +351,7 @@ function buildLayoutClosure(layout: keyboardLayout.KeyboardLayout): Map<string,
}
export interface RawTouchscreen {
- tap(x: number, y: number, modifiers: Set<types.KeyboardModifier>): Promise<void>;
+ tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>): Promise<void>;
}
export class Touchscreen {
@@ -319,11 +363,19 @@ export class Touchscreen {
this._page = page;
}
- async tap(x: number, y: number, metadata?: CallMetadata) {
- if (metadata)
- metadata.point = { x, y };
+ async tap(metadata: CallMetadata, x: number, y: number) {
+ const controller = new ProgressController(metadata, this._page);
+ return controller.run(progress => this._tap(progress, x, y));
+ }
+
+ async _tap(progress: Progress, x: number, y: number) {
if (!this._page.browserContext._options.hasTouch)
throw new Error('hasTouch must be enabled on the browser context before using the touchscreen.');
- await this._raw.tap(x, y, this._page.keyboard._modifiers());
+ 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/launchApp.ts b/packages/playwright-core/src/server/launchApp.ts
index 5ef69fcb87..3b3bcda5bf 100644
--- a/packages/playwright-core/src/server/launchApp.ts
+++ b/packages/playwright-core/src/server/launchApp.ts
@@ -65,7 +65,7 @@ export async function launchApp(browserType: BrowserType, options: {
context.on('page', async (newPage: Page) => {
if (newPage.mainFrame().url() === 'chrome://new-tab-page/') {
await page.bringToFront();
- await newPage.close(serverSideCallMetadata());
+ await newPage.close();
}
});
}
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index 66947dfb49..b2ca066122 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -94,7 +94,7 @@ export interface PageDelegate {
// Work around for asynchronously dispatched CSP errors in Firefox.
readonly cspErrorsAsynchronousForInlineScripts?: boolean;
// Work around for mouse position in Firefox.
- resetForReuse(): Promise<void>;
+ resetForReuse(progress: Progress): Promise<void>;
// WebKit hack.
shouldToggleStyleSheetToSyncAnimations(): boolean;
}
@@ -180,7 +180,7 @@ export class Page extends SdkObject {
this.delegate = delegate;
this.browserContext = browserContext;
this.accessibility = new accessibility.Accessibility(delegate.getAccessibilityTree.bind(delegate));
- this.keyboard = new input.Keyboard(delegate.rawKeyboard);
+ this.keyboard = new input.Keyboard(delegate.rawKeyboard, this);
this.mouse = new input.Mouse(delegate.rawMouse, this);
this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
this.screenshotter = new Screenshotter(this);
@@ -254,12 +254,12 @@ export class Page extends SdkObject {
this._eventsToEmitAfterInitialized.push({ event, args });
}
- async resetForReuse(metadata: CallMetadata) {
+ async resetForReuse(progress: Progress) {
this._locatorHandlers.clear();
// Re-navigate once init scripts are gone.
// TODO: we should have a timeout for `resetForReuse`.
- await this.mainFrame().goto(metadata, 'about:blank', { timeout: 0 });
+ await this.mainFrame().gotoImpl(progress, 'about:blank', {});
this._emulatedSize = undefined;
this._emulatedMedia = {};
this._extraHTTPHeaders = undefined;
@@ -269,7 +269,7 @@ export class Page extends SdkObject {
this.delegate.updateEmulateMedia(),
]);
- await this.delegate.resetForReuse();
+ await this.delegate.resetForReuse(progress);
}
_didClose() {
@@ -695,7 +695,7 @@ export class Page extends SdkObject {
options.timeout);
}
- async close(metadata: CallMetadata, options: { runBeforeUnload?: boolean, reason?: string } = {}) {
+ async close(options: { runBeforeUnload?: boolean, reason?: string } = {}) {
if (this._closedState === 'closed')
return;
if (options.reason)
diff --git a/packages/playwright-core/src/server/recorder/recorderRunner.ts b/packages/playwright-core/src/server/recorder/recorderRunner.ts
index 5936060609..5253643e6d 100644
--- a/packages/playwright-core/src/server/recorder/recorderRunner.ts
+++ b/packages/playwright-core/src/server/recorder/recorderRunner.ts
@@ -39,7 +39,7 @@ export async function performAction(pageAliases: Map<Page, string>, actionInCont
throw Error('Not reached');
if (action.name === 'closePage') {
- await mainFrame._page.close(callMetadata);
+ await mainFrame._page.close();
return;
}
diff --git a/packages/playwright-core/src/server/webkit/wkInput.ts b/packages/playwright-core/src/server/webkit/wkInput.ts
index dd4b1f9456..148e96b29d 100644
--- a/packages/playwright-core/src/server/webkit/wkInput.ts
+++ b/packages/playwright-core/src/server/webkit/wkInput.ts
@@ -22,6 +22,7 @@ import { macEditingCommands } from '../macEditingCommands';
import type * as types from '../types';
import type { WKSession } from './wkConnection';
import type { Page } from '../page';
+import type { Progress } from '../progress';
function toModifiersMask(modifiers: Set<types.KeyboardModifier>): number {
// From Source/WebKit/Shared/WebEvent.h
@@ -60,7 +61,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
this._session = session;
}
- async keydown(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
+ async keydown(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
const parts = [];
for (const modifier of (['Shift', 'Control', 'Alt', 'Meta']) as types.KeyboardModifier[]) {
if (modifiers.has(modifier))
@@ -84,9 +85,10 @@ export class RawKeyboardImpl implements input.RawKeyboard {
macCommands: commands,
isKeypad: description.location === input.keypadLocation
});
+ progress.throwIfAborted();
}
- async keyup(modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
+ 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', {
type: 'keyUp',
@@ -96,10 +98,12 @@ export class RawKeyboardImpl implements input.RawKeyboard {
code,
isKeypad: description.location === input.keypadLocation
});
+ progress.throwIfAborted();
}
- async sendText(text: string): Promise<void> {
+ async sendText(progress: Progress, text: string): Promise<void> {
await this._session!.send('Page.insertText', { text });
+ progress.throwIfAborted();
}
}
@@ -116,7 +120,7 @@ export class RawMouseImpl implements input.RawMouse {
this._session = session;
}
- async move(x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
+ 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', {
type: 'move',
button,
@@ -125,9 +129,10 @@ export class RawMouseImpl implements input.RawMouse {
y,
modifiers: toModifiersMask(modifiers)
});
+ progress.throwIfAborted();
}
- async down(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
+ 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', {
type: 'down',
button,
@@ -137,9 +142,10 @@ export class RawMouseImpl implements input.RawMouse {
modifiers: toModifiersMask(modifiers),
clickCount
});
+ progress.throwIfAborted();
}
- async up(x: number, y: number, button: types.MouseButton, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, clickCount: number): Promise<void> {
+ 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', {
type: 'up',
button,
@@ -149,14 +155,16 @@ export class RawMouseImpl implements input.RawMouse {
modifiers: toModifiersMask(modifiers),
clickCount
});
+ progress.throwIfAborted();
}
- async wheel(x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
+ async wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
if (this._page?.browserContext._options.isMobile)
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', {
x,
y,
@@ -164,6 +172,7 @@ export class RawMouseImpl implements input.RawMouse {
deltaY,
modifiers: toModifiersMask(modifiers),
});
+ progress.throwIfAborted();
}
setPage(page: Page) {
@@ -178,11 +187,12 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {
this._pageProxySession = session;
}
- async tap(x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
+ async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
await this._pageProxySession.send('Input.dispatchTapEvent', {
x,
y,
modifiers: toModifiersMask(modifiers),
});
+ progress.throwIfAborted();
}
}
diff --git a/packages/playwright-core/src/server/webkit/wkPage.ts b/packages/playwright-core/src/server/webkit/wkPage.ts
index 8e28449373..9970701684 100644
--- a/packages/playwright-core/src/server/webkit/wkPage.ts
+++ b/packages/playwright-core/src/server/webkit/wkPage.ts
@@ -994,7 +994,7 @@ export class WKPage implements PageDelegate {
async inputActionEpilogue(): Promise<void> {
}
- async resetForReuse(): Promise<void> {
+ async resetForReuse(progress: Progress): Promise<void> {
}
async getFrameElement(frame: frames.Frame): Promise<dom.ElementHandle> {