Skip to content

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

chore: enforce dispatcher API convention for server types (3) (#40035)

Pavel Feldman99ebd57f9ed0
diff --git a/packages/playwright-core/src/androidServerImpl.ts b/packages/playwright-core/src/androidServerImpl.ts
index d1b2626504..da6029b9d3 100644
--- a/packages/playwright-core/src/androidServerImpl.ts
+++ b/packages/playwright-core/src/androidServerImpl.ts
@@ -18,7 +18,7 @@ import { PlaywrightServer } from './remote/playwrightServer';
import { createPlaywright } from './server/playwright';
import { createGuid } from './server/utils/crypto';
import { ws } from './utilsBundle';
-import { ProgressController } from './server/progress';
+import { nullProgress, ProgressController } from './server/progress';
import type { BrowserServer } from './client/browserType';
import type { LaunchAndroidServerOptions } from './client/types';
@@ -58,8 +58,8 @@ export class AndroidServerLauncherImpl {
// 3. Return the BrowserServer interface
const browserServer = new ws.EventEmitter() as (BrowserServer & WebSocketEventEmitter);
browserServer.wsEndpoint = () => wsEndpoint;
- browserServer.close = () => device.close();
- browserServer.kill = () => device.close();
+ browserServer.close = () => device.close(nullProgress);
+ browserServer.kill = () => device.close(nullProgress);
device.on('close', () => {
server.close();
browserServer.emit('close');
diff --git a/packages/playwright-core/src/remote/playwrightServer.ts b/packages/playwright-core/src/remote/playwrightServer.ts
index 8a0eea69b5..89a7cecae2 100644
--- a/packages/playwright-core/src/remote/playwrightServer.ts
+++ b/packages/playwright-core/src/remote/playwrightServer.ts
@@ -25,7 +25,7 @@ import { getPlaywrightVersion } from '../server/utils/userAgent';
import { debugLogger, isUnderTest } from '../utils';
import { SocksProxy } from '../server/utils/socksProxy';
import { Browser } from '../server/browser';
-import { ProgressController } from '../server/progress';
+import { nullProgress, ProgressController } from '../server/progress';
import type { AndroidDevice } from '../server/android/android';
import type { Playwright } from '../server/playwright';
@@ -204,7 +204,7 @@ export class PlaywrightServer {
if (this._dontReuseBrowsers.has(b))
continue;
if (b.options.name === browserName && b.options.channel === launchOptions.channel)
- await b.close({ reason: 'Connection terminated' });
+ await b.close(nullProgress, { reason: 'Connection terminated' });
}
if (!browser) {
@@ -225,7 +225,7 @@ export class PlaywrightServer {
// keep around browser so it can be reused by the next connection.
for (const context of browser.contexts()) {
if (!context.pages().length)
- await context.close({ reason: 'Connection terminated' });
+ await context.close(nullProgress, { reason: 'Connection terminated' });
}
}
};
@@ -259,7 +259,7 @@ export class PlaywrightServer {
// In pre-launched mode, keep only the pre-launched browser.
for (const b of this._playwright.allBrowsers()) {
if (b !== browser)
- await b.close({ reason: 'Connection terminated' });
+ await b.close(nullProgress, { reason: 'Connection terminated' });
}
return {
@@ -299,7 +299,7 @@ export class PlaywrightServer {
socksProxy,
denyLaunch: true,
dispose: async () => {
- await browser.close({ reason: 'Connection terminated' });
+ await browser.close(nullProgress, { reason: 'Connection terminated' });
socksProxy?.close();
},
};
diff --git a/packages/playwright-core/src/server/android/android.ts b/packages/playwright-core/src/server/android/android.ts
index 5487f037e5..90d8ccf115 100644
--- a/packages/playwright-core/src/server/android/android.ts
+++ b/packages/playwright-core/src/server/android/android.ts
@@ -138,13 +138,17 @@ export class AndroidDevice extends SdkObject {
this._pollingWebViews = setTimeout(() => this._refreshWebViews()
.then(poll)
.catch(() => {
- this.close().catch(() => {});
+ this._close().catch(() => {});
}), 500);
};
poll();
}
- async shell(command: string): Promise<Buffer> {
+ async shell(progress: Progress, command: string): Promise<Buffer> {
+ return await progress.race(this._shell(command));
+ }
+
+ private async _shell(command: string): Promise<Buffer> {
const result = await this._backend.runCommand(`shell:${command}`);
await this._refreshWebViews();
return result;
@@ -154,8 +158,8 @@ export class AndroidDevice extends SdkObject {
return await this._open(progress, command);
}
- async screenshot(): Promise<Buffer> {
- return await this._backend.runCommand(`shell:screencap -p`);
+ async screenshot(progress: Progress): Promise<Buffer> {
+ return await progress.race(this._backend.runCommand(`shell:screencap -p`));
}
private async _driver(): Promise<PipeTransport | undefined> {
@@ -170,13 +174,13 @@ export class AndroidDevice extends SdkObject {
private async _installDriver(progress: Progress): Promise<PipeTransport> {
debug('pw:android')('Stopping the old driver');
- await progress.race(this.shell(`am force-stop com.microsoft.playwright.androiddriver`));
+ await progress.race(this._shell(`am force-stop com.microsoft.playwright.androiddriver`));
// uninstall and install driver on every execution
if (!this._options.omitDriverInstall) {
debug('pw:android')('Uninstalling the old driver');
- await progress.race(this.shell(`cmd package uninstall com.microsoft.playwright.androiddriver`));
- await progress.race(this.shell(`cmd package uninstall com.microsoft.playwright.androiddriver.test`));
+ await this.shell(progress, `cmd package uninstall com.microsoft.playwright.androiddriver`);
+ await this.shell(progress, `cmd package uninstall com.microsoft.playwright.androiddriver.test`);
debug('pw:android')('Installing the new driver');
const executable = registry.findExecutable('android')!;
@@ -192,7 +196,7 @@ export class AndroidDevice extends SdkObject {
}
debug('pw:android')('Starting the new driver');
- this.shell('am instrument -w com.microsoft.playwright.androiddriver.test/androidx.test.runner.AndroidJUnitRunner').catch(e => debug('pw:android')(e));
+ this._shell('am instrument -w com.microsoft.playwright.androiddriver.test/androidx.test.runner.AndroidJUnitRunner').catch(e => debug('pw:android')(e));
const socket = await this._waitForLocalAbstract(progress, 'playwright_android_driver_socket');
const transport = new PipeTransport(socket, socket, socket, 'be');
transport.onmessage = message => {
@@ -226,7 +230,11 @@ export class AndroidDevice extends SdkObject {
return socket;
}
- async send(method: string, params: any = {}): Promise<any> {
+ async send(progress: Progress, method: string, params: any = {}): Promise<any> {
+ return await progress.race(this._send(method, params));
+ }
+
+ private async _send(method: string, params: any = {}): Promise<any> {
params = {
...params,
// Patch the timeout in, just in case it's missing in one of the commands.
@@ -245,7 +253,11 @@ export class AndroidDevice extends SdkObject {
return result;
}
- async close() {
+ async close(progress: Progress) {
+ await progress.race(this._close());
+ }
+
+ private async _close() {
if (this._isClosed)
return;
this._isClosed = true;
@@ -276,7 +288,7 @@ export class AndroidDevice extends SdkObject {
await progress.race(this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`));
return browserContext;
} catch (error) {
- await browserContext.close({ reason: 'Failed to launch' }).catch(() => {});
+ await browserContext.close(progress, { reason: 'Failed to launch' }).catch(() => {});
throw error;
}
}
diff --git a/packages/playwright-core/src/server/bidi/bidiBrowser.ts b/packages/playwright-core/src/server/bidi/bidiBrowser.ts
index 58773ea625..f93e5750ca 100644
--- a/packages/playwright-core/src/server/bidi/bidiBrowser.ts
+++ b/packages/playwright-core/src/server/bidi/bidiBrowser.ts
@@ -507,11 +507,10 @@ export class BidiBrowserContext extends BrowserContext {
override async clearCache(): Promise<void> {
}
- async doClose(reason: string | undefined) {
+ async doClose(reason: string | undefined): Promise<void | 'close-browser'> {
if (!this._browserContextId) {
// Closing persistent context should close the browser.
- await this._browser.close({ reason });
- return;
+ return 'close-browser';
}
await this._browser._browserSession.send('browser.removeUserContext', {
userContext: this._browserContextId
diff --git a/packages/playwright-core/src/server/bidi/bidiPage.ts b/packages/playwright-core/src/server/bidi/bidiPage.ts
index 868c64fff6..67e3e3b4b2 100644
--- a/packages/playwright-core/src/server/bidi/bidiPage.ts
+++ b/packages/playwright-core/src/server/bidi/bidiPage.ts
@@ -26,6 +26,7 @@ import { RawKeyboardImpl, RawMouseImpl, RawTouchscreenImpl } from './bidiInput';
import { BidiNetworkManager } from './bidiNetworkManager';
import { BidiPDF } from './bidiPdf';
import * as bidi from './third_party/bidiProtocol';
+import { nullProgress } from '../progress';
import * as network from '../network';
import type { RegisteredListener } from '../utils/eventsHelper';
@@ -532,8 +533,8 @@ export class BidiPage implements PageDelegate {
private async _framePosition(frame: frames.Frame): Promise<types.Point | null> {
if (frame === this._page.mainFrame())
return { x: 0, y: 0 };
- const element = await frame.frameElement();
- const box = await element.boundingBox();
+ const element = await frame.frameElement(nullProgress);
+ const box = await element.boundingBox(nullProgress);
if (!box)
return null;
const style = await element.evaluateInUtility(([injected, iframe]) => injected.describeIFrameStyle(iframe as Element), {}).catch(e => 'error:notconnected' as const);
@@ -598,7 +599,7 @@ export class BidiPage implements PageDelegate {
return quads as types.Quad[];
}
- async setInputFilePaths(handle: dom.ElementHandle<HTMLInputElement>, paths: string[]): Promise<void> {
+ async setInputFilePaths(progress: Progress, handle: dom.ElementHandle<HTMLInputElement>, paths: string[]): Promise<void> {
const fromContext = toBidiExecutionContext(handle._context);
await this._session.send('input.setFiles', {
context: this._session.sessionId,
diff --git a/packages/playwright-core/src/server/browser.ts b/packages/playwright-core/src/server/browser.ts
index 5b0a7bccfa..5ce1d28f78 100644
--- a/packages/playwright-core/src/server/browser.ts
+++ b/packages/playwright-core/src/server/browser.ts
@@ -26,6 +26,7 @@ import { PlaywrightWebSocketServer } from '../remote/playwrightWebSocketServer';
import { BrowserInfo, serverRegistry } from '../serverRegistry';
import { makeSocketPath } from './utils/fileUtils';
import { createGuid } from '../utils';
+import { nullProgress } from './progress';
import type * as types from './types';
import type { ProxySettings } from './types';
@@ -117,7 +118,7 @@ export abstract class Browser extends SdkObject {
this.emit(Browser.Events.Context, context);
return context;
} catch (error) {
- await context?.close({ reason: 'Failed to create context' }).catch(() => {});
+ await context?.close(progress, { reason: 'Failed to create context' }).catch(() => {});
await clientCertificatesProxy?.close().catch(() => {});
throw error;
}
@@ -127,7 +128,7 @@ export abstract class Browser extends SdkObject {
const hash = BrowserContext.reusableContextHash(params);
if (!this._contextForReuse || hash !== this._contextForReuse.hash || !this._contextForReuse.context.canResetForReuse()) {
if (this._contextForReuse)
- await this._contextForReuse.context.close({ reason: 'Context reused' });
+ await this._contextForReuse.context.close(progress, { reason: 'Context reused' });
this._contextForReuse = { context: await this.newContext(progress, params), hash };
return this._contextForReuse.context;
}
@@ -159,12 +160,12 @@ export abstract class Browser extends SdkObject {
this._downloads.delete(uuid);
}
- async startServer(title: string, options: channels.BrowserStartServerOptions): Promise<{ endpoint: string }> {
- return await this._server.start(title, options);
+ async startServer(progress: Progress, title: string, options: channels.BrowserStartServerOptions): Promise<{ endpoint: string }> {
+ return await progress.race(this._server.start(title, options));
}
- async stopServer() {
- await this._server.stop();
+ async stopServer(progress: Progress): Promise<void> {
+ await progress.race(this._server.stop());
}
protected didClose() {
@@ -172,12 +173,16 @@ export abstract class Browser extends SdkObject {
context.browserClosed();
if (this._defaultContext)
this._defaultContext.browserClosed();
- this.stopServer().catch(() => {});
+ this.stopServer(nullProgress).catch(() => {});
this.emit(Browser.Events.Disconnected);
this.instrumentation.onBrowserClose(this);
}
- async close(options: { reason?: string }) {
+ async close(progress: Progress, options: { reason?: string }) {
+ return await progress.race(this._close(options));
+ }
+
+ private async _close(options: { reason?: string }) {
if (!this._startedClosing) {
if (options.reason)
this._closeReason = options.reason;
@@ -188,7 +193,7 @@ export abstract class Browser extends SdkObject {
await new Promise(x => this.once(Browser.Events.Disconnected, x));
}
- async killForTests() {
+ async killForTests(progress: Progress) {
await this.options.browserProcess.kill();
}
}
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index 9233689fe9..7c7314e9f0 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -289,7 +289,7 @@ export abstract class BrowserContext<EM extends EventMap = EventMap> extends Sdk
protected abstract doUpdateDefaultViewport(): Promise<void>;
protected abstract doUpdateDefaultEmulatedMedia(): Promise<void>;
protected abstract doExposePlaywrightBinding(): Promise<void>;
- protected abstract doClose(reason: string | undefined): Promise<void>;
+ protected abstract doClose(reason: string | undefined): Promise<void | 'close-browser'>;
protected abstract onClosePersistent(): void;
async cookies(urls: string | string[] | undefined = []): Promise<channels.NetworkCookie[]> {
@@ -520,7 +520,7 @@ export abstract class BrowserContext<EM extends EventMap = EventMap> extends Sdk
this._customCloseHandler = handler;
}
- async close(options: { reason?: string }) {
+ async close(progress: Progress, options: { reason?: string }) {
if (this._closedStatus === 'open') {
if (options.reason)
this._closeReason = options.reason;
@@ -536,7 +536,9 @@ export abstract class BrowserContext<EM extends EventMap = EventMap> extends Sdk
await this._customCloseHandler();
} else {
// Close the context.
- await this.doClose(options.reason);
+ const disposition = await this.doClose(options.reason);
+ if (disposition === 'close-browser')
+ await this._browser.close(progress, { reason: options.reason });
}
// We delete downloads after context closure
@@ -616,7 +618,7 @@ export abstract class BrowserContext<EM extends EventMap = EventMap> extends Sdk
for (const origin of originsToSave) {
const frame = page.mainFrame();
await frame.gotoImpl(progress, origin, {});
- const storage: SerializedStorage = await progress.race(frame.evaluateExpression(collectScript, { world: 'utility' }));
+ const storage: SerializedStorage = await frame.evaluateExpression(progress, collectScript, { world: 'utility' });
if (storage.localStorage.length || storage.indexedDB?.length)
result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
}
@@ -665,7 +667,7 @@ export abstract class BrowserContext<EM extends EventMap = EventMap> extends Sdk
const script = new (module.exports.StorageScript())(${this._browser.options.name === 'firefox'});
return script.restore(${JSON.stringify(newOrigins.get(origin))});
})()`;
- await progress.race(frame.evaluateExpression(restoreScript, { world: 'utility' }));
+ await frame.evaluateExpression(progress, restoreScript, { world: 'utility' });
}
}
this._origins = new Set([...newOrigins.keys()]);
diff --git a/packages/playwright-core/src/server/chromium/crBrowser.ts b/packages/playwright-core/src/server/chromium/crBrowser.ts
index b7189d13d7..e3c7b5b2bd 100644
--- a/packages/playwright-core/src/server/chromium/crBrowser.ts
+++ b/packages/playwright-core/src/server/chromium/crBrowser.ts
@@ -546,7 +546,7 @@ export class CRBrowserContext extends BrowserContext<CREventsMap> {
await page.exposePlaywrightBinding();
}
- async doClose(reason: string | undefined) {
+ async doClose(reason: string | undefined): Promise<void | 'close-browser'> {
// Headful chrome cannot dispose browser context with opened 'beforeunload'
// dialogs, so we should close all that are currently opened.
// We also won't get new ones since `Target.disposeBrowserContext` does not trigger
@@ -555,8 +555,7 @@ export class CRBrowserContext extends BrowserContext<CREventsMap> {
if (!this._browserContextId) {
// Closing persistent context should close the browser.
- await this._browser.close({ reason });
- return;
+ return 'close-browser';
}
await this._browser._session.send('Target.disposeBrowserContext', { browserContextId: this._browserContextId });
diff --git a/packages/playwright-core/src/server/chromium/crPage.ts b/packages/playwright-core/src/server/chromium/crPage.ts
index 2891976e95..700fe894d8 100644
--- a/packages/playwright-core/src/server/chromium/crPage.ts
+++ b/packages/playwright-core/src/server/chromium/crPage.ts
@@ -36,6 +36,7 @@ import { platformToFontFamilies } from './defaultFontFamilies';
import { TargetClosedError } from '../errors';
import { isSessionClosedError } from '../protocolError';
import { startAutomaticVideoRecording } from '../videoRecorder';
+import { nullProgress } from '../progress';
import type { CRSession } from './crConnection';
import type { Protocol } from './protocol';
@@ -308,8 +309,8 @@ export class CRPage implements PageDelegate {
return this._sessionForHandle(handle)._getContentQuads(handle);
}
- async setInputFilePaths(handle: dom.ElementHandle<HTMLInputElement>, files: string[]): Promise<void> {
- const frame = await handle.ownerFrame();
+ async setInputFilePaths(progress: Progress, handle: dom.ElementHandle<HTMLInputElement>, files: string[]): Promise<void> {
+ const frame = await handle.ownerFrame(progress);
if (!frame)
throw new Error('Cannot set input files to detached input element');
const parentSession = this._sessionForFrame(frame);
@@ -1078,8 +1079,8 @@ class FrameSession {
return null;
if (frame === this._page.mainFrame())
return { x: 0, y: 0 };
- const element = await frame.frameElement();
- const box = await element.boundingBox();
+ const element = await frame.frameElement(nullProgress);
+ const box = await element.boundingBox(nullProgress);
return box;
}
diff --git a/packages/playwright-core/src/server/debugController.ts b/packages/playwright-core/src/server/debugController.ts
index ef4230c6e8..fcece35f9d 100644
--- a/packages/playwright-core/src/server/debugController.ts
+++ b/packages/playwright-core/src/server/debugController.ts
@@ -79,7 +79,7 @@ export class DebugController extends SdkObject {
}
async setRecorderMode(progress: Progress, params: { mode: Mode, testIdAttributeName?: string, generateAutoExpect?: boolean }) {
- await progress.race(this._closeBrowsersWithoutPages());
+ await this._closeBrowsersWithoutPages(progress);
this._generateAutoExpect = !!params.generateAutoExpect;
if (params.mode === 'none') {
@@ -165,14 +165,14 @@ export class DebugController extends SdkObject {
return nonNullRecorders;
}
- private async _closeBrowsersWithoutPages() {
+ private async _closeBrowsersWithoutPages(progress: Progress) {
for (const browser of this._playwright.allBrowsers()) {
for (const context of browser.contexts()) {
if (!context.pages().length)
- await context.close({ reason: 'Browser collected' });
+ await progress.race(context.close(progress, { reason: 'Browser collected' }));
}
if (!browser.contexts())
- await browser.close({ reason: 'Browser collected' });
+ await browser.close(progress, { reason: 'Browser collected' });
}
}
}
diff --git a/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts b/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts
index f956d39a0e..9dd3cef399 100644
--- a/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts
@@ -61,48 +61,48 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
}
async wait(params: channels.AndroidDeviceWaitParams, progress: Progress) {
- await progress.race(this._object.send('wait', params));
+ await this._object.send(progress, 'wait', params);
}
async fill(params: channels.AndroidDeviceFillParams, progress: Progress) {
- await progress.race(this._object.send('click', { selector: params.androidSelector }));
- await progress.race(this._object.send('fill', params));
+ await this._object.send(progress, 'click', { selector: params.androidSelector });
+ await this._object.send(progress, 'fill', params);
}
async tap(params: channels.AndroidDeviceTapParams, progress: Progress) {
- await progress.race(this._object.send('click', params));
+ await this._object.send(progress, 'click', params);
}
async drag(params: channels.AndroidDeviceDragParams, progress: Progress) {
- await progress.race(this._object.send('drag', params));
+ await this._object.send(progress, 'drag', params);
}
async fling(params: channels.AndroidDeviceFlingParams, progress: Progress) {
- await progress.race(this._object.send('fling', params));
+ await this._object.send(progress, 'fling', params);
}
async longTap(params: channels.AndroidDeviceLongTapParams, progress: Progress) {
- await progress.race(this._object.send('longClick', params));
+ await this._object.send(progress, 'longClick', params);
}
async pinchClose(params: channels.AndroidDevicePinchCloseParams, progress: Progress) {
- await progress.race(this._object.send('pinchClose', params));
+ await this._object.send(progress, 'pinchClose', params);
}
async pinchOpen(params: channels.AndroidDevicePinchOpenParams, progress: Progress) {
- await progress.race(this._object.send('pinchOpen', params));
+ await this._object.send(progress, 'pinchOpen', params);
}
async scroll(params: channels.AndroidDeviceScrollParams, progress: Progress) {
- await progress.race(this._object.send('scroll', params));
+ await this._object.send(progress, 'scroll', params);
}
async swipe(params: channels.AndroidDeviceSwipeParams, progress: Progress) {
- await progress.race(this._object.send('swipe', params));
+ await this._object.send(progress, 'swipe', params);
}
async info(params: channels.AndroidDeviceTapParams, progress: Progress): Promise<channels.AndroidDeviceInfoResult> {
- const info = await progress.race(this._object.send('info', params));
+ const info = await this._object.send(progress, 'info', params);
fixupAndroidElementInfo(info);
return { info };
}
@@ -116,33 +116,33 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
throw new Error('No mapping for ' + text[i] + ' found');
keyCodes.push(code);
}
- await progress.race(Promise.all(keyCodes.map(keyCode => this._object.send('inputPress', { keyCode }))));
+ await Promise.all(keyCodes.map(keyCode => this._object.send(progress, 'inputPress', { keyCode })));
}
async inputPress(params: channels.AndroidDeviceInputPressParams, progress: Progress) {
if (!keyMap.has(params.key))
throw new Error('Unknown key: ' + params.key);
- await progress.race(this._object.send('inputPress', { keyCode: keyMap.get(params.key) }));
+ await this._object.send(progress, 'inputPress', { keyCode: keyMap.get(params.key) });
}
async inputTap(params: channels.AndroidDeviceInputTapParams, progress: Progress) {
- await progress.race(this._object.send('inputClick', params));
+ await this._object.send(progress, 'inputClick', params);
}
async inputSwipe(params: channels.AndroidDeviceInputSwipeParams, progress: Progress) {
- await progress.race(this._object.send('inputSwipe', params));
+ await this._object.send(progress, 'inputSwipe', params);
}
async inputDrag(params: channels.AndroidDeviceInputDragParams, progress: Progress) {
- await progress.race(this._object.send('inputDrag', params));
+ await this._object.send(progress, 'inputDrag', params);
}
async screenshot(params: channels.AndroidDeviceScreenshotParams, progress: Progress): Promise<channels.AndroidDeviceScreenshotResult> {
- return { binary: await progress.race(this._object.screenshot()) };
+ return { binary: await this._object.screenshot(progress) };
}
async shell(params: channels.AndroidDeviceShellParams, progress: Progress): Promise<channels.AndroidDeviceShellResult> {
- return { result: await progress.race(this._object.shell(params.command)) };
+ return { result: await this._object.shell(progress, params.command) };
}
async open(params: channels.AndroidDeviceOpenParams, progress: Progress): Promise<channels.AndroidDeviceOpenResult> {
@@ -155,7 +155,7 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
}
async push(params: channels.AndroidDevicePushParams, progress: Progress) {
- await progress.race(this._object.push(progress, params.file, params.path, params.mode));
+ await this._object.push(progress, params.file, params.path, params.mode);
}
async launchBrowser(params: channels.AndroidDeviceLaunchBrowserParams, progress: Progress): Promise<channels.AndroidDeviceLaunchBrowserResult> {
@@ -164,7 +164,7 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
}
async close(params: channels.AndroidDeviceCloseParams, progress: Progress) {
- await this._object.close();
+ await this._object.close(progress);
}
async connectToWebView(params: channels.AndroidDeviceConnectToWebViewParams, progress: Progress): Promise<channels.AndroidDeviceConnectToWebViewResult> {
diff --git a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
index 27e87482f3..bc91f6da42 100644
--- a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
@@ -337,7 +337,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
async close(params: channels.BrowserContextCloseParams, progress: Progress): Promise<void> {
progress.metadata.potentiallyClosesScope = true;
- await this._context.close(params);
+ await this._context.close(progress, params);
}
async enableRecorder(params: channels.BrowserContextEnableRecorderParams, progress: Progress): Promise<void> {
diff --git a/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts
index d7b8e77d02..36ebb8ae3b 100644
--- a/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts
@@ -20,6 +20,7 @@ import { CDPSessionDispatcher } from './cdpSessionDispatcher';
import { Dispatcher } from './dispatcher';
import { BrowserContext } from '../browserContext';
import { ArtifactDispatcher } from './artifactDispatcher';
+import { nullProgress } from '../progress';
import type { BrowserTypeDispatcher } from './browserTypeDispatcher';
import type { PageDispatcher } from './pageDispatcher';
@@ -96,14 +97,14 @@ export class BrowserDispatcher extends Dispatcher<Browser, channels.BrowserChann
if (this._options.ignoreStopAndKill)
return;
progress.metadata.potentiallyClosesScope = true;
- await this._object.close(params);
+ await this._object.close(progress, params);
}
async killForTests(params: channels.BrowserKillForTestsParams, progress: Progress): Promise<void> {
if (this._options.ignoreStopAndKill)
return;
progress.metadata.potentiallyClosesScope = true;
- await this._object.killForTests();
+ await this._object.killForTests(progress);
}
async defaultUserAgentForTest(): Promise<channels.BrowserDefaultUserAgentForTestResult> {
@@ -135,14 +136,14 @@ export class BrowserDispatcher extends Dispatcher<Browser, channels.BrowserChann
}
async startServer(params: channels.BrowserStartServerParams, progress: Progress): Promise<channels.BrowserStartServerResult> {
- return await this._object.startServer(params.title, params);
+ return await this._object.startServer(progress, params.title, params);
}
async stopServer(params: channels.BrowserStopServerParams, progress: Progress): Promise<void> {
- await this._object.stopServer();
+ await this._object.stopServer(progress);
}
async cleanupContexts() {
- await Promise.all(Array.from(this._isolatedContexts).map(context => context.close({ reason: 'Global context cleanup (connection terminated)' })));
+ await Promise.all(Array.from(this._isolatedContexts).map(context => context.close(nullProgress, { reason: 'Global context cleanup (connection terminated)' })));
}
}
diff --git a/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts b/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts
index 215aa288f6..899c71a0db 100644
--- a/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts
@@ -56,12 +56,12 @@ export class ElementHandleDispatcher extends JSHandleDispatcher<FrameDispatcher>
}
async ownerFrame(params: channels.ElementHandleOwnerFrameParams, progress: Progress): Promise<channels.ElementHandleOwnerFrameResult> {
- const frame = await this._elementHandle.ownerFrame();
+ const frame = await this._elementHandle.ownerFrame(progress);
return { frame: frame ? FrameDispatcher.from(this._browserContextDispatcher(), frame) : undefined };
}
async contentFrame(params: channels.ElementHandleContentFrameParams, progress: Progress): Promise<channels.ElementHandleContentFrameResult> {
- const frame = await progress.race(this._elementHandle.contentFrame());
+ const frame = await this._elementHandle.contentFrame(progress);
return { frame: frame ? FrameDispatcher.from(this._browserContextDispatcher(), frame) : undefined };
}
@@ -174,7 +174,7 @@ export class ElementHandleDispatcher extends JSHandleDispatcher<FrameDispatcher>
}
async boundingBox(params: channels.ElementHandleBoundingBoxParams, progress: Progress): Promise<channels.ElementHandleBoundingBoxResult> {
- const value = await progress.race(this._elementHandle.boundingBox());
+ const value = await this._elementHandle.boundingBox(progress);
return { value: value || undefined };
}
@@ -187,21 +187,21 @@ export class ElementHandleDispatcher extends JSHandleDispatcher<FrameDispatcher>
}
async querySelector(params: channels.ElementHandleQuerySelectorParams, progress: Progress): Promise<channels.ElementHandleQuerySelectorResult> {
- const handle = await progress.race(this._elementHandle.querySelector(params.selector, params));
+ const handle = await this._elementHandle.querySelector(progress, params.selector, params);
return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), handle) };
}
async querySelectorAll(params: channels.ElementHandleQuerySelectorAllParams, progress: Progress): Promise<channels.ElementHandleQuerySelectorAllResult> {
- const elements = await progress.race(this._elementHandle.querySelectorAll(params.selector));
+ const elements = await this._elementHandle.querySelectorAll(progress, params.selector);
return { elements: elements.map(e => ElementHandleDispatcher.from(this.parentScope(), e)) };
}
async evalOnSelector(params: channels.ElementHandleEvalOnSelectorParams, progress: Progress): Promise<channels.ElementHandleEvalOnSelectorResult> {
- return { value: serializeResult(await progress.race(this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, parseArgument(params.arg)))) };
+ return { value: serializeResult(await this._elementHandle.evalOnSelector(progress, params.selector, !!params.strict, params.expression, params.isFunction, parseArgument(params.arg))) };
}
async evalOnSelectorAll(params: channels.ElementHandleEvalOnSelectorAllParams, progress: Progress): Promise<channels.ElementHandleEvalOnSelectorAllResult> {
- return { value: serializeResult(await progress.race(this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, parseArgument(params.arg)))) };
+ return { value: serializeResult(await this._elementHandle.evalOnSelectorAll(progress, params.selector, params.expression, params.isFunction, parseArgument(params.arg))) };
}
async waitForElementState(params: channels.ElementHandleWaitForElementStateParams, progress: Progress): Promise<void> {
diff --git a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts b/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
index 2e6a1d77f3..e90a0a814b 100644
--- a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
@@ -80,15 +80,15 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br
}
async frameElement(params: channels.FrameFrameElementParams, progress: Progress): Promise<channels.FrameFrameElementResult> {
- return { element: ElementHandleDispatcher.from(this, await progress.race(this._frame.frameElement())) };
+ return { element: ElementHandleDispatcher.from(this, await this._frame.frameElement(progress)) };
}
async evaluateExpression(params: channels.FrameEvaluateExpressionParams, progress: Progress): Promise<channels.FrameEvaluateExpressionResult> {
- return { value: serializeResult(await progress.race(this._frame.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)))) };
+ return { value: serializeResult(await this._frame.evaluateExpression(progress, params.expression, { isFunction: params.isFunction }, parseArgument(params.arg))) };
}
async evaluateExpressionHandle(params: channels.FrameEvaluateExpressionHandleParams, progress: Progress): Promise<channels.FrameEvaluateExpressionHandleResult> {
- return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await progress.race(this._frame.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)))) };
+ return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction }, parseArgument(params.arg))) };
}
async waitForSelector(params: channels.FrameWaitForSelectorParams, progress: Progress): Promise<channels.FrameWaitForSelectorResult> {
@@ -100,28 +100,28 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br
}
async evalOnSelector(params: channels.FrameEvalOnSelectorParams, progress: Progress): Promise<channels.FrameEvalOnSelectorResult> {
- return { value: serializeResult(await progress.race(this._frame.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, parseArgument(params.arg)))) };
+ return { value: serializeResult(await this._frame.evalOnSelector(progress, params.selector, !!params.strict, params.expression, params.isFunction, parseArgument(params.arg))) };
}
async evalOnSelectorAll(params: channels.FrameEvalOnSelectorAllParams, progress: Progress): Promise<channels.FrameEvalOnSelectorAllResult> {
- return { value: serializeResult(await progress.race(this._frame.evalOnSelectorAll(params.selector, params.expression, params.isFunction, parseArgument(params.arg)))) };
+ return { value: serializeResult(await this._frame.evalOnSelectorAll(progress, params.selector, params.expression, params.isFunction, parseArgument(params.arg))) };
}
async querySelector(params: channels.FrameQuerySelectorParams, progress: Progress): Promise<channels.FrameQuerySelectorResult> {
- return { element: ElementHandleDispatcher.fromNullable(this, await progress.race(this._frame.querySelector(params.selector, params))) };
+ return { element: ElementHandleDispatcher.fromNullable(this, await this._frame.querySelector(progress, params.selector, params)) };
}
async querySelectorAll(params: channels.FrameQuerySelectorAllParams, progress: Progress): Promise<channels.FrameQuerySelectorAllResult> {
- const elements = await progress.race(this._frame.querySelectorAll(params.selector));
+ const elements = await this._frame.querySelectorAll(progress, params.selector);
return { elements: elements.map(e => ElementHandleDispatcher.from(this, e)) };
}
async queryCount(params: channels.FrameQueryCountParams, progress: Progress): Promise<channels.FrameQueryCountResult> {
- return { value: await progress.race(this._frame.queryCount(params.selector, params)) };
+ return { value: await this._frame.queryCount(progress, params.selector, params) };
}
async content(params: channels.FrameContentParams, progress: Progress): Promise<channels.FrameContentResult> {
- return { value: await progress.race(this._frame.content()) };
+ return { value: await this._frame.content(progress) };
}
async setContent(params: channels.FrameSetContentParams, progress: Progress): Promise<void> {
@@ -129,11 +129,11 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br
}
async addScriptTag(params: channels.FrameAddScriptTagParams, progress: Progress): Promise<channels.FrameAddScriptTagResult> {
- return { element: ElementHandleDispatcher.from(this, await progress.race(this._frame.addScriptTag(params))) };
+ return { element: ElementHandleDispatcher.from(this, await this._frame.addScriptTag(progress, params)) };
}
async addStyleTag(params: channels.FrameAddStyleTagParams, progress: Progress): Promise<channels.FrameAddStyleTagResult> {
- return { element: ElementHandleDispatcher.from(this, await progress.race(this._frame.addStyleTag(params))) };
+ return { element: ElementHandleDispatcher.from(this, await this._frame.addStyleTag(progress, params)) };
}
async ariaSnapshot(params: channels.FrameAriaSnapshotParams, progress: Progress): Promise<channels.FrameAriaSnapshotResult> {
@@ -258,7 +258,7 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br
}
async title(params: channels.FrameTitleParams, progress: Progress): Promise<channels.FrameTitleResult> {
- return { value: await progress.race(this._frame.title()) };
+ return { value: await this._frame.title(progress) };
}
async highlight(params: channels.FrameHighlightParams, progress: Progress): Promise<void> {
diff --git a/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts b/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
index 9015f004ad..1abf02c57c 100644
--- a/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
@@ -79,7 +79,7 @@ export class WebSocketRouteDispatcher extends Dispatcher<SdkObject, channels.Web
new WebSocketRouteDispatcher(scope, payload.id, payload.url, source.frame);
} else {
const request: ws.PassthroughRequest = { id: payload.id, type: 'passthrough' };
- source.frame.evaluateExpression(`globalThis.__pwWebSocketDispatch(${JSON.stringify(request)})`).catch(() => {});
+ source.frame.evaluateExpression(progress, `globalThis.__pwWebSocketDispatch(${JSON.stringify(request)})`).catch(() => {});
}
return;
}
@@ -141,7 +141,7 @@ export class WebSocketRouteDispatcher extends Dispatcher<SdkObject, channels.Web
}
private async _evaluateAPIRequest(progress: Progress, request: ws.APIRequest) {
- await progress.race(this._frame.evaluateExpression(`globalThis.__pwWebSocketDispatch(${JSON.stringify(request)})`).catch(() => {}));
+ await this._frame.evaluateExpression(progress, `globalThis.__pwWebSocketDispatch(${JSON.stringify(request)})`).catch(() => {});
}
override _onDispose() {
diff --git a/packages/playwright-core/src/server/dom.ts b/packages/playwright-core/src/server/dom.ts
index a06a979735..6c16bb724e 100644
--- a/packages/playwright-core/src/server/dom.ts
+++ b/packages/playwright-core/src/server/dom.ts
@@ -156,7 +156,11 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}
}
- async ownerFrame(): Promise<frames.Frame | null> {
+ async ownerFrame(progress: Progress): Promise<frames.Frame | null> {
+ return await progress.race(this._ownerFrame());
+ }
+
+ private async _ownerFrame(): Promise<frames.Frame | null> {
const frameId = await this._page.delegate.getOwnerFrame(this);
if (!frameId)
return null;
@@ -175,7 +179,11 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return this.evaluateInUtility(([injected, node]) => node && (node.nodeName === 'IFRAME' || node.nodeName === 'FRAME'), {});
}
- async contentFrame(): Promise<frames.Frame | null> {
+ async contentFrame(progress: Progress): Promise<frames.Frame | null> {
+ return progress.race(this._contentFrame());
+ }
+
+ private async _contentFrame(): Promise<frames.Frame | null> {
const isFrameElement = throwRetargetableDOMError(await this._isIframeElement());
if (!isFrameElement)
return null;
@@ -227,7 +235,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
await this._waitAndScrollIntoViewIfNeeded(progress, false /* waitForVisible */);
}
- private async _clickablePoint(): Promise<{ point: types.Point, box: types.Rect } | 'error:notvisible' | 'error:notinviewport' | 'error:notconnected'> {
+ private async _clickablePoint(progress: Progress): Promise<{ point: types.Point, box: types.Rect } | 'error:notvisible' | 'error:notinviewport' | 'error:notconnected'> {
const intersectQuadWithViewport = (quad: types.Quad): types.Quad => {
return quad.map(point => ({
x: Math.min(Math.max(point.x, 0), metrics.width),
@@ -280,9 +288,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return { point: quadMiddlePoint(quad), box };
}
- private async _offsetPoint(offset: types.Point): Promise<{ point: types.Point, box: types.Rect } | 'error:notvisible' | 'error:notconnected'> {
+ private async _offsetPoint(progress: Progress, offset: types.Point): Promise<{ point: types.Point, box: types.Rect } | 'error:notvisible' | 'error:notconnected'> {
const [box, border] = await Promise.all([
- this.boundingBox(),
+ this.boundingBox(progress),
this.evaluateInUtility(([injected, node]) => injected.getElementBorderWidth(node), {}).catch(e => {}),
]);
if (!box || !border)
@@ -433,7 +441,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return scrolled;
progress.log(' done scrolling');
- const maybeResult = position ? await progress.race(this._offsetPoint(position)) : await progress.race(this._clickablePoint());
+ const maybeResult = position ? await this._offsetPoint(progress, position) : await this._clickablePoint(progress);
if (typeof maybeResult === 'string')
return maybeResult;
const point = roundPoint(maybeResult.point);
@@ -448,7 +456,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if ((options as any).__testHookBeforeHitTarget)
await progress.race((options as any).__testHookBeforeHitTarget());
- const frameCheckResult = await progress.race(this._checkFrameIsHitTarget(point));
+ const frameCheckResult = await progress.race(this._checkFrameIsHitTarget(progress, point));
if (frameCheckResult === 'error:notconnected' || ('hitTargetDescription' in frameCheckResult))
return frameCheckResult;
const hitPoint = frameCheckResult.framePoint;
@@ -563,7 +571,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
private async _beforeNonPointerAction(progress: Progress) {
if (progress.metadata.annotate)
- progress.metadata.box = await this.boundingBox() || undefined;
+ progress.metadata.box = await this.boundingBox(progress) || undefined;
await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
}
@@ -680,7 +688,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
const waitForInputEvent = localDirectory ? this.evaluate(node => new Promise<any>(fulfill => {
node.addEventListener('input', fulfill, { once: true });
})).catch(() => {}) : Promise.resolve();
- await progress.race(this._page.delegate.setInputFilePaths(retargeted, localPathsOrDirectory));
+ await this._page.delegate.setInputFilePaths(progress, retargeted, localPathsOrDirectory);
await progress.race(waitForInputEvent);
} else {
await progress.race(retargeted.evaluateInUtility(([injected, node, files]) =>
@@ -771,28 +779,36 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return 'done';
}
- async boundingBox(): Promise<types.Rect | null> {
- return this._page.delegate.getBoundingBox(this);
+ async boundingBox(progress: Progress): Promise<types.Rect | null> {
+ return await progress.race(this._page.delegate.getBoundingBox(this));
}
async screenshot(progress: Progress, options: ScreenshotOptions): Promise<Buffer> {
return await this._page.screenshotter.screenshotElement(progress, this, options);
}
- async querySelector(selector: string, options: types.StrictOptions): Promise<ElementHandle | null> {
+ async querySelector(progress: Progress, selector: string, options: types.StrictOptions): Promise<ElementHandle | null> {
+ return progress.race(this._querySelector(selector, options));
+ }
+
+ private async _querySelector(selector: string, options: types.StrictOptions): Promise<ElementHandle | null> {
return this._frame.selectors.query(selector, options, this);
}
- async querySelectorAll(selector: string): Promise<ElementHandle<Element>[]> {
+ async querySelectorAll(progress: Progress, selector: string): Promise<ElementHandle<Element>[]> {
+ return progress.race(this._querySelectorAll(selector));
+ }
+
+ private async _querySelectorAll(selector: string): Promise<ElementHandle<Element>[]> {
return this._frame.selectors.queryAll(selector, this);
}
- async evalOnSelector(selector: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
- return this._frame.evalOnSelector(selector, strict, expression, isFunction, arg, this);
+ async evalOnSelector(progress: Progress, selector: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
+ return this._frame.evalOnSelector(progress, selector, strict, expression, isFunction, arg, this);
}
- async evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
- return this._frame.evalOnSelectorAll(selector, expression, isFunction, arg, this);
+ async evalOnSelectorAll(progress: Progress, selector: string, expression: string, isFunction: boolean | undefined, arg: any): Promise<any> {
+ return this._frame.evalOnSelectorAll(progress, selector, expression, isFunction, arg, this);
}
async isVisible(progress: Progress): Promise<boolean> {
@@ -842,12 +858,12 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return this;
}
- async _checkFrameIsHitTarget(point: types.Point): Promise<{ framePoint: types.Point | undefined } | 'error:notconnected' | { hitTargetDescription: string }> {
+ async _checkFrameIsHitTarget(progress: Progress, point: types.Point): Promise<{ framePoint: types.Point | undefined } | 'error:notconnected' | { hitTargetDescription: string }> {
let frame = this._frame;
const data: { frame: frames.Frame, frameElement: ElementHandle<Element> | null, pointInFrame: types.Point }[] = [];
while (frame.parentFrame()) {
- const frameElement = await frame.frameElement() as ElementHandle<Element>;
- const box = await frameElement.boundingBox();
+ const frameElement = await frame.frameElement(progress) as ElementHandle<Element>;
+ const box = await frameElement.boundingBox(progress);
const style = await frameElement.evaluateInUtility(([injected, iframe]) => injected.describeIFrameStyle(iframe), {}).catch(e => 'error:notconnected' as const);
if (!box || style === 'error:notconnected')
return 'error:notconnected';
diff --git a/packages/playwright-core/src/server/electron/electron.ts b/packages/playwright-core/src/server/electron/electron.ts
index e486366c62..6b73737923 100644
--- a/packages/playwright-core/src/server/electron/electron.ts
+++ b/packages/playwright-core/src/server/electron/electron.ts
@@ -34,6 +34,7 @@ import { SdkObject } from '../instrumentation';
import * as js from '../javascript';
import { envArrayToObject, launchProcess } from '../utils/processLauncher';
import { WebSocketTransport } from '../transport';
+import { nullProgress } from '../progress';
import type { BrowserOptions, BrowserProcess } from '../browser';
import type { BrowserContext } from '../browserContext';
@@ -131,9 +132,9 @@ export class ElectronApplication extends SdkObject {
return this._browserContext;
}
- async close() {
+ async close(progress: Progress) {
// This will call BrowserContext.setCustomCloseHandler.
- await this._browserContext.close({ reason: 'Application exited' });
+ await this._browserContext.close(progress, { reason: 'Application exited' });
}
async browserWindow(progress: Progress, page: Page): Promise<js.JSHandle<BrowserWindow>> {
@@ -223,7 +224,7 @@ export class Electron extends SdkObject {
stdio: 'pipe',
cwd: options.cwd,
tempDirectories,
- attemptToGracefullyClose: () => app!.close(),
+ attemptToGracefullyClose: () => app!.close(nullProgress),
handleSIGINT: true,
handleSIGTERM: true,
handleSIGHUP: true,
diff --git a/packages/playwright-core/src/server/firefox/ffBrowser.ts b/packages/playwright-core/src/server/firefox/ffBrowser.ts
index 4fa67cabc4..8280ac4d78 100644
--- a/packages/playwright-core/src/server/firefox/ffBrowser.ts
+++ b/packages/playwright-core/src/server/firefox/ffBrowser.ts
@@ -402,10 +402,10 @@ export class FFBrowserContext extends BrowserContext {
await this._browser.session.send('Browser.clearCache');
}
- async doClose(reason: string | undefined) {
+ async doClose(reason: string | undefined): Promise<void | 'close-browser'> {
if (!this._browserContextId) {
// Closing persistent context should close the browser.
- await this._browser.close({ reason });
+ return 'close-browser';
} else {
await this._browser.session.send('Browser.removeBrowserContext', { browserContextId: this._browserContextId });
this._browser._contexts.delete(this._browserContextId);
diff --git a/packages/playwright-core/src/server/firefox/ffInput.ts b/packages/playwright-core/src/server/firefox/ffInput.ts
index 92cd8f593a..43948fac72 100644
--- a/packages/playwright-core/src/server/firefox/ffInput.ts
+++ b/packages/playwright-core/src/server/firefox/ffInput.ts
@@ -162,7 +162,7 @@ export class RawMouseImpl implements input.RawMouse {
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._page!.mainFrame().evaluateExpression(progress, `new Promise(requestAnimationFrame)`, { world: 'utility' });
await progress.race(this._client.send('Page.dispatchWheelEvent', {
deltaX,
deltaY,
diff --git a/packages/playwright-core/src/server/firefox/ffPage.ts b/packages/playwright-core/src/server/firefox/ffPage.ts
index b956253531..4baab0b637 100644
--- a/packages/playwright-core/src/server/firefox/ffPage.ts
+++ b/packages/playwright-core/src/server/firefox/ffPage.ts
@@ -510,7 +510,7 @@ export class FFPage implements PageDelegate {
return result.quads.map(quad => [quad.p1, quad.p2, quad.p3, quad.p4]);
}
- async setInputFilePaths(handle: dom.ElementHandle<HTMLInputElement>, files: string[]): Promise<void> {
+ async setInputFilePaths(progress: Progress, handle: dom.ElementHandle<HTMLInputElement>, files: string[]): Promise<void> {
await this._session.send('Page.setFileInputFiles', {
frameId: handle._context.frame._id,
objectId: handle._objectId,
diff --git a/packages/playwright-core/src/server/frames.ts b/packages/playwright-core/src/server/frames.ts
index 33ea139ac1..67f100fc03 100644
--- a/packages/playwright-core/src/server/frames.ts
+++ b/packages/playwright-core/src/server/frames.ts
@@ -685,7 +685,7 @@ export class Frame extends SdkObject<FrameEventMap> {
await helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e: types.LifecycleEvent) => e === waitUntil).promise;
const request = event.newDocument ? event.newDocument.request : undefined;
- const response = request ? progress.race(request._finalRequest().internalResponse()) : null;
+ const response = request ? progress.race(request._finalRequest().response(progress)) : null;
return response;
}
@@ -709,7 +709,7 @@ export class Frame extends SdkObject<FrameEventMap> {
await helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e: types.LifecycleEvent) => e === waitUntil).promise;
const request = navigationEvent.newDocument ? navigationEvent.newDocument.request : undefined;
- return request ? progress.race(request._finalRequest().internalResponse()) : null;
+ return request ? progress.race(request._finalRequest().response(progress)) : null;
}
async waitForLoadState(progress: Progress, state: types.LifecycleEvent): Promise<void> {
@@ -718,8 +718,8 @@ export class Frame extends SdkObject<FrameEventMap> {
await helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, (e: types.LifecycleEvent) => e === waitUntil).promise;
}
- async frameElement(): Promise<dom.ElementHandle> {
- return this._page.delegate.getFrameElement(this);
+ async frameElement(progress: Progress): Promise<dom.ElementHandle> {
+ return await progress.race(this._page.delegate.getFrameElement(this));
}
context(world: types.World): Promise<dom.FrameExecutionContext> {
@@ -742,21 +742,29 @@ export class Frame extends SdkObject<FrameEventMap> {
return this.context('utility');
}
- async evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {
+ async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {
+ return await progress.race(this._evaluateExpression(expression, options, arg));
+ }
+
+ private async _evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {
const context = await this.context(options.world ?? 'main');
const value = await context.evaluateExpression(expression, options, arg);
return value;
}
- async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {
+ async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {
+ return await progress.race(this._evaluateExpressionHandle(expression, options, arg));
+ }
+
+ private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {
const context = await this.context(options.world ?? 'main');
const value = await context.evaluateExpressionHandle(expression, options, arg);
return value;
}
- async querySelector(selector: string, options: types.StrictOptions): Promise<dom.ElementHandle<Element> | null> {
+ async querySelector(progress: Progress, selector: string, options: types.StrictOptions): Promise<dom.ElementHandle<Element> | null> {
this.apiLog(` finding element using the selector "${selector}"`);
- return this.selectors.query(selector, options);
+ return progress.race(this.selectors.query(selector, options));
}
async waitForSelector(progress: Progress, selector: string, performActionPreChecksAndLog: boolean, options: types.WaitForElementOptions, scope?: dom.ElementHandle): Promise<dom.ElementHandle<Element> | null> {
@@ -830,7 +838,11 @@ export class Frame extends SdkObject<FrameEventMap> {
}, { type, eventInit }, { mainWorld: true, ...options }, scope);
}
- async evalOnSelector(selector: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
+ async evalOnSelector(progress: Progress, selector: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
+ return progress.race(this._evalOnSelector(selector, strict, expression, isFunction, arg, scope));
+ }
+
+ private async _evalOnSelector(selector: string, strict: boolean, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
const handle = await this.selectors.query(selector, { strict }, scope);
if (!handle)
throw new Error(`Failed to find element matching selector "${selector}"`);
@@ -839,7 +851,11 @@ export class Frame extends SdkObject<FrameEventMap> {
return result;
}
- async evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
+ async evalOnSelectorAll(progress: Progress, selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
+ return progress.race(this._evalOnSelectorAll(selector, expression, isFunction, arg, scope));
+ }
+
+ private async _evalOnSelectorAll(selector: string, expression: string, isFunction: boolean | undefined, arg: any, scope?: dom.ElementHandle): Promise<any> {
const arrayHandle = await this.selectors.queryArrayInMainWorld(selector, scope);
const result = await arrayHandle.internalEvaluateExpression(expression, { isFunction }, arg);
arrayHandle.dispose();
@@ -854,13 +870,13 @@ export class Frame extends SdkObject<FrameEventMap> {
}, { parsed: selectors, color: color });
}
- async querySelectorAll(selector: string): Promise<dom.ElementHandle<Element>[]> {
- return this.selectors.queryAll(selector);
+ async querySelectorAll(progress: Progress, selector: string): Promise<dom.ElementHandle<Element>[]> {
+ return progress.race(this.selectors.queryAll(selector));
}
- async queryCount(selector: string, options: any): Promise<number> {
+ async queryCount(progress: Progress, selector: string, options: any): Promise<number> {
try {
- return await this.selectors.queryCount(selector, options);
+ return await progress.race(this.selectors.queryCount(selector, options));
} catch (e) {
if (this.isNonRetriableError(e))
throw e;
@@ -868,7 +884,11 @@ export class Frame extends SdkObject<FrameEventMap> {
}
}
- async content(): Promise<string> {
+ async content(progress: Progress): Promise<string> {
+ return progress.race(this._content());
+ }
+
+ private async _content(): Promise<string> {
try {
const context = await this.utilityContext();
return await context.evaluate(() => {
@@ -934,7 +954,15 @@ export class Frame extends SdkObject<FrameEventMap> {
return Array.from(this._childFrames);
}
- async addScriptTag(params: {
+ async addScriptTag(progress: Progress, params: {
+ url?: string,
+ content?: string,
+ type?: string,
+ }): Promise<dom.ElementHandle> {
+ return await progress.race(this._addScriptTag(params));
+ }
+
+ private async _addScriptTag(params: {
url?: string,
content?: string,
type?: string,
@@ -986,7 +1014,11 @@ export class Frame extends SdkObject<FrameEventMap> {
}
}
- async addStyleTag(params: { url?: string, content?: string }): Promise<dom.ElementHandle> {
+ async addStyleTag(progress: Progress, params: { url?: string, content?: string }): Promise<dom.ElementHandle> {
+ return await progress.race(this._addStyleTag(params));
+ }
+
+ private async _addStyleTag(params: { url?: string, content?: string }): Promise<dom.ElementHandle> {
const {
url = null,
content = null
@@ -1228,7 +1260,7 @@ export class Frame extends SdkObject<FrameEventMap> {
let frame: Frame | null = element._frame;
const result = [generated];
while (frame?.parentFrame()) {
- const frameElement = await progress.race(frame.frameElement());
+ const frameElement = await progress.race(frame.frameElement(progress));
if (frameElement) {
const generated = await progress.race(frameElement.evaluateInUtility(async ([injected, node]) => {
return injected.generateSelectorSimple(node as unknown as Element);
@@ -1561,7 +1593,11 @@ export class Frame extends SdkObject<FrameEventMap> {
return JSON.parse(handle.rawValue()) as R;
}
- async title(): Promise<string> {
+ async title(progress: Progress): Promise<string> {
+ return progress.race(this._title());
+ }
+
+ private async _title(): Promise<string> {
try {
return await this.raceAgainstEvaluationStallingEvents(async () => {
const context = await this.utilityContext();
diff --git a/packages/playwright-core/src/server/har/harTracer.ts b/packages/playwright-core/src/server/har/harTracer.ts
index 9d4ad5fa53..6783290682 100644
--- a/packages/playwright-core/src/server/har/harTracer.ts
+++ b/packages/playwright-core/src/server/har/harTracer.ts
@@ -24,6 +24,7 @@ import { APIRequestContext } from '../fetch';
import { Frame } from '../frames';
import { helper } from '../helper';
import * as network from '../network';
+import { nullProgress } from '../progress';
import type { RegisteredListener } from '../utils/eventsHelper';
import type { APIRequestEvent, APIRequestFinishedEvent } from '../fetch';
@@ -153,7 +154,7 @@ export class HarTracer {
}
private _onDOMContentLoaded(page: Page, pageEntry: har.Page) {
- const promise = page.mainFrame().evaluateExpression(String(() => {
+ const promise = page.mainFrame().evaluateExpression(nullProgress, String(() => {
return {
title: document.title,
domContentLoaded: performance.timing.domContentLoadedEventStart,
@@ -167,7 +168,7 @@ export class HarTracer {
}
private _onLoad(page: Page, pageEntry: har.Page) {
- const promise = page.mainFrame().evaluateExpression(String(() => {
+ const promise = page.mainFrame().evaluateExpression(nullProgress, String(() => {
return {
title: document.title,
loaded: performance.timing.loadEventStart,
@@ -309,7 +310,7 @@ export class HarTracer {
// In WebKit security details and server ip are reported in Network.loadingFinished, so we populate
// it here to not hang in case of long chunked responses, see https://github.com/microsoft/playwright/issues/21182.
if (!this._options.omitServerIP) {
- this._addBarrier(page || request.serviceWorker(), response.internalServerAddr().then(server => {
+ this._addBarrier(page || request.serviceWorker(), response.serverAddr(nullProgress).then(server => {
if (server?.ipAddress)
harEntry.serverIPAddress = server.ipAddress;
if (server?.port)
@@ -317,7 +318,7 @@ export class HarTracer {
}));
}
if (!this._options.omitSecurityDetails) {
- this._addBarrier(page || request.serviceWorker(), response.internalSecurityDetails().then(details => {
+ this._addBarrier(page || request.serviceWorker(), response.securityDetails(nullProgress).then(details => {
if (details)
harEntry._securityDetails = details;
}));
@@ -362,7 +363,7 @@ export class HarTracer {
});
this._addBarrier(page || request.serviceWorker(), promise);
- this._addBarrier(page || request.serviceWorker(), response.internalHttpVersion().then(httpVersion => {
+ this._addBarrier(page || request.serviceWorker(), response.httpVersion(nullProgress).then(httpVersion => {
harEntry.request.httpVersion = httpVersion;
harEntry.response.httpVersion = httpVersion;
}));
@@ -373,7 +374,7 @@ export class HarTracer {
this._computeHarEntryTotalTime(harEntry);
if (!this._options.omitSizes) {
- this._addBarrier(page || request.serviceWorker(), response.internalSizes().then(sizes => {
+ this._addBarrier(page || request.serviceWorker(), response.sizes(nullProgress).then(sizes => {
harEntry.response.bodySize = sizes.responseBodySize;
harEntry.response.headersSize = sizes.responseHeadersSize;
harEntry.response._transferSize = sizes.transferSize;
@@ -490,13 +491,13 @@ export class HarTracer {
}
this._recordRequestOverrides(harEntry, request);
- this._addBarrier(page || request.serviceWorker(), request.internalRawRequestHeaders().then(headers => {
+ this._addBarrier(page || request.serviceWorker(), request.rawRequestHeaders(nullProgress).then(headers => {
this._recordRequestHeadersAndCookies(harEntry, headers);
}));
// Record available headers including redirect location in case the tracing is stopped before
// response extra info is received (in Chromium).
this._recordResponseHeaders(harEntry, response.headers());
- this._addBarrier(page || request.serviceWorker(), response.internalRawResponseHeaders().then(headers => {
+ this._addBarrier(page || request.serviceWorker(), response.rawResponseHeaders(nullProgress).then(headers => {
this._recordResponseHeaders(harEntry, headers);
}));
}
diff --git a/packages/playwright-core/src/server/network.ts b/packages/playwright-core/src/server/network.ts
index 62656ba144..574fc63d8a 100644
--- a/packages/playwright-core/src/server/network.ts
+++ b/packages/playwright-core/src/server/network.ts
@@ -215,11 +215,11 @@ export class Request extends SdkObject {
}
async rawRequestHeaders(progress: Progress): Promise<HeadersArray> {
- return await progress.race(this.internalRawRequestHeaders());
+ return await progress.race(this._rawRequestHeaders());
}
async response(progress: Progress): Promise<Response | null> {
- return await progress.race(this.internalResponse());
+ return await progress.race(this._waitForResponse());
}
_setFailureText(failureText: string) {
@@ -267,11 +267,11 @@ export class Request extends SdkObject {
this._rawRequestHeadersPromise.resolve(headers || this._headers);
}
- async internalRawRequestHeaders(): Promise<HeadersArray> {
+ private async _rawRequestHeaders(): Promise<HeadersArray> {
return this._overrides?.headers || this._rawRequestHeadersPromise;
}
- internalResponse(): Promise<Response | null> {
+ private _waitForResponse(): Promise<Response | null> {
return this._waitForResponsePromise;
}
@@ -327,7 +327,7 @@ export class Request extends SdkObject {
headersSize += this.method().length;
headersSize += (new URL(this.url())).pathname.length;
headersSize += 8; // httpVersion
- const headers = await this.internalRawRequestHeaders();
+ const headers = await this._rawRequestHeaders();
for (const header of headers)
headersSize += header.name.length + header.value.length + 4; // 4 = ': ' + '\r\n'
return headersSize;
@@ -547,19 +547,19 @@ export class Response extends SdkObject {
}
async serverAddr(progress: Progress): Promise<RemoteAddr | null> {
- return await progress.race(this.internalServerAddr());
+ return (await progress.race(this._serverAddrPromise)) || null;
}
async rawResponseHeaders(progress: Progress): Promise<NameValue[]> {
- return await progress.race(this.internalRawResponseHeaders());
+ return await progress.race(this._rawResponseHeadersPromise);
}
async httpVersion(progress: Progress): Promise<string> {
- return await progress.race(this.internalHttpVersion());
+ return await progress.race(this._httpVersion());
}
async sizes(progress: Progress): Promise<ResourceSizes> {
- return await progress.race(this.internalSizes());
+ return await progress.race(this._sizes());
}
_serverAddrFinished(addr?: RemoteAddr) {
@@ -602,10 +602,6 @@ export class Response extends SdkObject {
return this._headersMap.get(name);
}
- async internalRawResponseHeaders(): Promise<NameValue[]> {
- return this._rawResponseHeadersPromise;
- }
-
// "null" means no raw headers available - we'll use provisional headers as raw headers.
setRawResponseHeaders(headers: HeadersArray | null) {
if (!this._rawResponseHeadersPromise.isDone())
@@ -628,10 +624,6 @@ export class Response extends SdkObject {
return this._timing;
}
- async internalServerAddr(): Promise<RemoteAddr|null> {
- return await this._serverAddrPromise || null;
- }
-
async internalSecurityDetails(): Promise<SecurityDetails|null> {
return await this._securityDetailsPromise || null;
}
@@ -663,7 +655,7 @@ export class Response extends SdkObject {
return this._request.frame();
}
- async internalHttpVersion(): Promise<string> {
+ private async _httpVersion(): Promise<string> {
const httpVersion = await this._httpVersionPromise || null;
if (!httpVersion)
return 'HTTP/1.1';
@@ -695,7 +687,7 @@ export class Response extends SdkObject {
return headersSize;
}
- async internalSizes(): Promise<ResourceSizes> {
+ private async _sizes(): Promise<ResourceSizes> {
const requestHeadersSize = await this._request._requestHeadersSize();
const responseHeadersSize = await this.responseHeadersSize();
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index 8acecd9081..ba9fffb5ab 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -81,7 +81,7 @@ export interface PageDelegate {
getContentFrame(handle: dom.ElementHandle): Promise<frames.Frame | null>; // Only called for frame owner elements.
getOwnerFrame(handle: dom.ElementHandle): Promise<string | null>; // Returns frameId.
getContentQuads(handle: dom.ElementHandle): Promise<types.Quad[] | null | 'error:notconnected'>;
- setInputFilePaths(handle: dom.ElementHandle<HTMLInputElement>, files: string[]): Promise<void>;
+ setInputFilePaths(progress: Progress, handle: dom.ElementHandle<HTMLInputElement>, files: string[]): Promise<void>;
getBoundingBox(handle: dom.ElementHandle): Promise<types.Rect | null>;
getFrameElement(frame: frames.Frame): Promise<dom.ElementHandle>;
scrollRectIntoViewIfNeeded(handle: dom.ElementHandle, rect?: types.Rect): Promise<'error:notvisible' | 'error:notconnected' | 'done'>;
diff --git a/packages/playwright-core/src/server/recorder.ts b/packages/playwright-core/src/server/recorder.ts
index 1da4f6694e..54c6f42b6f 100644
--- a/packages/playwright-core/src/server/recorder.ts
+++ b/packages/playwright-core/src/server/recorder.ts
@@ -195,7 +195,7 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
});
await this._context.exposeBinding(progress, '__pw_recorderElementPicked', false, async ({ frame }, elementInfo: ElementInfo) => {
- const selectorChain = await generateFrameSelector(frame);
+ const selectorChain = await generateFrameSelector(progress, frame);
this.emit(RecorderEvent.ElementPicked, { selector: buildFullSelector(selectorChain, elementInfo.selector), ariaSnapshot: elementInfo.ariaSnapshot }, true);
});
@@ -227,11 +227,11 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
// Input actions that potentially lead to navigation are intercepted on the page and are
// performed by the Playwright.
await this._context.exposeBinding(progress, '__pw_recorderPerformAction', false,
- (source: BindingSource, action: actions.PerformOnRecordAction) => this._performAction(source.frame, action));
+ (source: BindingSource, action: actions.PerformOnRecordAction) => this._performAction(progress, source.frame, action));
// Other non-essential actions are simply being recorded.
await this._context.exposeBinding(progress, '__pw_recorderRecordAction', false,
- (source: BindingSource, action: actions.Action) => this._recordAction(source.frame, action));
+ (source: BindingSource, action: actions.Action) => this._recordAction(progress, source.frame, action));
await this._context.extendInjectedScript(rawRecorderSource.source, { recorderMode: this._recorderMode, hideToolbar: !!this._params.hideToolbar });
});
@@ -548,11 +548,11 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
};
}
- private async _describeFrame(frame: Frame): Promise<actions.FrameDescription> {
+ private async _describeFrame(progress: Progress, frame: Frame): Promise<actions.FrameDescription> {
return {
pageGuid: frame._page.guid,
pageAlias: this._pageAliases.get(frame._page)!,
- framePath: await generateFrameSelector(frame),
+ framePath: await generateFrameSelector(progress, frame),
};
}
@@ -560,8 +560,8 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
return this._params.testIdAttributeName || this._context.selectors().testIdAttributeName() || 'data-testid';
}
- private async _createActionInContext(frame: Frame, action: actions.Action): Promise<actions.ActionInContext> {
- const frameDescription = await this._describeFrame(frame);
+ private async _createActionInContext(progress: Progress, frame: Frame, action: actions.Action): Promise<actions.ActionInContext> {
+ const frameDescription = await this._describeFrame(progress, frame);
const actionInContext: actions.ActionInContext = {
frame: frameDescription,
action,
@@ -571,16 +571,16 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
return actionInContext;
}
- private async _performAction(frame: Frame, action: actions.PerformOnRecordAction) {
- const actionInContext = await this._createActionInContext(frame, action);
+ private async _performAction(progress: Progress, frame: Frame, action: actions.PerformOnRecordAction) {
+ const actionInContext = await this._createActionInContext(progress, frame, action);
this._signalProcessor.addAction(actionInContext);
if (actionInContext.action.name !== 'openPage' && actionInContext.action.name !== 'closePage')
- await performAction(this._pageAliases, actionInContext);
+ await performAction(progress, this._pageAliases, actionInContext);
actionInContext.endTime = monotonicTime();
}
- private async _recordAction(frame: Frame, action: actions.Action) {
- const actionInContext = await this._createActionInContext(frame, action);
+ private async _recordAction(progress: Progress, frame: Frame, action: actions.Action) {
+ const actionInContext = await this._createActionInContext(progress, frame, action);
this._signalProcessor.addAction(actionInContext);
}
diff --git a/packages/playwright-core/src/server/recorder/recorderApp.ts b/packages/playwright-core/src/server/recorder/recorderApp.ts
index 8feec0f125..5a05b59ccf 100644
--- a/packages/playwright-core/src/server/recorder/recorderApp.ts
+++ b/packages/playwright-core/src/server/recorder/recorderApp.ts
@@ -21,7 +21,7 @@ import { isUnderTest } from '../utils/debug';
import { mime } from '../../utilsBundle';
import { syncLocalStorageWithSettings } from '../launchApp';
import { launchApp } from '../launchApp';
-import { ProgressController } from '../progress';
+import { nullProgress, ProgressController } from '../progress';
import { ThrottledFile } from './throttledFile';
import { languageSet } from '../codegen/languages';
import { collapseActions, shouldMergeAction } from './recorderUtils';
@@ -111,7 +111,7 @@ export class RecorderApp {
this._page.once('close', () => {
this._recorder.close();
- this._page.browserContext.close({ reason: 'Recorder window closed' }).catch(() => {});
+ this._page.browserContext.close(nullProgress, { reason: 'Recorder window closed' }).catch(() => {});
delete (inspectedContext as any)[recorderAppSymbol];
});
@@ -254,7 +254,7 @@ export class RecorderApp {
recorder.on(RecorderEvent.ContextClosed, () => {
this._throttledOutputFile?.flush();
- this._page.browserContext.close({ reason: 'Recorder window closed' }).catch(() => {});
+ this._page.browserContext.close(nullProgress, { reason: 'Recorder window closed' }).catch(() => {});
});
recorder.on(RecorderEvent.ModeChanged, (mode: Mode) => {
@@ -397,7 +397,7 @@ function createRecorderFrontend(page: Page): RecorderFrontend {
if (typeof prop !== 'string')
return undefined;
return (params: any) => {
- page.mainFrame().evaluateExpression(((event: { method: string, params?: any }) => {
+ page.mainFrame().evaluateExpression(nullProgress, ((event: { method: string, params?: any }) => {
window.dispatch(event);
}).toString(), { isFunction: true }, { method: prop, params }).catch(() => {});
};
diff --git a/packages/playwright-core/src/server/recorder/recorderRunner.ts b/packages/playwright-core/src/server/recorder/recorderRunner.ts
index 38e75e00ac..1ebdf6d381 100644
--- a/packages/playwright-core/src/server/recorder/recorderRunner.ts
+++ b/packages/playwright-core/src/server/recorder/recorderRunner.ts
@@ -17,18 +17,16 @@
import { serializeExpectedTextValues } from '../../utils';
import { toKeyboardModifiers } from '../codegen/language';
import { buildFullSelector, mainFrameForAction } from './recorderUtils';
-import { Progress, ProgressController } from '../progress';
+import { Progress } from '../progress';
import type { Page } from '../page';
import type * as types from '../types';
import type * as actions from '@recorder/actions';
import type { Frame } from '../frames';
-export async function performAction(pageAliases: Map<Page, string>, actionInContext: actions.ActionInContext) {
+export async function performAction(progress: Progress, pageAliases: Map<Page, string>, actionInContext: actions.ActionInContext) {
const mainFrame = mainFrameForAction(pageAliases, actionInContext);
- const controller = new ProgressController();
- const kActionTimeout = 5000;
- return await controller.run(progress => performActionImpl(progress, mainFrame, actionInContext), kActionTimeout);
+ return await performActionImpl(progress, mainFrame, actionInContext);
}
async function performActionImpl(progress: Progress, mainFrame: Frame, actionInContext: actions.ActionInContext) {
diff --git a/packages/playwright-core/src/server/recorder/recorderSignalProcessor.ts b/packages/playwright-core/src/server/recorder/recorderSignalProcessor.ts
index a4d33fe40d..4e15d80e82 100644
--- a/packages/playwright-core/src/server/recorder/recorderSignalProcessor.ts
+++ b/packages/playwright-core/src/server/recorder/recorderSignalProcessor.ts
@@ -17,6 +17,7 @@
import { isUnderTest } from '../utils/debug';
import { monotonicTime } from '../../utils/isomorphic/time';
import { generateFrameSelector } from './recorderUtils';
+import { nullProgress } from '../progress';
import type { Signal } from '../../../../recorder/src/actions';
import type { Frame } from '../frames';
@@ -73,7 +74,7 @@ export class RecorderSignalProcessor {
return;
}
- generateFrameSelector(frame).then(framePath => {
+ generateFrameSelector(nullProgress, frame).then(framePath => {
const signalInContext: actions.SignalInContext = {
frame: {
pageGuid: frame._page.guid,
diff --git a/packages/playwright-core/src/server/recorder/recorderUtils.ts b/packages/playwright-core/src/server/recorder/recorderUtils.ts
index 4f43273db2..793124a968 100644
--- a/packages/playwright-core/src/server/recorder/recorderUtils.ts
+++ b/packages/playwright-core/src/server/recorder/recorderUtils.ts
@@ -23,6 +23,7 @@ import type { CallMetadata } from '../instrumentation';
import type { Page } from '../page';
import type * as actions from '@recorder/actions';
import type { CallLog, CallLogStatus } from '@recorder/recorderTypes';
+import type { Progress } from '@protocol/progress';
export function buildFullSelector(framePath: string[], selector: string) {
return [...framePath, selector].join(' >> internal:control=enter-frame >> ');
@@ -115,23 +116,23 @@ export function collapseActions(actions: actions.ActionInContext[]): actions.Act
return result;
}
-export async function generateFrameSelector(frame: Frame): Promise<string[]> {
+export async function generateFrameSelector(progress: Progress, frame: Frame): Promise<string[]> {
const selectorPromises: Promise<string>[] = [];
while (frame) {
const parent = frame.parentFrame();
if (!parent)
break;
- selectorPromises.push(generateFrameSelectorInParent(parent, frame));
+ selectorPromises.push(generateFrameSelectorInParent(progress, parent, frame));
frame = parent;
}
const result = await Promise.all(selectorPromises);
return result.reverse();
}
-async function generateFrameSelectorInParent(parent: Frame, frame: Frame): Promise<string> {
+async function generateFrameSelectorInParent(prgoress: Progress, parent: Frame, frame: Frame): Promise<string> {
const result = await raceAgainstDeadline(async () => {
try {
- const frameElement = await frame.frameElement();
+ const frameElement = await frame.frameElement(prgoress);
if (!frameElement || !parent)
return;
const utility = await parent.utilityContext();
diff --git a/packages/playwright-core/src/server/screenshotter.ts b/packages/playwright-core/src/server/screenshotter.ts
index 448d7f08c6..f2e0611398 100644
--- a/packages/playwright-core/src/server/screenshotter.ts
+++ b/packages/playwright-core/src/server/screenshotter.ts
@@ -233,7 +233,7 @@ export class Screenshotter {
try {
await handle._waitAndScrollIntoViewIfNeeded(progress, true /* waitForVisible */);
- const boundingBox = await progress.race(handle.boundingBox());
+ const boundingBox = await handle.boundingBox(progress);
assert(boundingBox, 'Node is either not visible or not an HTMLElement');
assert(boundingBox.width !== 0, 'Node has 0 width.');
assert(boundingBox.height !== 0, 'Node has 0 height.');
diff --git a/packages/playwright-core/src/server/trace/recorder/snapshotter.ts b/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
index 0c055f6b5e..1cf3505c72 100644
--- a/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
+++ b/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
@@ -22,6 +22,7 @@ import { eventsHelper } from '../../utils/eventsHelper';
import { mime } from '../../../utilsBundle';
import { BrowserContext } from '../../browserContext';
import { Page } from '../../page';
+import { nullProgress } from '../../progress';
import type { SnapshotData } from './snapshotterInjected';
import type { RegisteredListener } from '../../utils/eventsHelper';
@@ -161,9 +162,9 @@ export class Snapshotter {
this._eventListeners.push(eventsHelper.addEventListener(page, Page.Events.FrameAttached, frame => this._annotateFrameHierarchy(frame)));
}
- private async _annotateFrameHierarchy(frame: Frame) {
- try {
- const frameElement = await frame.frameElement();
+ private _annotateFrameHierarchy(frame: Frame) {
+ (async () => {
+ const frameElement = await frame.frameElement(nullProgress);
const parent = frame.parentFrame();
if (!parent)
return;
@@ -172,8 +173,7 @@ export class Snapshotter {
(window as any)[snapshotStreamer].markIframe(frameElement, frameId);
}, { snapshotStreamer: this._snapshotStreamer, frameElement, frameId: frame.guid });
frameElement.dispose();
- } catch (e) {
- }
+ })().catch(() => {});
}
}
diff --git a/packages/playwright-core/src/server/trace/viewer/traceViewer.ts b/packages/playwright-core/src/server/trace/viewer/traceViewer.ts
index 90d7f56668..212fac3bcf 100644
--- a/packages/playwright-core/src/server/trace/viewer/traceViewer.ts
+++ b/packages/playwright-core/src/server/trace/viewer/traceViewer.ts
@@ -25,6 +25,7 @@ import { syncLocalStorageWithSettings } from '../../launchApp';
import { launchApp } from '../../launchApp';
import { createPlaywright } from '../../playwright';
import { ProgressController } from '../../progress';
+import { nullProgress } from '../../progress';
import type { Transport } from '../../utils/httpServer';
import type { BrowserType } from '../../browserType';
@@ -195,7 +196,7 @@ export async function openTraceViewerApp(url: string, browserName: string, optio
await syncLocalStorageWithSettings(page, 'traceviewer');
if (isUnderTest())
- page.on('close', () => context.close({ reason: 'Trace viewer closed' }).catch(() => {}));
+ page.on('close', () => context.close(nullProgress, { reason: 'Trace viewer closed' }).catch(() => {}));
await page.mainFrame().goto(progress, url);
});
diff --git a/packages/playwright-core/src/server/webkit/wkBrowser.ts b/packages/playwright-core/src/server/webkit/wkBrowser.ts
index fc6e6005ff..1482a51356 100644
--- a/packages/playwright-core/src/server/webkit/wkBrowser.ts
+++ b/packages/playwright-core/src/server/webkit/wkBrowser.ts
@@ -363,10 +363,10 @@ export class WKBrowserContext extends BrowserContext {
});
}
- async doClose(reason: string | undefined) {
+ async doClose(reason: string | undefined): Promise<void | 'close-browser'> {
if (!this._browserContextId) {
// Closing persistent context should close the browser.
- await this._browser.close({ reason });
+ return 'close-browser';
} else {
await this._browser._browserSession.send('Playwright.deleteContext', { browserContextId: this._browserContextId });
this._browser._contexts.delete(this._browserContextId);
diff --git a/packages/playwright-core/src/server/webkit/wkInput.ts b/packages/playwright-core/src/server/webkit/wkInput.ts
index 3d1dffd196..d62b1f681d 100644
--- a/packages/playwright-core/src/server/webkit/wkInput.ts
+++ b/packages/playwright-core/src/server/webkit/wkInput.ts
@@ -157,7 +157,7 @@ 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 progress.race(this._page!.mainFrame().evaluateExpression(`new Promise(requestAnimationFrame)`, { world: 'utility' }));
+ await progress.race(this._page!.mainFrame().evaluateExpression(progress, `new Promise(requestAnimationFrame)`, { world: 'utility' }));
await progress.race(this._pageProxySession.send('Input.dispatchWheelEvent', {
x,
y,
diff --git a/packages/playwright-core/src/server/webkit/wkPage.ts b/packages/playwright-core/src/server/webkit/wkPage.ts
index 76ab0eddec..4455efcee4 100644
--- a/packages/playwright-core/src/server/webkit/wkPage.ts
+++ b/packages/playwright-core/src/server/webkit/wkPage.ts
@@ -36,6 +36,7 @@ import { WKWorkers } from './wkWorkers';
import { translatePathToWSL } from './webkit';
import { registry } from '../registry';
import { startAutomaticVideoRecording } from '../videoRecorder';
+import { nullProgress } from '../progress';
import type { Protocol } from './protocol';
import type { WKBrowserContext } from './wkBrowser';
@@ -195,7 +196,7 @@ export class WKPage implements PageDelegate {
const bootstrapScript = this._calculateBootstrapScript();
if (bootstrapScript.length)
promises.push(session.send('Page.setBootstrapScript', { source: bootstrapScript }));
- this._page.frames().map(frame => frame.evaluateExpression(bootstrapScript).catch(e => {}));
+ this._page.frames().map(frame => frame.evaluateExpression(nullProgress, bootstrapScript).catch(e => {}));
if (contextOptions.bypassCSP)
promises.push(session.send('Page.setBypassCSP', { enabled: true }));
const emulatedSize = this._page.emulatedSize();
@@ -971,7 +972,7 @@ export class WKPage implements PageDelegate {
]);
}
- async setInputFilePaths(handle: dom.ElementHandle<HTMLInputElement>, paths: string[]): Promise<void> {
+ async setInputFilePaths(progress: Progress, handle: dom.ElementHandle<HTMLInputElement>, paths: string[]): Promise<void> {
const pageProxyId = this._pageProxySession.sessionId;
const objectId = handle._objectId;
if (this._browserContext._browser?.options.channel === 'webkit-wsl')
diff --git a/tests/library/chromium/connect-over-cdp.spec.ts b/tests/library/chromium/connect-over-cdp.spec.ts
index cf8e27dda9..2e11f9e1ff 100644
--- a/tests/library/chromium/connect-over-cdp.spec.ts
+++ b/tests/library/chromium/connect-over-cdp.spec.ts
@@ -21,6 +21,7 @@ import fs from 'fs';
import { getUserAgent } from '../../../packages/playwright-core/lib/server/utils/userAgent';
import { WebSocketTransport } from '../../../packages/playwright-core/lib/server/transport';
import { suppressCertificateWarning } from '../../config/utils';
+import { nullProgress } from '../../../packages/playwright-core/lib/server/progress';
import type { Frame } from '../../../packages/playwright-core/lib/server/frames';
test.skip(({ mode }) => mode === 'service2');
@@ -591,13 +592,13 @@ test('should not reuse utility worlds between two clients', async ({ browserType
expect(context1.pages().length).toBe(0);
const page1 = await context1.newPage();
const frameImpl1 = toImpl(page1.mainFrame()) as Frame;
- await frameImpl1.evaluateExpression('window.foo = 42', { world: 'utility' });
+ await frameImpl1.evaluateExpression(nullProgress, 'window.foo = 42', { world: 'utility' });
const browser2 = await browserType.connectOverCDP(`http://127.0.0.1:${port}/`);
const context2 = browser2.contexts()[0];
const page2 = context2.pages()[0];
const frameImpl2 = toImpl(page2.mainFrame()) as Frame;
- const result = await frameImpl2.evaluateExpression('window.foo', { world: 'utility' });
+ const result = await frameImpl2.evaluateExpression(nullProgress, 'window.foo', { world: 'utility' });
await browser1.close();
await browser2.close();
diff --git a/tests/page/page-set-content.spec.ts b/tests/page/page-set-content.spec.ts
index 33e04c8604..41d38787c7 100644
--- a/tests/page/page-set-content.spec.ts
+++ b/tests/page/page-set-content.spec.ts
@@ -16,6 +16,7 @@
*/
import { test as it, expect } from './pageTest';
+import { nullProgress } from '../../packages/playwright-core/lib/server/progress';
const expectedOutput = '<html><head></head><body><div>hello</div></body></html>';
@@ -133,7 +134,7 @@ it('should return empty content there is no iframe src', async ({ page, browserN
it('should handle timeout properly', async ({ page, toImpl, browserName }) => {
it.skip(browserName === 'firefox', 'tampering with console.debug in utility world does not work');
- await toImpl(page).mainFrame().evaluateExpression(String(() => {
+ await toImpl(page).mainFrame().evaluateExpression(nullProgress, String(() => {
window['saved'] = console.debug.bind(console);
console.debug = () => {};
}), { isFunction: true, world: 'utility' });
@@ -141,7 +142,7 @@ it('should handle timeout properly', async ({ page, toImpl, browserName }) => {
expect(error.message).toContain('page.setContent: Timeout 1000ms exceeded');
// Should recover after timeout.
- await toImpl(page).mainFrame().evaluateExpression(String(() => {
+ await toImpl(page).mainFrame().evaluateExpression(nullProgress, String(() => {
console.debug = window['saved'];
}), { isFunction: true, world: 'utility' });
await page.setContent(`<div>world</div>`);
@@ -151,7 +152,7 @@ it('should handle timeout properly', async ({ page, toImpl, browserName }) => {
it('should handle timeout properly 2', async ({ page, toImpl, trace }) => {
it.skip(trace === 'on');
- await toImpl(page).mainFrame().evaluateExpression(String(() => {
+ await toImpl(page).mainFrame().evaluateExpression(nullProgress, String(() => {
document.close = () => {
while (true) {}
};