Skip to content

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

chore: migrate some dispatchers from CallMetadata to Progress (part 3) (#36439)

Dmitry Gozmane4355f722afd
diff --git a/packages/playwright-core/src/server/bidi/bidiBrowser.ts b/packages/playwright-core/src/server/bidi/bidiBrowser.ts
index 30c1cdb1c4..4c7a42fc8e 100644
--- a/packages/playwright-core/src/server/bidi/bidiBrowser.ts
+++ b/packages/playwright-core/src/server/bidi/bidiBrowser.ts
@@ -351,13 +351,13 @@ export class BidiBrowserContext extends BrowserContext {
});
}
- async setExtraHTTPHeaders(headers: types.HeadersArray): Promise<void> {
+ async doUpdateExtraHTTPHeaders(): Promise<void> {
}
async setUserAgent(userAgent: string | undefined): Promise<void> {
}
- async setOffline(offline: boolean): Promise<void> {
+ async doUpdateOffline(): Promise<void> {
}
async doSetHTTPCredentials(httpCredentials?: types.Credentials): Promise<void> {
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index 3615c3b1bd..abc26fb66c 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -144,7 +144,7 @@ export abstract class BrowserContext extends SdkObject {
if (debugMode() === 'console')
await this.extendInjectedScript('function Console(injectedScript) { injectedScript.consoleApi.install(); }');
if (this._options.serviceWorkers === 'block')
- await this.addInitScript(`\nif (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };\n`);
+ await this.addInitScript(undefined, `\nif (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };\n`);
if (this._options.permissions)
await this.grantPermissions(this._options.permissions);
@@ -227,9 +227,7 @@ export abstract class BrowserContext extends SdkObject {
await this.grantPermissions(this._options.permissions);
else
await this.clearPermissions();
- await this.setExtraHTTPHeaders(this._options.extraHTTPHeaders || []);
await this.setGeolocation(this._options.geolocation);
- await this.setOffline(!!this._options.offline);
await this.setUserAgent(this._options.userAgent);
await this.clearCache();
await this._resetCookies();
@@ -268,9 +266,7 @@ export abstract class BrowserContext extends SdkObject {
abstract doCreateNewPage(markAsServerSideOnly?: boolean): Promise<Page>;
abstract addCookies(cookies: channels.SetNetworkCookie[]): Promise<void>;
abstract setGeolocation(geolocation?: types.Geolocation): Promise<void>;
- abstract setExtraHTTPHeaders(headers: types.HeadersArray): Promise<void>;
abstract setUserAgent(userAgent: string | undefined): Promise<void>;
- abstract setOffline(offline: boolean): Promise<void>;
abstract cancelDownload(uuid: string): Promise<void>;
abstract clearCache(): Promise<void>;
protected abstract doGetCookies(urls: string[]): Promise<channels.NetworkCookie[]>;
@@ -280,6 +276,8 @@ export abstract class BrowserContext extends SdkObject {
protected abstract doSetHTTPCredentials(httpCredentials?: types.Credentials): Promise<void>;
protected abstract doAddInitScript(initScript: InitScript): Promise<void>;
protected abstract doRemoveInitScripts(initScripts: InitScript[]): Promise<void>;
+ protected abstract doUpdateExtraHTTPHeaders(): Promise<void>;
+ protected abstract doUpdateOffline(): Promise<void>;
protected abstract doUpdateRequestInterception(): Promise<void>;
protected abstract doExposePlaywrightBinding(): Promise<void>;
protected abstract doClose(reason: string | undefined): Promise<void>;
@@ -338,18 +336,19 @@ export abstract class BrowserContext extends SdkObject {
return this._playwrightBindingExposed;
}
- async exposeBinding(name: string, needsHandle: boolean, playwrightBinding: frames.FunctionWithSource): Promise<PageBinding> {
+ async exposeBinding(progress: Progress, name: string, needsHandle: boolean, playwrightBinding: frames.FunctionWithSource): Promise<PageBinding> {
if (this._pageBindings.has(name))
throw new Error(`Function "${name}" has been already registered`);
for (const page of this.pages()) {
if (page.getBinding(name))
throw new Error(`Function "${name}" has been already registered in one of the pages`);
}
- await this.exposePlaywrightBindingIfNeeded();
+ await progress.race(this.exposePlaywrightBindingIfNeeded());
const binding = new PageBinding(name, playwrightBinding, needsHandle);
this._pageBindings.set(name, binding);
- await this.doAddInitScript(binding.initScript);
- await this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main');
+ progress.cleanupWhenAborted(() => this._pageBindings.delete(name));
+ await progress.race(this.doAddInitScript(binding.initScript));
+ await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
return binding;
}
@@ -380,6 +379,26 @@ export abstract class BrowserContext extends SdkObject {
await this.doClearPermissions();
}
+ async setExtraHTTPHeaders(progress: Progress, headers: types.HeadersArray) {
+ const oldHeaders = this._options.extraHTTPHeaders;
+ this._options.extraHTTPHeaders = headers;
+ progress.cleanupWhenAborted(async () => {
+ this._options.extraHTTPHeaders = oldHeaders;
+ await this.doUpdateExtraHTTPHeaders();
+ });
+ await progress.race(this.doUpdateExtraHTTPHeaders());
+ }
+
+ async setOffline(progress: Progress, offline: boolean) {
+ const oldOffline = this._options.offline;
+ this._options.offline = offline;
+ progress.cleanupWhenAborted(async () => {
+ this._options.offline = oldOffline;
+ await this.doUpdateOffline();
+ });
+ await progress.race(this.doUpdateOffline());
+ }
+
async _loadDefaultContextAsIs(progress: Progress): Promise<Page | undefined> {
if (!this.possiblyUninitializedPages().length) {
const waitForEvent = helper.waitForEvent(progress, this, BrowserContext.Events.Page);
@@ -432,10 +451,15 @@ export abstract class BrowserContext extends SdkObject {
this._options.httpCredentials = { username, password: password || '' };
}
- async addInitScript(source: string, name?: string) {
+ async addInitScript(progress: Progress | undefined, source: string, name?: string) {
const initScript = new InitScript(source, name);
this.initScripts.push(initScript);
- await this.doAddInitScript(initScript);
+ progress?.cleanupWhenAborted(() => this.removeInitScripts([initScript]));
+ const promise = this.doAddInitScript(initScript);
+ if (progress)
+ await progress.race(promise);
+ else
+ await promise;
return initScript;
}
@@ -445,7 +469,8 @@ export abstract class BrowserContext extends SdkObject {
await this.doRemoveInitScripts(initScripts);
}
- async addRequestInterceptor(handler: network.RouteHandler): Promise<void> {
+ async addRequestInterceptor(progress: Progress, handler: network.RouteHandler): Promise<void> {
+ // Note: progress is intentionally ignored, because this operation is not cancellable and should not block in the browser anyway.
this.requestInterceptors.push(handler);
await this.doUpdateRequestInterception();
}
@@ -571,9 +596,9 @@ export abstract class BrowserContext extends SdkObject {
// If there are still origins to save, create a blank page to iterate over origins.
if (originsToSave.size) {
const page = await this.newPage(progress, true);
- await progress.race(page.addRequestInterceptor(route => {
+ await page.addRequestInterceptor(progress, route => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
- }, 'prepend'));
+ }, 'prepend');
for (const origin of originsToSave) {
const frame = page.mainFrame();
await frame.gotoImpl(progress, origin, {});
@@ -601,7 +626,7 @@ export abstract class BrowserContext extends SdkObject {
};
progress.cleanupWhenAborted(() => page.removeRequestInterceptor(interceptor));
- await progress.race(page.addRequestInterceptor(interceptor, 'prepend'));
+ await page.addRequestInterceptor(progress, interceptor, 'prepend');
for (const origin of new Set([...oldOrigins, ...newOrigins.keys()])) {
const frame = page.mainFrame();
@@ -632,9 +657,9 @@ export abstract class BrowserContext extends SdkObject {
await progress.race(this.addCookies(state.cookies));
if (state.origins && state.origins.length) {
const page = await this.newPage(progress, true);
- await progress.race(page.addRequestInterceptor(route => {
+ await page.addRequestInterceptor(progress, route => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
- }, 'prepend'));
+ }, 'prepend');
for (const originState of state.origins) {
const frame = page.mainFrame();
await frame.gotoImpl(progress, originState.origin, {});
@@ -667,13 +692,13 @@ export abstract class BrowserContext extends SdkObject {
await Promise.all(this.pages().map(page => page.safeNonStallingEvaluateInAllFrames(expression, world, options)));
}
- async _harStart(page: Page | null, options: channels.RecordHarOptions): Promise<string> {
+ harStart(page: Page | null, options: channels.RecordHarOptions): string {
const harId = createGuid();
this._harRecorders.set(harId, new HarRecorder(this, page, options));
return harId;
}
- async _harExport(harId: string | undefined): Promise<Artifact> {
+ async harExport(harId: string | undefined): Promise<Artifact> {
const recorder = this._harRecorders.get(harId || '')!;
return recorder.export();
}
diff --git a/packages/playwright-core/src/server/chromium/crBrowser.ts b/packages/playwright-core/src/server/chromium/crBrowser.ts
index 0c640c9879..b58ac97986 100644
--- a/packages/playwright-core/src/server/chromium/crBrowser.ts
+++ b/packages/playwright-core/src/server/chromium/crBrowser.ts
@@ -477,8 +477,7 @@ export class CRBrowserContext extends BrowserContext {
await (page.delegate as CRPage).updateGeolocation();
}
- async setExtraHTTPHeaders(headers: types.HeadersArray): Promise<void> {
- this._options.extraHTTPHeaders = headers;
+ async doUpdateExtraHTTPHeaders(): Promise<void> {
for (const page of this.pages())
await (page.delegate as CRPage).updateExtraHTTPHeaders();
for (const sw of this.serviceWorkers())
@@ -492,8 +491,7 @@ export class CRBrowserContext extends BrowserContext {
// TODO: service workers don't have Emulation domain?
}
- async setOffline(offline: boolean): Promise<void> {
- this._options.offline = offline;
+ async doUpdateOffline(): Promise<void> {
for (const page of this.pages())
await (page.delegate as CRPage).updateOffline();
for (const sw of this.serviceWorkers())
diff --git a/packages/playwright-core/src/server/chromium/crCoverage.ts b/packages/playwright-core/src/server/chromium/crCoverage.ts
index 1a9d01148f..800f7c5094 100644
--- a/packages/playwright-core/src/server/chromium/crCoverage.ts
+++ b/packages/playwright-core/src/server/chromium/crCoverage.ts
@@ -22,6 +22,7 @@ import type { CRSession } from './crConnection';
import type { Protocol } from './protocol';
import type { RegisteredListener } from '../utils/eventsHelper';
import type * as channels from '@protocol/channels';
+import type { Progress } from '@protocol/progress';
export class CRCoverage {
@@ -33,16 +34,18 @@ export class CRCoverage {
this._cssCoverage = new CSSCoverage(client);
}
- async startJSCoverage(options: channels.PageStartJSCoverageParams) {
- return await this._jsCoverage.start(options);
+ async startJSCoverage(progress: Progress, options: channels.PageStartJSCoverageParams) {
+ progress.cleanupWhenAborted(() => this._jsCoverage.stop());
+ await progress.race(this._jsCoverage.start(options));
}
async stopJSCoverage(): Promise<channels.PageStopJSCoverageResult> {
return await this._jsCoverage.stop();
}
- async startCSSCoverage(options: channels.PageStartCSSCoverageParams) {
- return await this._cssCoverage.start(options);
+ async startCSSCoverage(progress: Progress, options: channels.PageStartCSSCoverageParams) {
+ progress.cleanupWhenAborted(() => this._cssCoverage.stop());
+ await progress.race(this._cssCoverage.start(options));
}
async stopCSSCoverage(): Promise<channels.PageStopCSSCoverageResult> {
diff --git a/packages/playwright-core/src/server/clock.ts b/packages/playwright-core/src/server/clock.ts
index 8df4ae86b1..5972e99799 100644
--- a/packages/playwright-core/src/server/clock.ts
+++ b/packages/playwright-core/src/server/clock.ts
@@ -18,6 +18,7 @@ import * as rawClockSource from '../generated/clockSource';
import type { BrowserContext } from './browserContext';
import type { InitScript } from './page';
+import type { Progress } from '@protocol/progress';
export class Clock {
private _browserContext: BrowserContext;
@@ -32,64 +33,76 @@ export class Clock {
this._initScripts = [];
}
- async fastForward(ticks: number | string) {
- await this._installIfNeeded();
+ async fastForward(progress: Progress, ticks: number | string) {
+ await this._installIfNeeded(progress);
const ticksMillis = parseTicks(ticks);
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`));
}
- async install(time: number | string | undefined) {
- await this._installIfNeeded();
+ async install(progress: Progress, time: number | string | undefined) {
+ await this._installIfNeeded(progress);
const timeMillis = time !== undefined ? parseTime(time) : Date.now();
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`));
}
- async pauseAt(ticks: number | string) {
- await this._installIfNeeded();
+ async pauseAt(progress: Progress, ticks: number | string) {
+ await this._installIfNeeded(progress);
const timeMillis = parseTime(ticks);
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`));
}
- async resume() {
- await this._installIfNeeded();
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
+ resumeNoReply() {
+ if (!this._initScripts.length)
+ return;
+ const doResume = async () => {
+ this._initScripts.push(await this._browserContext.addInitScript(undefined, `globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
+ await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
+ };
+ doResume().catch(() => {});
+ }
+
+ async resume(progress: Progress) {
+ await this._installIfNeeded(progress);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`));
}
- async setFixedTime(time: string | number) {
- await this._installIfNeeded();
+ async setFixedTime(progress: Progress, time: string | number) {
+ await this._installIfNeeded(progress);
const timeMillis = parseTime(time);
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`));
}
- async setSystemTime(time: string | number) {
- await this._installIfNeeded();
+ async setSystemTime(progress: Progress, time: string | number) {
+ await this._installIfNeeded(progress);
const timeMillis = parseTime(time);
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`));
}
- async runFor(ticks: number | string) {
- await this._installIfNeeded();
+ async runFor(progress: Progress, ticks: number | string) {
+ await this._installIfNeeded(progress);
const ticksMillis = parseTicks(ticks);
- this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`));
- await this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`);
+ this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`));
+ await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`));
}
- private async _installIfNeeded() {
+ private async _installIfNeeded(progress: Progress) {
if (this._initScripts.length)
return;
const script = `(() => {
const module = {};
${rawClockSource.source}
- globalThis.__pwClock = (module.exports.inject())(globalThis);
+ if (!globalThis.__pwClock)
+ globalThis.__pwClock = (module.exports.inject())(globalThis);
})();`;
- this._initScripts.push(await this._browserContext.addInitScript(script));
- await this._evaluateInFrames(script);
+ const initScript = await this._browserContext.addInitScript(progress, script);
+ await progress.race(this._evaluateInFrames(script));
+ this._initScripts.push(initScript);
}
private async _evaluateInFrames(script: string) {
diff --git a/packages/playwright-core/src/server/debugController.ts b/packages/playwright-core/src/server/debugController.ts
index a861facd8c..14cd66b2fc 100644
--- a/packages/playwright-core/src/server/debugController.ts
+++ b/packages/playwright-core/src/server/debugController.ts
@@ -109,7 +109,8 @@ export class DebugController extends SdkObject {
if (!pages.length) {
const [browser] = this._playwright.allBrowsers();
const { context } = await browser.newContextForReuse({}, internalMetadata);
- await context.newPageFromMetadata(internalMetadata);
+ const controller = new ProgressController(internalMetadata, this);
+ await controller.run(progress => context.newPage(progress, false /* isServerSide */));
}
// Update test id attribute.
if (params.testIdAttributeName) {
diff --git a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
index 9609d62a26..860d83852b 100644
--- a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
@@ -40,11 +40,11 @@ import { RecorderApp } from '../recorder/recorderApp';
import type { Artifact } from '../artifact';
import type { ConsoleMessage } from '../console';
import type { Dialog } from '../dialog';
-import type { CallMetadata } from '../instrumentation';
import type { Request, Response, RouteHandler } from '../network';
import type { InitScript, Page, PageBinding } from '../page';
import type { DispatcherScope } from './dispatcher';
import type * as channels from '@protocol/channels';
+import type { Progress } from '@protocol/progress';
export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channels.BrowserContextChannel, DispatcherScope> implements channels.BrowserContextChannel {
_type_EventTarget = true;
@@ -214,24 +214,24 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
return false;
}
- async createTempFiles(params: channels.BrowserContextCreateTempFilesParams): Promise<channels.BrowserContextCreateTempFilesResult> {
+ async createTempFiles(params: channels.BrowserContextCreateTempFilesParams, progress: Progress): Promise<channels.BrowserContextCreateTempFilesResult> {
const dir = this._context._browser.options.artifactsDir;
const tmpDir = path.join(dir, 'upload-' + createGuid());
const tempDirWithRootName = params.rootDirName ? path.join(tmpDir, path.basename(params.rootDirName)) : tmpDir;
- await fs.promises.mkdir(tempDirWithRootName, { recursive: true });
+ await progress.race(fs.promises.mkdir(tempDirWithRootName, { recursive: true }));
this._context._tempDirs.push(tmpDir);
return {
rootDir: params.rootDirName ? new WritableStreamDispatcher(this, tempDirWithRootName) : undefined,
writableStreams: await Promise.all(params.items.map(async item => {
- await fs.promises.mkdir(path.dirname(path.join(tempDirWithRootName, item.name)), { recursive: true });
+ await progress.race(fs.promises.mkdir(path.dirname(path.join(tempDirWithRootName, item.name)), { recursive: true }));
const file = fs.createWriteStream(path.join(tempDirWithRootName, item.name));
return new WritableStreamDispatcher(this, file, item.lastModifiedMs);
}))
};
}
- async exposeBinding(params: channels.BrowserContextExposeBindingParams): Promise<void> {
- const binding = await this._context.exposeBinding(params.name, !!params.needsHandle, (source, ...args) => {
+ async exposeBinding(params: channels.BrowserContextExposeBindingParams, progress: Progress): Promise<void> {
+ const binding = await this._context.exposeBinding(progress, params.name, !!params.needsHandle, (source, ...args) => {
// When reusing the context, we might have some bindings called late enough,
// after context and page dispatchers have been disposed.
if (this._disposed)
@@ -244,19 +244,21 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
this._bindings.push(binding);
}
- async newPage(params: channels.BrowserContextNewPageParams, metadata: CallMetadata): Promise<channels.BrowserContextNewPageResult> {
- return { page: PageDispatcher.from(this, await this._context.newPageFromMetadata(metadata)) };
+ async newPage(params: channels.BrowserContextNewPageParams, progress: Progress): Promise<channels.BrowserContextNewPageResult> {
+ return { page: PageDispatcher.from(this, await this._context.newPage(progress, false /* isServerSide */)) };
}
- async cookies(params: channels.BrowserContextCookiesParams): Promise<channels.BrowserContextCookiesResult> {
- return { cookies: await this._context.cookies(params.urls) };
+ async cookies(params: channels.BrowserContextCookiesParams, progress: Progress): Promise<channels.BrowserContextCookiesResult> {
+ return { cookies: await progress.race(this._context.cookies(params.urls)) };
}
- async addCookies(params: channels.BrowserContextAddCookiesParams): Promise<void> {
+ async addCookies(params: channels.BrowserContextAddCookiesParams, progress: Progress): Promise<void> {
+ // Note: progress is ignored because this operation is not cancellable and should not block in the browser anyway.
await this._context.addCookies(params.cookies);
}
- async clearCookies(params: channels.BrowserContextClearCookiesParams): Promise<void> {
+ async clearCookies(params: channels.BrowserContextClearCookiesParams, progress: Progress): Promise<void> {
+ // Note: progress is ignored because this operation is not cancellable and should not block in the browser anyway.
const nameRe = params.nameRegexSource !== undefined && params.nameRegexFlags !== undefined ? new RegExp(params.nameRegexSource, params.nameRegexFlags) : undefined;
const domainRe = params.domainRegexSource !== undefined && params.domainRegexFlags !== undefined ? new RegExp(params.domainRegexSource, params.domainRegexFlags) : undefined;
const pathRe = params.pathRegexSource !== undefined && params.pathRegexFlags !== undefined ? new RegExp(params.pathRegexSource, params.pathRegexFlags) : undefined;
@@ -267,35 +269,39 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
});
}
- async grantPermissions(params: channels.BrowserContextGrantPermissionsParams): Promise<void> {
+ async grantPermissions(params: channels.BrowserContextGrantPermissionsParams, progress: Progress): Promise<void> {
+ // Note: progress is ignored because this operation is not cancellable and should not block in the browser anyway.
await this._context.grantPermissions(params.permissions, params.origin);
}
- async clearPermissions(): Promise<void> {
+ async clearPermissions(params: channels.BrowserContextClearPermissionsParams, progress: Progress): Promise<void> {
+ // Note: progress is ignored because this operation is not cancellable and should not block in the browser anyway.
await this._context.clearPermissions();
}
- async setGeolocation(params: channels.BrowserContextSetGeolocationParams): Promise<void> {
+ async setGeolocation(params: channels.BrowserContextSetGeolocationParams, progress: Progress): Promise<void> {
+ // Note: progress is ignored because this operation is not cancellable and should not block in the browser anyway.
await this._context.setGeolocation(params.geolocation);
}
- async setExtraHTTPHeaders(params: channels.BrowserContextSetExtraHTTPHeadersParams): Promise<void> {
- await this._context.setExtraHTTPHeaders(params.headers);
+ async setExtraHTTPHeaders(params: channels.BrowserContextSetExtraHTTPHeadersParams, progress: Progress): Promise<void> {
+ await this._context.setExtraHTTPHeaders(progress, params.headers);
}
- async setOffline(params: channels.BrowserContextSetOfflineParams): Promise<void> {
- await this._context.setOffline(params.offline);
+ async setOffline(params: channels.BrowserContextSetOfflineParams, progress: Progress): Promise<void> {
+ await this._context.setOffline(progress, params.offline);
}
- async setHTTPCredentials(params: channels.BrowserContextSetHTTPCredentialsParams): Promise<void> {
- await this._context.setHTTPCredentials(params.httpCredentials);
+ async setHTTPCredentials(params: channels.BrowserContextSetHTTPCredentialsParams, progress: Progress): Promise<void> {
+ // Note: this operation is deprecated, so we do not properly cleanup.
+ await progress.race(this._context.setHTTPCredentials(params.httpCredentials));
}
- async addInitScript(params: channels.BrowserContextAddInitScriptParams): Promise<void> {
- this._initScritps.push(await this._context.addInitScript(params.source));
+ async addInitScript(params: channels.BrowserContextAddInitScriptParams, progress: Progress): Promise<void> {
+ this._initScritps.push(await this._context.addInitScript(progress, params.source));
}
- async setNetworkInterceptionPatterns(params: channels.BrowserContextSetNetworkInterceptionPatternsParams): Promise<void> {
+ async setNetworkInterceptionPatterns(params: channels.BrowserContextSetNetworkInterceptionPatternsParams, progress: Progress): Promise<void> {
const hadMatchers = this._interceptionUrlMatchers.length > 0;
if (!params.patterns.length) {
// Note: it is important to remove the interceptor when there are no patterns,
@@ -306,96 +312,96 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
} else {
this._interceptionUrlMatchers = params.patterns.map(pattern => pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags!) : pattern.glob!);
if (!hadMatchers)
- await this._context.addRequestInterceptor(this._requestInterceptor);
+ await this._context.addRequestInterceptor(progress, this._requestInterceptor);
}
}
- async setWebSocketInterceptionPatterns(params: channels.PageSetWebSocketInterceptionPatternsParams, metadata: CallMetadata): Promise<void> {
+ async setWebSocketInterceptionPatterns(params: channels.PageSetWebSocketInterceptionPatternsParams, progress: Progress): Promise<void> {
this._webSocketInterceptionPatterns = params.patterns;
if (params.patterns.length)
- await WebSocketRouteDispatcher.installIfNeeded(this.connection, this._context);
+ await WebSocketRouteDispatcher.installIfNeeded(progress, this.connection, this._context);
}
- async storageState(params: channels.BrowserContextStorageStateParams, metadata: CallMetadata): Promise<channels.BrowserContextStorageStateResult> {
- return await this._context.storageState(params.indexedDB);
+ async storageState(params: channels.BrowserContextStorageStateParams, progress: Progress): Promise<channels.BrowserContextStorageStateResult> {
+ return await progress.race(this._context.storageState(params.indexedDB));
}
- async close(params: channels.BrowserContextCloseParams, metadata: CallMetadata): Promise<void> {
- metadata.potentiallyClosesScope = true;
+ async close(params: channels.BrowserContextCloseParams, progress: Progress): Promise<void> {
+ progress.metadata.potentiallyClosesScope = true;
await this._context.close(params);
}
- async enableRecorder(params: channels.BrowserContextEnableRecorderParams): Promise<void> {
+ async enableRecorder(params: channels.BrowserContextEnableRecorderParams, progress: Progress): Promise<void> {
await Recorder.show(this._context, RecorderApp.factory(this._context), params);
}
- async pause(params: channels.BrowserContextPauseParams, metadata: CallMetadata) {
+ async pause(params: channels.BrowserContextPauseParams, progress: Progress) {
// Debugger will take care of this.
}
- async newCDPSession(params: channels.BrowserContextNewCDPSessionParams): Promise<channels.BrowserContextNewCDPSessionResult> {
+ async newCDPSession(params: channels.BrowserContextNewCDPSessionParams, progress: Progress): Promise<channels.BrowserContextNewCDPSessionResult> {
if (!this._object._browser.options.isChromium)
throw new Error(`CDP session is only available in Chromium`);
if (!params.page && !params.frame || params.page && params.frame)
throw new Error(`CDP session must be initiated with either Page or Frame, not none or both`);
const crBrowserContext = this._object as CRBrowserContext;
- return { session: new CDPSessionDispatcher(this, await crBrowserContext.newCDPSession((params.page ? params.page as PageDispatcher : params.frame as FrameDispatcher)._object)) };
+ return { session: new CDPSessionDispatcher(this, await progress.race(crBrowserContext.newCDPSession((params.page ? params.page as PageDispatcher : params.frame as FrameDispatcher)._object))) };
}
- async harStart(params: channels.BrowserContextHarStartParams): Promise<channels.BrowserContextHarStartResult> {
- const harId = await this._context._harStart(params.page ? (params.page as PageDispatcher)._object : null, params.options);
+ async harStart(params: channels.BrowserContextHarStartParams, progress: Progress): Promise<channels.BrowserContextHarStartResult> {
+ const harId = this._context.harStart(params.page ? (params.page as PageDispatcher)._object : null, params.options);
return { harId };
}
- async harExport(params: channels.BrowserContextHarExportParams): Promise<channels.BrowserContextHarExportResult> {
- const artifact = await this._context._harExport(params.harId);
+ async harExport(params: channels.BrowserContextHarExportParams, progress: Progress): Promise<channels.BrowserContextHarExportResult> {
+ const artifact = await progress.race(this._context.harExport(params.harId));
if (!artifact)
throw new Error('No HAR artifact. Ensure record.harPath is set.');
return { artifact: ArtifactDispatcher.from(this, artifact) };
}
- async clockFastForward(params: channels.BrowserContextClockFastForwardParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockFastForwardResult> {
- await this._context.clock.fastForward(params.ticksString ?? params.ticksNumber ?? 0);
+ async clockFastForward(params: channels.BrowserContextClockFastForwardParams, progress: Progress): Promise<channels.BrowserContextClockFastForwardResult> {
+ await this._context.clock.fastForward(progress, params.ticksString ?? params.ticksNumber ?? 0);
}
- async clockInstall(params: channels.BrowserContextClockInstallParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockInstallResult> {
- await this._context.clock.install(params.timeString ?? params.timeNumber ?? undefined);
+ async clockInstall(params: channels.BrowserContextClockInstallParams, progress: Progress): Promise<channels.BrowserContextClockInstallResult> {
+ await this._context.clock.install(progress, params.timeString ?? params.timeNumber ?? undefined);
}
- async clockPauseAt(params: channels.BrowserContextClockPauseAtParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockPauseAtResult> {
- await this._context.clock.pauseAt(params.timeString ?? params.timeNumber ?? 0);
+ async clockPauseAt(params: channels.BrowserContextClockPauseAtParams, progress: Progress): Promise<channels.BrowserContextClockPauseAtResult> {
+ await this._context.clock.pauseAt(progress, params.timeString ?? params.timeNumber ?? 0);
this._clockPaused = true;
}
- async clockResume(params: channels.BrowserContextClockResumeParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockResumeResult> {
- await this._context.clock.resume();
+ async clockResume(params: channels.BrowserContextClockResumeParams, progress: Progress): Promise<channels.BrowserContextClockResumeResult> {
+ await this._context.clock.resume(progress);
this._clockPaused = false;
}
- async clockRunFor(params: channels.BrowserContextClockRunForParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockRunForResult> {
- await this._context.clock.runFor(params.ticksString ?? params.ticksNumber ?? 0);
+ async clockRunFor(params: channels.BrowserContextClockRunForParams, progress: Progress): Promise<channels.BrowserContextClockRunForResult> {
+ await this._context.clock.runFor(progress, params.ticksString ?? params.ticksNumber ?? 0);
}
- async clockSetFixedTime(params: channels.BrowserContextClockSetFixedTimeParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockSetFixedTimeResult> {
- await this._context.clock.setFixedTime(params.timeString ?? params.timeNumber ?? 0);
+ async clockSetFixedTime(params: channels.BrowserContextClockSetFixedTimeParams, progress: Progress): Promise<channels.BrowserContextClockSetFixedTimeResult> {
+ await this._context.clock.setFixedTime(progress, params.timeString ?? params.timeNumber ?? 0);
}
- async clockSetSystemTime(params: channels.BrowserContextClockSetSystemTimeParams, metadata?: CallMetadata | undefined): Promise<channels.BrowserContextClockSetSystemTimeResult> {
- await this._context.clock.setSystemTime(params.timeString ?? params.timeNumber ?? 0);
+ async clockSetSystemTime(params: channels.BrowserContextClockSetSystemTimeParams, progress: Progress): Promise<channels.BrowserContextClockSetSystemTimeResult> {
+ await this._context.clock.setSystemTime(progress, params.timeString ?? params.timeNumber ?? 0);
}
- async updateSubscription(params: channels.BrowserContextUpdateSubscriptionParams): Promise<void> {
+ async updateSubscription(params: channels.BrowserContextUpdateSubscriptionParams, progress: Progress): Promise<void> {
if (params.enabled)
this._subscriptions.add(params.event);
else
this._subscriptions.delete(params.event);
}
- async registerSelectorEngine(params: channels.BrowserContextRegisterSelectorEngineParams): Promise<void> {
+ async registerSelectorEngine(params: channels.BrowserContextRegisterSelectorEngineParams, progress: Progress): Promise<void> {
this._object.selectors().register(params.selectorEngine);
}
- async setTestIdAttributeName(params: channels.BrowserContextSetTestIdAttributeNameParams): Promise<void> {
+ async setTestIdAttributeName(params: channels.BrowserContextSetTestIdAttributeNameParams, progress: Progress): Promise<void> {
this._object.selectors().setTestIdAttributeName(params.testIdAttributeName);
}
@@ -413,7 +419,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
this._context.removeInitScripts(this._initScritps).catch(() => {});
this._initScritps = [];
if (this._clockPaused)
- this._context.clock.resume().catch(() => {});
+ this._context.clock.resumeNoReply();
this._clockPaused = false;
}
}
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 4d633c7f2c..0760b340f8 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -33,13 +33,13 @@ import type { BrowserContext } from '../browserContext';
import type { CRCoverage } from '../chromium/crCoverage';
import type { Download } from '../download';
import type { FileChooser } from '../fileChooser';
-import type { CallMetadata } from '../instrumentation';
import type { JSHandle } from '../javascript';
import type { BrowserContextDispatcher } from './browserContextDispatcher';
import type { Frame } from '../frames';
import type { RouteHandler } from '../network';
import type { InitScript, PageBinding } from '../page';
import type * as channels from '@protocol/channels';
+import type { Progress } from '@protocol/progress';
export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, BrowserContextDispatcher> implements channels.PageChannel {
_type_EventTarget = true;
@@ -124,8 +124,8 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
return this._page;
}
- async exposeBinding(params: channels.PageExposeBindingParams, metadata: CallMetadata): Promise<void> {
- const binding = await this._page.exposeBinding(params.name, !!params.needsHandle, (source, ...args) => {
+ async exposeBinding(params: channels.PageExposeBindingParams, progress: Progress): Promise<void> {
+ const binding = await this._page.exposeBinding(progress, params.name, !!params.needsHandle, (source, ...args) => {
// When reusing the context, we might have some bindings called late enough,
// after context and page dispatchers have been disposed.
if (this._disposed)
@@ -137,43 +137,43 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
this._bindings.push(binding);
}
- async setExtraHTTPHeaders(params: channels.PageSetExtraHTTPHeadersParams, metadata: CallMetadata): Promise<void> {
- await this._page.setExtraHTTPHeaders(params.headers);
+ async setExtraHTTPHeaders(params: channels.PageSetExtraHTTPHeadersParams, progress: Progress): Promise<void> {
+ await this._page.setExtraHTTPHeaders(progress, params.headers);
}
- async reload(params: channels.PageReloadParams, metadata: CallMetadata): Promise<channels.PageReloadResult> {
- return { response: ResponseDispatcher.fromNullable(this.parentScope(), await this._page.reload(metadata, params)) };
+ async reload(params: channels.PageReloadParams, progress: Progress): Promise<channels.PageReloadResult> {
+ return { response: ResponseDispatcher.fromNullable(this.parentScope(), await this._page.reload(progress, params)) };
}
- async goBack(params: channels.PageGoBackParams, metadata: CallMetadata): Promise<channels.PageGoBackResult> {
- return { response: ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goBack(metadata, params)) };
+ async goBack(params: channels.PageGoBackParams, progress: Progress): Promise<channels.PageGoBackResult> {
+ return { response: ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goBack(progress, params)) };
}
- async goForward(params: channels.PageGoForwardParams, metadata: CallMetadata): Promise<channels.PageGoForwardResult> {
- return { response: ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goForward(metadata, params)) };
+ async goForward(params: channels.PageGoForwardParams, progress: Progress): Promise<channels.PageGoForwardResult> {
+ return { response: ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goForward(progress, params)) };
}
- async requestGC(params: channels.PageRequestGCParams, metadata: CallMetadata): Promise<channels.PageRequestGCResult> {
- await this._page.requestGC();
+ async requestGC(params: channels.PageRequestGCParams, progress: Progress): Promise<channels.PageRequestGCResult> {
+ await progress.race(this._page.requestGC());
}
- async registerLocatorHandler(params: channels.PageRegisterLocatorHandlerParams, metadata: CallMetadata): Promise<channels.PageRegisterLocatorHandlerResult> {
+ async registerLocatorHandler(params: channels.PageRegisterLocatorHandlerParams, progress: Progress): Promise<channels.PageRegisterLocatorHandlerResult> {
const uid = this._page.registerLocatorHandler(params.selector, params.noWaitAfter);
this._locatorHandlers.add(uid);
return { uid };
}
- async resolveLocatorHandlerNoReply(params: channels.PageResolveLocatorHandlerNoReplyParams, metadata: CallMetadata): Promise<void> {
+ async resolveLocatorHandlerNoReply(params: channels.PageResolveLocatorHandlerNoReplyParams, progress: Progress): Promise<void> {
this._page.resolveLocatorHandler(params.uid, params.remove);
}
- async unregisterLocatorHandler(params: channels.PageUnregisterLocatorHandlerParams, metadata: CallMetadata): Promise<void> {
+ async unregisterLocatorHandler(params: channels.PageUnregisterLocatorHandlerParams, progress: Progress): Promise<void> {
this._page.unregisterLocatorHandler(params.uid);
this._locatorHandlers.delete(params.uid);
}
- async emulateMedia(params: channels.PageEmulateMediaParams, metadata: CallMetadata): Promise<void> {
- await this._page.emulateMedia({
+ async emulateMedia(params: channels.PageEmulateMediaParams, progress: Progress): Promise<void> {
+ await this._page.emulateMedia(progress, {
media: params.media,
colorScheme: params.colorScheme,
reducedMotion: params.reducedMotion,
@@ -182,15 +182,15 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
});
}
- async setViewportSize(params: channels.PageSetViewportSizeParams, metadata: CallMetadata): Promise<void> {
- await this._page.setViewportSize(params.viewportSize);
+ async setViewportSize(params: channels.PageSetViewportSizeParams, progress: Progress): Promise<void> {
+ await this._page.setViewportSize(progress, params.viewportSize);
}
- async addInitScript(params: channels.PageAddInitScriptParams, metadata: CallMetadata): Promise<void> {
- this._initScripts.push(await this._page.addInitScript(params.source));
+ async addInitScript(params: channels.PageAddInitScriptParams, progress: Progress): Promise<void> {
+ this._initScripts.push(await this._page.addInitScript(progress, params.source));
}
- async setNetworkInterceptionPatterns(params: channels.PageSetNetworkInterceptionPatternsParams, metadata: CallMetadata): Promise<void> {
+ async setNetworkInterceptionPatterns(params: channels.PageSetNetworkInterceptionPatternsParams, progress: Progress): Promise<void> {
const hadMatchers = this._interceptionUrlMatchers.length > 0;
if (!params.patterns.length) {
// Note: it is important to remove the interceptor when there are no patterns,
@@ -201,17 +201,17 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
} else {
this._interceptionUrlMatchers = params.patterns.map(pattern => pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags!) : pattern.glob!);
if (!hadMatchers)
- await this._page.addRequestInterceptor(this._requestInterceptor);
+ await this._page.addRequestInterceptor(progress, this._requestInterceptor);
}
}
- async setWebSocketInterceptionPatterns(params: channels.PageSetWebSocketInterceptionPatternsParams, metadata: CallMetadata): Promise<void> {
+ async setWebSocketInterceptionPatterns(params: channels.PageSetWebSocketInterceptionPatternsParams, progress: Progress): Promise<void> {
this._webSocketInterceptionPatterns = params.patterns;
if (params.patterns.length)
- await WebSocketRouteDispatcher.installIfNeeded(this.connection, this._page);
+ await WebSocketRouteDispatcher.installIfNeeded(progress, this.connection, this._page);
}
- async expectScreenshot(params: channels.PageExpectScreenshotParams, metadata: CallMetadata): Promise<channels.PageExpectScreenshotResult> {
+ async expectScreenshot(params: channels.PageExpectScreenshotParams, progress: Progress): Promise<channels.PageExpectScreenshotResult> {
const mask: { frame: Frame, selector: string }[] = (params.mask || []).map(({ frame, selector }) => ({
frame: (frame as FrameDispatcher)._object,
selector,
@@ -220,28 +220,29 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
frame: (params.locator.frame as FrameDispatcher)._object,
selector: params.locator.selector,
} : undefined;
- return await this._page.expectScreenshot(metadata, {
+ return await this._page.expectScreenshot(progress, {
...params,
locator,
mask,
});
}
- async screenshot(params: channels.PageScreenshotParams, metadata: CallMetadata): Promise<channels.PageScreenshotResult> {
+ async screenshot(params: channels.PageScreenshotParams, progress: Progress): Promise<channels.PageScreenshotResult> {
const mask: { frame: Frame, selector: string }[] = (params.mask || []).map(({ frame, selector }) => ({
frame: (frame as FrameDispatcher)._object,
selector,
}));
- return { binary: await this._page.screenshot(metadata, { ...params, mask }) };
+ return { binary: await this._page.screenshot(progress, { ...params, mask }) };
}
- async close(params: channels.PageCloseParams, metadata: CallMetadata): Promise<void> {
+ async close(params: channels.PageCloseParams, progress: Progress): Promise<void> {
if (!params.runBeforeUnload)
- metadata.potentiallyClosesScope = true;
+ progress.metadata.potentiallyClosesScope = true;
await this._page.close(params);
}
- async updateSubscription(params: channels.PageUpdateSubscriptionParams): Promise<void> {
+ async updateSubscription(params: channels.PageUpdateSubscriptionParams, progress: Progress): Promise<void> {
+ // Note: progress is ignored because this operation is not cancellable and should not block in the browser anyway.
if (params.event === 'fileChooser')
await this._page.setFileChooserInterceptedBy(params.enabled, this);
if (params.enabled)
@@ -250,102 +251,100 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
this._subscriptions.delete(params.event);
}
- async keyboardDown(params: channels.PageKeyboardDownParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.down(metadata, params.key);
+ async keyboardDown(params: channels.PageKeyboardDownParams, progress: Progress): Promise<void> {
+ await this._page.keyboard.down(progress, params.key);
}
- async keyboardUp(params: channels.PageKeyboardUpParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.up(metadata, params.key);
+ async keyboardUp(params: channels.PageKeyboardUpParams, progress: Progress): Promise<void> {
+ await this._page.keyboard.up(progress, params.key);
}
- async keyboardInsertText(params: channels.PageKeyboardInsertTextParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.insertText(metadata, params.text);
+ async keyboardInsertText(params: channels.PageKeyboardInsertTextParams, progress: Progress): Promise<void> {
+ await this._page.keyboard.insertText(progress, params.text);
}
- async keyboardType(params: channels.PageKeyboardTypeParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.type(metadata, params.text, params);
+ async keyboardType(params: channels.PageKeyboardTypeParams, progress: Progress): Promise<void> {
+ await this._page.keyboard.type(progress, params.text, params);
}
- async keyboardPress(params: channels.PageKeyboardPressParams, metadata: CallMetadata): Promise<void> {
- await this._page.keyboard.press(metadata, params.key, params);
+ async keyboardPress(params: channels.PageKeyboardPressParams, progress: Progress): Promise<void> {
+ await this._page.keyboard.press(progress, params.key, params);
}
- async mouseMove(params: channels.PageMouseMoveParams, metadata: CallMetadata): Promise<void> {
- metadata.point = { x: params.x, y: params.y };
- await this._page.mouse.move(metadata, params.x, params.y, params);
+ async mouseMove(params: channels.PageMouseMoveParams, progress: Progress): Promise<void> {
+ progress.metadata.point = { x: params.x, y: params.y };
+ await this._page.mouse.move(progress, params.x, params.y, params);
}
- async mouseDown(params: channels.PageMouseDownParams, metadata: CallMetadata): Promise<void> {
- metadata.point = this._page.mouse.currentPoint();
- await this._page.mouse.down(metadata, params);
+ async mouseDown(params: channels.PageMouseDownParams, progress: Progress): Promise<void> {
+ progress.metadata.point = this._page.mouse.currentPoint();
+ await this._page.mouse.down(progress, params);
}
- async mouseUp(params: channels.PageMouseUpParams, metadata: CallMetadata): Promise<void> {
- metadata.point = this._page.mouse.currentPoint();
- await this._page.mouse.up(metadata, params);
+ async mouseUp(params: channels.PageMouseUpParams, progress: Progress): Promise<void> {
+ progress.metadata.point = this._page.mouse.currentPoint();
+ await this._page.mouse.up(progress, params);
}
- async mouseClick(params: channels.PageMouseClickParams, metadata: CallMetadata): Promise<void> {
- metadata.point = { x: params.x, y: params.y };
- await this._page.mouse.click(metadata, params.x, params.y, params);
+ async mouseClick(params: channels.PageMouseClickParams, progress: Progress): Promise<void> {
+ progress.metadata.point = { x: params.x, y: params.y };
+ await this._page.mouse.click(progress, params.x, params.y, params);
}
- async mouseWheel(params: channels.PageMouseWheelParams, metadata: CallMetadata): Promise<void> {
- await this._page.mouse.wheel(metadata, params.deltaX, params.deltaY);
+ async mouseWheel(params: channels.PageMouseWheelParams, progress: Progress): Promise<void> {
+ await this._page.mouse.wheel(progress, params.deltaX, params.deltaY);
}
- async touchscreenTap(params: channels.PageTouchscreenTapParams, metadata: CallMetadata): Promise<void> {
- metadata.point = { x: params.x, y: params.y };
- await this._page.touchscreen.tap(metadata, params.x, params.y);
+ async touchscreenTap(params: channels.PageTouchscreenTapParams, progress: Progress): Promise<void> {
+ progress.metadata.point = { x: params.x, y: params.y };
+ await this._page.touchscreen.tap(progress, params.x, params.y);
}
- async accessibilitySnapshot(params: channels.PageAccessibilitySnapshotParams, metadata: CallMetadata): Promise<channels.PageAccessibilitySnapshotResult> {
- const rootAXNode = await this._page.accessibility.snapshot({
+ async accessibilitySnapshot(params: channels.PageAccessibilitySnapshotParams, progress: Progress): Promise<channels.PageAccessibilitySnapshotResult> {
+ const rootAXNode = await progress.race(this._page.accessibility.snapshot({
interestingOnly: params.interestingOnly,
root: params.root ? (params.root as ElementHandleDispatcher)._elementHandle : undefined
- });
+ }));
return { rootAXNode: rootAXNode || undefined };
}
- async pdf(params: channels.PagePdfParams, metadata: CallMetadata): Promise<channels.PagePdfResult> {
+ async pdf(params: channels.PagePdfParams, progress: Progress): Promise<channels.PagePdfResult> {
if (!this._page.pdf)
throw new Error('PDF generation is only supported for Headless Chromium');
- const buffer = await this._page.pdf(params);
+ const buffer = await progress.race(this._page.pdf(params));
return { pdf: buffer };
}
- async snapshotForAI(params: channels.PageSnapshotForAIParams, metadata: CallMetadata): Promise<channels.PageSnapshotForAIResult> {
- return { snapshot: await this._page.snapshotForAI(metadata) };
+ async snapshotForAI(params: channels.PageSnapshotForAIParams, progress: Progress): Promise<channels.PageSnapshotForAIResult> {
+ return { snapshot: await this._page.snapshotForAI(progress) };
}
- async bringToFront(params: channels.PageBringToFrontParams, metadata: CallMetadata): Promise<void> {
- await this._page.bringToFront();
+ async bringToFront(params: channels.PageBringToFrontParams, progress: Progress): Promise<void> {
+ await progress.race(this._page.bringToFront());
}
- async startJSCoverage(params: channels.PageStartJSCoverageParams, metadata: CallMetadata): Promise<void> {
- this._jsCoverageActive = true;
+ async startJSCoverage(params: channels.PageStartJSCoverageParams, progress: Progress): Promise<void> {
const coverage = this._page.coverage as CRCoverage;
- await coverage.startJSCoverage(params);
+ await coverage.startJSCoverage(progress, params);
+ this._jsCoverageActive = true;
}
- async stopJSCoverage(params: channels.PageStopJSCoverageParams, metadata: CallMetadata): Promise<channels.PageStopJSCoverageResult> {
- const coverage = this._page.coverage as CRCoverage;
- const result = await coverage.stopJSCoverage();
+ async stopJSCoverage(params: channels.PageStopJSCoverageParams, progress: Progress): Promise<channels.PageStopJSCoverageResult> {
this._jsCoverageActive = false;
- return result;
+ const coverage = this._page.coverage as CRCoverage;
+ return await coverage.stopJSCoverage();
}
- async startCSSCoverage(params: channels.PageStartCSSCoverageParams, metadata: CallMetadata): Promise<void> {
- this._cssCoverageActive = true;
+ async startCSSCoverage(params: channels.PageStartCSSCoverageParams, progress: Progress): Promise<void> {
const coverage = this._page.coverage as CRCoverage;
- await coverage.startCSSCoverage(params);
+ await coverage.startCSSCoverage(progress, params);
+ this._cssCoverageActive = true;
}
- async stopCSSCoverage(params: channels.PageStopCSSCoverageParams, metadata: CallMetadata): Promise<channels.PageStopCSSCoverageResult> {
- const coverage = this._page.coverage as CRCoverage;
- const result = await coverage.stopCSSCoverage();
+ async stopCSSCoverage(params: channels.PageStopCSSCoverageParams, progress: Progress): Promise<channels.PageStopCSSCoverageResult> {
this._cssCoverageActive = false;
- return result;
+ const coverage = this._page.coverage as CRCoverage;
+ return await coverage.stopCSSCoverage();
}
_onFrameAttached(frame: Frame) {
@@ -399,12 +398,12 @@ export class WorkerDispatcher extends Dispatcher<Worker, channels.WorkerChannel,
this.addObjectListener(Worker.Events.Close, () => this._dispatchEvent('close'));
}
- async evaluateExpression(params: channels.WorkerEvaluateExpressionParams, metadata: CallMetadata): Promise<channels.WorkerEvaluateExpressionResult> {
- return { value: serializeResult(await this._object.evaluateExpression(params.expression, params.isFunction, parseArgument(params.arg))) };
+ async evaluateExpression(params: channels.WorkerEvaluateExpressionParams, progress: Progress): Promise<channels.WorkerEvaluateExpressionResult> {
+ return { value: serializeResult(await progress.race(this._object.evaluateExpression(params.expression, params.isFunction, parseArgument(params.arg)))) };
}
- async evaluateExpressionHandle(params: channels.WorkerEvaluateExpressionHandleParams, metadata: CallMetadata): Promise<channels.WorkerEvaluateExpressionHandleResult> {
- return { handle: JSHandleDispatcher.fromJSHandle(this, await this._object.evaluateExpressionHandle(params.expression, params.isFunction, parseArgument(params.arg))) };
+ async evaluateExpressionHandle(params: channels.WorkerEvaluateExpressionHandleParams, progress: Progress): Promise<channels.WorkerEvaluateExpressionHandleResult> {
+ return { handle: JSHandleDispatcher.fromJSHandle(this, await progress.race(this._object.evaluateExpressionHandle(params.expression, params.isFunction, parseArgument(params.arg)))) };
}
}
@@ -432,12 +431,12 @@ export class BindingCallDispatcher extends Dispatcher<SdkObject, channels.Bindin
return this._promise;
}
- async resolve(params: channels.BindingCallResolveParams, metadata: CallMetadata): Promise<void> {
+ async resolve(params: channels.BindingCallResolveParams, progress: Progress): Promise<void> {
this._resolve!(parseArgument(params.result));
this._dispose();
}
- async reject(params: channels.BindingCallRejectParams, metadata: CallMetadata): Promise<void> {
+ async reject(params: channels.BindingCallRejectParams, progress: Progress): Promise<void> {
this._reject!(parseError(params.error));
this._dispose();
}
diff --git a/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts b/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
index 975f2d2082..2e59886335 100644
--- a/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
@@ -28,6 +28,7 @@ import type { DispatcherConnection } from './dispatcher';
import type { Frame } from '../frames';
import type * as ws from '@injected/webSocketMock';
import type * as channels from '@protocol/channels';
+import type { Progress } from '@protocol/progress';
export class WebSocketRouteDispatcher extends Dispatcher<SdkObject, channels.WebSocketRouteChannel, PageDispatcher | BrowserContextDispatcher> implements channels.WebSocketRouteChannel {
_type_WebSocketRoute = true;
@@ -57,11 +58,11 @@ export class WebSocketRouteDispatcher extends Dispatcher<SdkObject, channels.Web
(scope as any)._dispatchEvent('webSocketRoute', { webSocketRoute: this });
}
- static async installIfNeeded(connection: DispatcherConnection, target: Page | BrowserContext) {
+ static async installIfNeeded(progress: Progress, connection: DispatcherConnection, target: Page | BrowserContext) {
const kBindingName = '__pwWebSocketBinding';
const context = target instanceof Page ? target.browserContext : target;
if (!context.hasBinding(kBindingName)) {
- await context.exposeBinding(kBindingName, false, (source, payload: ws.BindingPayload) => {
+ await context.exposeBinding(progress, kBindingName, false, (source, payload: ws.BindingPayload) => {
if (payload.type === 'onCreate') {
const contextDispatcher = connection.existingDispatcher<BrowserContextDispatcher>(context);
const pageDispatcher = contextDispatcher ? PageDispatcher.fromNullable(contextDispatcher, source.page) : undefined;
@@ -93,7 +94,7 @@ export class WebSocketRouteDispatcher extends Dispatcher<SdkObject, channels.Web
const kInitScriptName = 'webSocketMockSource';
if (!target.initScripts.find(s => s.name === kInitScriptName)) {
- await target.addInitScript(`
+ await target.addInitScript(progress, `
(() => {
const module = {};
${rawWebSocketMockSource.source}
diff --git a/packages/playwright-core/src/server/dom.ts b/packages/playwright-core/src/server/dom.ts
index 89cc1dc01a..ac2a88aff0 100644
--- a/packages/playwright-core/src/server/dom.ts
+++ b/packages/playwright-core/src/server/dom.ts
@@ -507,7 +507,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(progress, 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(progress: Progress, options: { noWaitAfter?: boolean } & types.MouseClickOptions & types.PointerActionWaitOptions): Promise<void> {
@@ -517,7 +517,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(progress, 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(progress: Progress, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions): Promise<void> {
@@ -527,7 +527,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._click(progress, point.x, point.y, { ...options, clickCount: 2 }), { ...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(progress: Progress, options: types.PointerActionWaitOptions): Promise<void> {
@@ -537,7 +537,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(progress, 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(progress: Progress, elements: ElementHandle[], values: types.SelectOption[], options: types.CommonActionOptions): Promise<string[]> {
@@ -595,9 +595,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}, { value, force: options.force }));
if (result === 'needsinput') {
if (value)
- await this._page.keyboard._insertText(progress, value);
+ await this._page.keyboard.insertText(progress, value);
else
- await this._page.keyboard._press(progress, 'Delete');
+ await this._page.keyboard.press(progress, 'Delete');
return 'done';
} else {
return result;
@@ -694,7 +694,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
if (result !== 'done')
return result;
- await this._page.keyboard._type(progress, text, options);
+ await this._page.keyboard.type(progress, text, options);
return 'done';
}
@@ -711,7 +711,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
if (result !== 'done')
return result;
- await this._page.keyboard._press(progress, key, options);
+ await this._page.keyboard.press(progress, key, options);
return 'done';
});
}
diff --git a/packages/playwright-core/src/server/firefox/ffBrowser.ts b/packages/playwright-core/src/server/firefox/ffBrowser.ts
index 4b529d0ad8..577ec2ac80 100644
--- a/packages/playwright-core/src/server/firefox/ffBrowser.ts
+++ b/packages/playwright-core/src/server/firefox/ffBrowser.ts
@@ -217,13 +217,13 @@ export class FFBrowserContext extends BrowserContext {
if (this._options.timezoneId)
promises.push(this._browser.session.send('Browser.setTimezoneOverride', { browserContextId, timezoneId: this._options.timezoneId }));
if (this._options.extraHTTPHeaders || this._options.locale)
- promises.push(this.setExtraHTTPHeaders(this._options.extraHTTPHeaders || []));
+ promises.push(this.doUpdateExtraHTTPHeaders());
if (this._options.httpCredentials)
promises.push(this.setHTTPCredentials(this._options.httpCredentials));
if (this._options.geolocation)
promises.push(this.setGeolocation(this._options.geolocation));
if (this._options.offline)
- promises.push(this.setOffline(this._options.offline));
+ promises.push(this.doUpdateOffline());
if (this._options.colorScheme !== 'no-override') {
promises.push(this._browser.session.send('Browser.setColorScheme', {
browserContextId,
@@ -359,9 +359,8 @@ export class FFBrowserContext extends BrowserContext {
await this._browser.session.send('Browser.setGeolocationOverride', { browserContextId: this._browserContextId, geolocation: geolocation || null });
}
- async setExtraHTTPHeaders(headers: types.HeadersArray): Promise<void> {
- this._options.extraHTTPHeaders = headers;
- let allHeaders = this._options.extraHTTPHeaders;
+ async doUpdateExtraHTTPHeaders(): Promise<void> {
+ let allHeaders = this._options.extraHTTPHeaders || [];
if (this._options.locale)
allHeaders = network.mergeHeaders([allHeaders, network.singleHeader('Accept-Language', this._options.locale)]);
await this._browser.session.send('Browser.setExtraHTTPHeaders', { browserContextId: this._browserContextId, headers: allHeaders });
@@ -371,9 +370,8 @@ export class FFBrowserContext extends BrowserContext {
await this._browser.session.send('Browser.setUserAgentOverride', { browserContextId: this._browserContextId, userAgent: userAgent || null });
}
- async setOffline(offline: boolean): Promise<void> {
- this._options.offline = offline;
- await this._browser.session.send('Browser.setOnlineOverride', { browserContextId: this._browserContextId, override: offline ? 'offline' : 'online' });
+ async doUpdateOffline(): Promise<void> {
+ await this._browser.session.send('Browser.setOnlineOverride', { browserContextId: this._browserContextId, override: this._options.offline ? 'offline' : 'online' });
}
async doSetHTTPCredentials(httpCredentials?: types.Credentials): Promise<void> {
diff --git a/packages/playwright-core/src/server/frames.ts b/packages/playwright-core/src/server/frames.ts
index c8dfa9999c..86fd824eb7 100644
--- a/packages/playwright-core/src/server/frames.ts
+++ b/packages/playwright-core/src/server/frames.ts
@@ -669,7 +669,7 @@ export class Frame extends SdkObject {
return response;
}
- async _waitForNavigation(progress: Progress, requiresNewDocument: boolean, options: Omit<types.NavigateOptions, 'timeout'>): Promise<network.Response | null> {
+ async _waitForNavigation(progress: Progress, requiresNewDocument: boolean, options: types.NavigateOptions): Promise<network.Response | null> {
const waitUntil = verifyLifecycle('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
progress.log(`waiting for navigation until "${waitUntil}"`);
@@ -859,7 +859,7 @@ export class Frame extends SdkObject {
}
}
- async setContent(progress: Progress, html: string, options: Omit<types.NavigateOptions, 'timeout'>): Promise<void> {
+ async setContent(progress: Progress, html: string, options: types.NavigateOptions): Promise<void> {
await this.raceNavigationAction(progress, async () => {
const waitUntil = options.waitUntil === undefined ? 'load' : options.waitUntil;
progress.log(`setting frame content, waiting until "${waitUntil}"`);
@@ -1138,8 +1138,8 @@ export class Frame extends SdkObject {
async dragAndDrop(progress: Progress, source: string, target: string, options: types.DragActionOptions & types.PointerActionWaitOptions) {
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(progress, point.x, point.y);
- await this._page.mouse._down(progress);
+ await this._page.mouse.move(progress, point.x, point.y);
+ await this._page.mouse.down(progress);
}, {
...options,
waitAfter: 'disabled',
@@ -1149,8 +1149,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(progress, point.x, point.y);
- await this._page.mouse._up(progress);
+ 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 c5c34acb85..bdb17c7c37 100644
--- a/packages/playwright-core/src/server/input.ts
+++ b/packages/playwright-core/src/server/input.ts
@@ -16,9 +16,7 @@
import { assert } from '../utils';
import * as keyboardLayout from './usKeyboardLayout';
-import { ProgressController } from './progress';
-import type { CallMetadata } from '@protocol/callMetadata';
import type { Progress } from './progress';
import type { Page } from './page';
import type * as types from './types';
@@ -54,12 +52,7 @@ export class Keyboard {
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(progress: Progress, 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);
@@ -81,12 +74,7 @@ export class Keyboard {
return description;
}
- 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) {
+ 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);
@@ -94,39 +82,24 @@ export class Keyboard {
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) {
+ async insertText(progress: Progress, text: string) {
await this._raw.sendText(progress, 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(progress: Progress, 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(progress, char, { delay });
+ await this.press(progress, char, { delay });
} else {
if (delay)
await progress.wait(delay);
- await this._insertText(progress, char);
+ await this.insertText(progress, char);
}
}
}
- 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 } = {}) {
+ async press(progress: Progress, key: string, options: { delay?: number } = {}) {
function split(keyString: string) {
const keys = [];
let building = '';
@@ -145,13 +118,13 @@ export class Keyboard {
const tokens = split(key);
key = tokens[tokens.length - 1];
for (let i = 0; i < tokens.length - 1; ++i)
- await this._down(progress, tokens[i]);
- await this._down(progress, key);
+ await this.down(progress, tokens[i]);
+ await this.down(progress, key);
if (options.delay)
await progress.wait(options.delay);
- await this._up(progress, key);
+ await this.up(progress, key);
for (let i = tokens.length - 2; i >= 0; --i)
- await this._up(progress, tokens[i]);
+ await this.up(progress, tokens[i]);
}
async ensureModifiers(progress: Progress, mm: types.SmartKeyboardModifier[]): Promise<types.KeyboardModifier[]> {
@@ -165,9 +138,9 @@ export class Keyboard {
const needDown = modifiers.includes(key);
const isDown = this._pressedModifiers.has(key);
if (needDown && !isDown)
- await this._down(progress, key);
+ await this.down(progress, key);
else if (!needDown && isDown)
- await this._up(progress, key);
+ await this.up(progress, key);
}
return restore;
}
@@ -213,12 +186,7 @@ export class Mouse {
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 } = {}) {
+ 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;
@@ -231,62 +199,44 @@ export class Mouse {
}
}
- 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 } = {}) {
+ 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(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
}
- 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 } = {}) {
+ 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(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(progress: Progress, x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number } = {}) {
+ 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(progress, x, y, { forClick: true });
+ this.move(progress, x, y, { forClick: true });
for (let cc = 1; cc <= clickCount; ++cc) {
- await this._down(progress, { ...options, clickCount: cc });
+ await this.down(progress, { ...options, clickCount: cc });
await progress.wait(delay);
- await this._up(progress, { ...options, clickCount: cc });
+ await this.up(progress, { ...options, clickCount: cc });
if (cc < clickCount)
await progress.wait(delay);
}
} else {
const promises = [];
- promises.push(this._move(progress, x, y, { forClick: true }));
+ promises.push(this.move(progress, x, y, { forClick: true }));
for (let cc = 1; cc <= clickCount; ++cc) {
- promises.push(this._down(progress, { ...options, clickCount: cc }));
- promises.push(this._up(progress, { ...options, clickCount: cc }));
+ promises.push(this.down(progress, { ...options, clickCount: cc }));
+ promises.push(this.up(progress, { ...options, clickCount: cc }));
}
await Promise.all(promises);
}
}
- 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);
- });
+ async wheel(progress: Progress, deltaX: number, deltaY: number) {
+ await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
}
}
@@ -363,12 +313,7 @@ export class Touchscreen {
this._page = page;
}
- 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) {
+ 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(progress, x, y, this._page.keyboard._modifiers());
diff --git a/packages/playwright-core/src/server/launchApp.ts b/packages/playwright-core/src/server/launchApp.ts
index 3b3bcda5bf..cdf0809b64 100644
--- a/packages/playwright-core/src/server/launchApp.ts
+++ b/packages/playwright-core/src/server/launchApp.ts
@@ -21,6 +21,7 @@ import { isUnderTest } from '../utils';
import { serverSideCallMetadata } from './instrumentation';
import { findChromiumChannel } from './registry';
import { registryDirectory } from './registry';
+import { ProgressController } from './progress';
import type { BrowserType } from './browserType';
import type { CRPage } from './chromium/crPage';
@@ -86,23 +87,27 @@ export async function syncLocalStorageWithSettings(page: Page, appName: string)
if (isUnderTest())
return;
const settingsFile = path.join(registryDirectory, '.settings', `${appName}.json`);
- await page.exposeBinding('_saveSerializedSettings', false, (_, settings) => {
- fs.mkdirSync(path.dirname(settingsFile), { recursive: true });
- fs.writeFileSync(settingsFile, settings);
- });
- const settings = await fs.promises.readFile(settingsFile, 'utf-8').catch(() => ('{}'));
- await page.addInitScript(
- `(${String((settings: any) => {
- // iframes w/ snapshots, etc.
- if (location && location.protocol === 'data:')
- return;
- if (window.top !== window)
- return;
- Object.entries(settings).map(([k, v]) => localStorage[k] = v);
- (window as any).saveSettings = () => {
- (window as any)._saveSerializedSettings(JSON.stringify({ ...localStorage }));
- };
- })})(${settings});
- `);
+ const controller = new ProgressController(serverSideCallMetadata(), page);
+ await controller.run(async progress => {
+ await page.exposeBinding(progress, '_saveSerializedSettings', false, (_, settings) => {
+ fs.mkdirSync(path.dirname(settingsFile), { recursive: true });
+ fs.writeFileSync(settingsFile, settings);
+ });
+
+ const settings = await fs.promises.readFile(settingsFile, 'utf-8').catch(() => ('{}'));
+ await page.addInitScript(progress,
+ `(${String((settings: any) => {
+ // iframes w/ snapshots, etc.
+ if (location && location.protocol === 'data:')
+ return;
+ if (window.top !== window)
+ return;
+ Object.entries(settings).map(([k, v]) => localStorage[k] = v);
+ (window as any).saveSettings = () => {
+ (window as any)._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+ };
+ })})(${settings});
+ `);
+ });
}
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index 2570793a9d..dd3dae03d1 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -25,7 +25,6 @@ import { helper } from './helper';
import * as input from './input';
import { SdkObject } from './instrumentation';
import * as js from './javascript';
-import { ProgressController } from './progress';
import { Screenshotter, validateScreenshotOptions } from './screenshotter';
import { LongStandingScope, assert, renderTitleForCall, trimStringWithEllipsis } from '../utils';
import { asLocator } from '../utils';
@@ -39,7 +38,6 @@ import * as rawBindingsControllerSource from '../generated/bindingsControllerSou
import type { Artifact } from './artifact';
import type * as dom from './dom';
-import type { CallMetadata } from './instrumentation';
import type * as network from './network';
import type { Progress } from './progress';
import type { ScreenshotOptions } from './screenshotter';
@@ -320,16 +318,17 @@ export class Page extends SdkObject {
return this.frameManager.frames();
}
- async exposeBinding(name: string, needsHandle: boolean, playwrightBinding: frames.FunctionWithSource): Promise<PageBinding> {
+ async exposeBinding(progress: Progress, name: string, needsHandle: boolean, playwrightBinding: frames.FunctionWithSource): Promise<PageBinding> {
if (this._pageBindings.has(name))
throw new Error(`Function "${name}" has been already registered`);
if (this.browserContext._pageBindings.has(name))
throw new Error(`Function "${name}" has been already registered in the browser context`);
- await this.browserContext.exposePlaywrightBindingIfNeeded();
+ await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
const binding = new PageBinding(name, playwrightBinding, needsHandle);
this._pageBindings.set(name, binding);
- await this.delegate.addInitScript(binding.initScript);
- await this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main');
+ progress.cleanupWhenAborted(() => this._pageBindings.delete(name));
+ await progress.race(this.delegate.addInitScript(binding.initScript));
+ await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
return binding;
}
@@ -342,9 +341,14 @@ export class Page extends SdkObject {
await this.safeNonStallingEvaluateInAllFrames(cleanup, 'main');
}
- setExtraHTTPHeaders(headers: types.HeadersArray) {
+ async setExtraHTTPHeaders(progress: Progress, headers: types.HeadersArray) {
+ const oldHeaders = this._extraHTTPHeaders;
this._extraHTTPHeaders = headers;
- return this.delegate.updateExtraHTTPHeaders();
+ progress.cleanupWhenAborted(async () => {
+ this._extraHTTPHeaders = oldHeaders;
+ await this.delegate.updateExtraHTTPHeaders();
+ });
+ await progress.race(this.delegate.updateExtraHTTPHeaders());
}
extraHTTPHeaders(): types.HeadersArray | undefined {
@@ -367,9 +371,8 @@ export class Page extends SdkObject {
this.emitOnContextOnceInitialized(BrowserContext.Events.Console, message);
}
- async reload(metadata: CallMetadata, options: types.NavigateOptions): Promise<network.Response | null> {
- const controller = new ProgressController(metadata, this);
- return controller.run(progress => this.mainFrame().raceNavigationAction(progress, async () => {
+ async reload(progress: Progress, options: types.NavigateOptions): Promise<network.Response | null> {
+ return this.mainFrame().raceNavigationAction(progress, async () => {
// Note: waitForNavigation may fail before we get response to reload(),
// so we should await it immediately.
const [response] = await Promise.all([
@@ -378,12 +381,11 @@ export class Page extends SdkObject {
progress.race(this.delegate.reload()),
]);
return response;
- }), options.timeout);
+ });
}
- async goBack(metadata: CallMetadata, options: types.NavigateOptions): Promise<network.Response | null> {
- const controller = new ProgressController(metadata, this);
- return controller.run(progress => this.mainFrame().raceNavigationAction(progress, async () => {
+ async goBack(progress: Progress, options: types.NavigateOptions): Promise<network.Response | null> {
+ return this.mainFrame().raceNavigationAction(progress, async () => {
// Note: waitForNavigation may fail before we get response to goBack,
// so we should catch it immediately.
let error: Error | undefined;
@@ -400,12 +402,11 @@ export class Page extends SdkObject {
if (error)
throw error;
return response;
- }), options.timeout);
+ });
}
- async goForward(metadata: CallMetadata, options: types.NavigateOptions): Promise<network.Response | null> {
- const controller = new ProgressController(metadata, this);
- return controller.run(progress => this.mainFrame().raceNavigationAction(progress, async () => {
+ async goForward(progress: Progress, options: types.NavigateOptions): Promise<network.Response | null> {
+ return this.mainFrame().raceNavigationAction(progress, async () => {
// Note: waitForNavigation may fail before we get response to goForward,
// so we should catch it immediately.
let error: Error | undefined;
@@ -422,7 +423,7 @@ export class Page extends SdkObject {
if (error)
throw error;
return response;
- }), options.timeout);
+ });
}
requestGC(): Promise<void> {
@@ -500,7 +501,13 @@ export class Page extends SdkObject {
}
}
- async emulateMedia(options: Partial<EmulatedMedia>) {
+ async emulateMedia(progress: Progress, options: Partial<EmulatedMedia>) {
+ const oldEmulatedMedia = { ...this._emulatedMedia };
+ progress.cleanupWhenAborted(async () => {
+ this._emulatedMedia = oldEmulatedMedia;
+ await this.delegate.updateEmulateMedia();
+ });
+
if (options.media !== undefined)
this._emulatedMedia.media = options.media;
if (options.colorScheme !== undefined)
@@ -512,7 +519,7 @@ export class Page extends SdkObject {
if (options.contrast !== undefined)
this._emulatedMedia.contrast = options.contrast;
- await this.delegate.updateEmulateMedia();
+ await progress.race(this.delegate.updateEmulateMedia());
}
emulatedMedia(): EmulatedMedia {
@@ -526,9 +533,15 @@ export class Page extends SdkObject {
};
}
- async setViewportSize(viewportSize: types.Size) {
+ async setViewportSize(progress: Progress, viewportSize: types.Size) {
+ const oldEmulatedSize = this._emulatedSize;
+ progress.cleanupWhenAborted(async () => {
+ this._emulatedSize = oldEmulatedSize;
+ await this.delegate.updateEmulatedViewportSize();
+ });
+
this._setEmulatedSize({ viewport: { ...viewportSize }, screen: { ...viewportSize } });
- await this.delegate.updateEmulatedViewportSize();
+ await progress.race(this.delegate.updateEmulatedViewportSize());
}
setEmulatedSizeFromWindowOpen(emulatedSize: EmulatedSize) {
@@ -551,10 +564,11 @@ export class Page extends SdkObject {
await this.delegate.bringToFront();
}
- async addInitScript(source: string, name?: string) {
+ async addInitScript(progress: Progress, source: string, name?: string) {
const initScript = new InitScript(source, name);
this.initScripts.push(initScript);
- await this.delegate.addInitScript(initScript);
+ progress.cleanupWhenAborted(() => this.removeInitScripts([initScript]));
+ await progress.race(this.delegate.addInitScript(initScript));
return initScript;
}
@@ -568,7 +582,8 @@ export class Page extends SdkObject {
return this.requestInterceptors.length > 0 || this.browserContext.requestInterceptors.length > 0;
}
- async addRequestInterceptor(handler: network.RouteHandler, prepend?: 'prepend'): Promise<void> {
+ async addRequestInterceptor(progress: Progress, handler: network.RouteHandler, prepend?: 'prepend'): Promise<void> {
+ // Note: progress is intentionally ignored, because this operation is not cancellable and should not block in the browser anyway.
if (prepend)
this.requestInterceptors.unshift(handler);
else
@@ -585,18 +600,17 @@ export class Page extends SdkObject {
await this.delegate.updateRequestInterception();
}
- async expectScreenshot(metadata: CallMetadata, options: ExpectScreenshotOptions): Promise<{ actual?: Buffer, previous?: Buffer, diff?: Buffer, errorMessage?: string, log?: string[] }> {
+ async expectScreenshot(progress: Progress, options: ExpectScreenshotOptions): Promise<{ actual?: Buffer, previous?: Buffer, diff?: Buffer, errorMessage?: string, log?: string[], timedOut?: boolean }> {
const locator = options.locator;
- const rafrafScreenshot = locator ? async (progress: Progress, timeout: number) => {
+ const rafrafScreenshot = locator ? async (timeout: number) => {
return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
- } : async (progress: Progress, timeout: number) => {
+ } : async (timeout: number) => {
await this.performActionPreChecks(progress);
await this.mainFrame().rafrafTimeout(progress, timeout);
return await this.screenshotter.screenshotPage(progress, options || {});
};
const comparator = getComparator('image/png');
- const controller = new ProgressController(metadata, this);
if (!options.expected && options.isNot)
return { errorMessage: '"not" matcher requires expected result' };
try {
@@ -611,7 +625,7 @@ export class Page extends SdkObject {
previous?: Buffer,
errorMessage: string,
diff?: Buffer,
- } | undefined = undefined;
+ } | undefined;
const areEqualScreenshots = (actual: Buffer | undefined, expected: Buffer | undefined, previous: Buffer | undefined) => {
const comparatorResult = actual && expected ? comparator(actual, expected, options) : undefined;
if (comparatorResult !== undefined && !!comparatorResult === !!options.isNot)
@@ -620,12 +634,11 @@ export class Page extends SdkObject {
intermediateResult = { errorMessage: comparatorResult.errorMessage, diff: comparatorResult.diff, actual, previous };
return false;
};
- const callTimeout = options.timeout;
- return controller.run(async progress => {
+ try {
let actual: Buffer | undefined;
let previous: Buffer | undefined;
const pollIntervals = [0, 100, 250, 500];
- progress.log(`${renderTitleForCall(metadata)}${callTimeout ? ` with timeout ${callTimeout}ms` : ''}`);
+ progress.log(`${renderTitleForCall(progress.metadata)}${options.timeout ? ` with timeout ${options.timeout}ms` : ''}`);
if (options.expected)
progress.log(` verifying given screenshot expectation`);
else
@@ -638,7 +651,7 @@ export class Page extends SdkObject {
if (screenshotTimeout)
progress.log(`waiting ${screenshotTimeout}ms before taking screenshot`);
previous = actual;
- actual = await rafrafScreenshot(progress, screenshotTimeout).catch(e => {
+ actual = await rafrafScreenshot(screenshotTimeout).catch(e => {
if (this.mainFrame().isNonRetriableError(e))
throw e;
progress.log(`failed to take screenshot - ` + e.message);
@@ -671,7 +684,7 @@ export class Page extends SdkObject {
return {};
}
throw new Error(intermediateResult!.errorMessage);
- }, callTimeout).catch(e => {
+ } catch (e) {
// Q: Why not throw upon isNonRetriableError(e) as in other places?
// A: We want user to receive a friendly diff between actual and expected/previous.
if (js.isJavaScriptErrorInEvaluate(e) || isInvalidSelectorError(e))
@@ -680,19 +693,16 @@ export class Page extends SdkObject {
if (e instanceof TimeoutError && intermediateResult?.previous)
errorMessage = `Failed to take two consecutive stable screenshots.`;
return {
- log: compressCallLog(e.message ? [...metadata.log, e.message] : metadata.log),
+ log: compressCallLog(e.message ? [...progress.metadata.log, e.message] : progress.metadata.log),
...intermediateResult,
errorMessage,
timedOut: (e instanceof TimeoutError),
};
- });
+ }
}
- async screenshot(metadata: CallMetadata, options: ScreenshotOptions & types.TimeoutOptions): Promise<Buffer> {
- const controller = new ProgressController(metadata, this);
- return controller.run(
- progress => this.screenshotter.screenshotPage(progress, options),
- options.timeout);
+ async screenshot(progress: Progress, options: ScreenshotOptions): Promise<Buffer> {
+ return await this.screenshotter.screenshotPage(progress, options);
}
async close(options: { runBeforeUnload?: boolean, reason?: string } = {}) {
@@ -808,13 +818,10 @@ export class Page extends SdkObject {
this._isServerSideOnly = true;
}
- snapshotForAI(metadata: CallMetadata): Promise<string> {
- const controller = new ProgressController(metadata, this);
- return controller.run(async progress => {
- this.lastSnapshotFrameIds = [];
- const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);
- return snapshot.join('\n');
- });
+ async snapshotForAI(progress: Progress): Promise<string> {
+ this.lastSnapshotFrameIds = [];
+ const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);
+ return snapshot.join('\n');
}
}
diff --git a/packages/playwright-core/src/server/recorder.ts b/packages/playwright-core/src/server/recorder.ts
index bc3a5b7500..fb3782e415 100644
--- a/packages/playwright-core/src/server/recorder.ts
+++ b/packages/playwright-core/src/server/recorder.ts
@@ -23,6 +23,8 @@ import { ContextRecorder, generateFrameSelector } from './recorder/contextRecord
import { buildFullSelector, metadataToCallLog } from './recorder/recorderUtils';
import { locatorOrSelectorAsSelector } from '../utils/isomorphic/locatorParser';
import { stringifySelector } from '../utils/isomorphic/selectorParser';
+import { ProgressController } from './progress';
+import { serverSideCallMetadata } from './instrumentation';
import type { Language } from './codegen/types';
import type { Frame } from './frames';
@@ -158,52 +160,55 @@ export class Recorder implements InstrumentationListener, IRecorder {
this._pushAllSources();
});
- await this._context.exposeBinding('__pw_recorderState', false, async source => {
- let actionSelector: string | undefined;
- let actionPoint: Point | undefined;
- const hasActiveScreenshotCommand = [...this._currentCallsMetadata.keys()].some(isScreenshotCommand);
- if (!hasActiveScreenshotCommand) {
- actionSelector = await this._scopeHighlightedSelectorToFrame(source.frame);
- for (const [metadata, sdkObject] of this._currentCallsMetadata) {
- if (source.page === sdkObject.attribution.page) {
- actionPoint = metadata.point || actionPoint;
- actionSelector = actionSelector || metadata.params.selector;
+ const controller = new ProgressController(serverSideCallMetadata(), this._context);
+ await controller.run(async progress => {
+ await this._context.exposeBinding(progress, '__pw_recorderState', false, async source => {
+ let actionSelector: string | undefined;
+ let actionPoint: Point | undefined;
+ const hasActiveScreenshotCommand = [...this._currentCallsMetadata.keys()].some(isScreenshotCommand);
+ if (!hasActiveScreenshotCommand) {
+ actionSelector = await this._scopeHighlightedSelectorToFrame(source.frame);
+ for (const [metadata, sdkObject] of this._currentCallsMetadata) {
+ if (source.page === sdkObject.attribution.page) {
+ actionPoint = metadata.point || actionPoint;
+ actionSelector = actionSelector || metadata.params.selector;
+ }
}
}
- }
- const uiState: UIState = {
- mode: this._mode,
- actionPoint,
- actionSelector,
- ariaTemplate: this._highlightedElement.ariaTemplate,
- language: this._currentLanguage,
- testIdAttributeName: this._contextRecorder.testIdAttributeName(),
- overlay: this._overlayState,
- };
- return uiState;
- });
-
- await this._context.exposeBinding('__pw_recorderElementPicked', false, async ({ frame }, elementInfo: ElementInfo) => {
- const selectorChain = await generateFrameSelector(frame);
- await this._recorderApp?.elementPicked({ selector: buildFullSelector(selectorChain, elementInfo.selector), ariaSnapshot: elementInfo.ariaSnapshot }, true);
- });
-
- await this._context.exposeBinding('__pw_recorderSetMode', false, async ({ frame }, mode: Mode) => {
- if (frame.parentFrame())
- return;
- this.setMode(mode);
- });
-
- await this._context.exposeBinding('__pw_recorderSetOverlayState', false, async ({ frame }, state: OverlayState) => {
- if (frame.parentFrame())
- return;
- this._overlayState = state;
- });
-
- await this._context.exposeBinding('__pw_resume', false, () => {
- this._debugger.resume(false);
+ const uiState: UIState = {
+ mode: this._mode,
+ actionPoint,
+ actionSelector,
+ ariaTemplate: this._highlightedElement.ariaTemplate,
+ language: this._currentLanguage,
+ testIdAttributeName: this._contextRecorder.testIdAttributeName(),
+ overlay: this._overlayState,
+ };
+ return uiState;
+ });
+
+ await this._context.exposeBinding(progress, '__pw_recorderElementPicked', false, async ({ frame }, elementInfo: ElementInfo) => {
+ const selectorChain = await generateFrameSelector(frame);
+ await this._recorderApp?.elementPicked({ selector: buildFullSelector(selectorChain, elementInfo.selector), ariaSnapshot: elementInfo.ariaSnapshot }, true);
+ });
+
+ await this._context.exposeBinding(progress, '__pw_recorderSetMode', false, async ({ frame }, mode: Mode) => {
+ if (frame.parentFrame())
+ return;
+ this.setMode(mode);
+ });
+
+ await this._context.exposeBinding(progress, '__pw_recorderSetOverlayState', false, async ({ frame }, state: OverlayState) => {
+ if (frame.parentFrame())
+ return;
+ this._overlayState = state;
+ });
+
+ await this._context.exposeBinding(progress, '__pw_resume', false, () => {
+ this._debugger.resume(false);
+ });
+ await this._contextRecorder.install(progress);
});
- await this._contextRecorder.install();
if (this._debugger.isPaused())
this._pausedStateChanged();
diff --git a/packages/playwright-core/src/server/recorder/contextRecorder.ts b/packages/playwright-core/src/server/recorder/contextRecorder.ts
index ed2aa6202b..f83e8fab25 100644
--- a/packages/playwright-core/src/server/recorder/contextRecorder.ts
+++ b/packages/playwright-core/src/server/recorder/contextRecorder.ts
@@ -32,6 +32,7 @@ import type { Language, LanguageGenerator, LanguageGeneratorOptions } from '../c
import type * as channels from '@protocol/channels';
import type * as actions from '@recorder/actions';
import type { Source } from '@recorder/recorderTypes';
+import type { Progress } from '@protocol/progress';
type BindingSource = { frame: Frame, page: Page };
@@ -130,7 +131,7 @@ export class ContextRecorder extends EventEmitter {
return 'javascript';
}
- async install() {
+ async install(progress: Progress) {
this._context.on(BrowserContext.Events.Page, (page: Page) => this._onPage(page));
for (const page of this._context.pages())
this._onPage(page);
@@ -142,11 +143,11 @@ export class ContextRecorder extends EventEmitter {
// Input actions that potentially lead to navigation are intercepted on the page and are
// performed by the Playwright.
- await this._context.exposeBinding('__pw_recorderPerformAction', false,
+ await this._context.exposeBinding(progress, '__pw_recorderPerformAction', false,
(source: BindingSource, action: actions.PerformOnRecordAction) => this._performAction(source.frame, action));
// Other non-essential actions are simply being recorded.
- await this._context.exposeBinding('__pw_recorderRecordAction', false,
+ await this._context.exposeBinding(progress, '__pw_recorderRecordAction', false,
(source: BindingSource, action: actions.Action) => this._recordAction(source.frame, action));
await this._context.extendInjectedScript(rawRecorderSource.source);
diff --git a/packages/playwright-core/src/server/recorder/recorderApp.ts b/packages/playwright-core/src/server/recorder/recorderApp.ts
index a4862fb2fe..cc86c27de3 100644
--- a/packages/playwright-core/src/server/recorder/recorderApp.ts
+++ b/packages/playwright-core/src/server/recorder/recorderApp.ts
@@ -63,36 +63,37 @@ export class RecorderApp extends EventEmitter implements IRecorderApp {
private async _init() {
await syncLocalStorageWithSettings(this._page, 'recorder');
- await this._page.addRequestInterceptor(route => {
- if (!route.request().url().startsWith('https://playwright/')) {
- route.continue({ isFallback: true }).catch(() => {});
- return;
- }
-
- const uri = route.request().url().substring('https://playwright/'.length);
- const file = require.resolve('../../vite/recorder/' + uri);
- fs.promises.readFile(file).then(buffer => {
- route.fulfill({
- status: 200,
- headers: [
- { name: 'Content-Type', value: mime.getType(path.extname(file)) || 'application/octet-stream' }
- ],
- body: buffer.toString('base64'),
- isBase64: true
- }).catch(() => {});
+ const controller = new ProgressController(serverSideCallMetadata(), this._page);
+ await controller.run(async progress => {
+ await this._page.addRequestInterceptor(progress, route => {
+ if (!route.request().url().startsWith('https://playwright/')) {
+ route.continue({ isFallback: true }).catch(() => {});
+ return;
+ }
+
+ const uri = route.request().url().substring('https://playwright/'.length);
+ const file = require.resolve('../../vite/recorder/' + uri);
+ fs.promises.readFile(file).then(buffer => {
+ route.fulfill({
+ status: 200,
+ headers: [
+ { name: 'Content-Type', value: mime.getType(path.extname(file)) || 'application/octet-stream' }
+ ],
+ body: buffer.toString('base64'),
+ isBase64: true
+ }).catch(() => {});
+ });
});
- });
- await this._page.exposeBinding('dispatch', false, (_, data: any) => this.emit('event', data));
+ await this._page.exposeBinding(progress, 'dispatch', false, (_, data: any) => this.emit('event', data));
- this._page.once('close', () => {
- this.emit('close');
- this._page.browserContext.close({ reason: 'Recorder window closed' }).catch(() => {});
- });
+ this._page.once('close', () => {
+ this.emit('close');
+ this._page.browserContext.close({ reason: 'Recorder window closed' }).catch(() => {});
+ });
- const mainFrame = this._page.mainFrame();
- const controller = new ProgressController(serverSideCallMetadata(), mainFrame);
- await controller.run(progress => mainFrame.goto(progress, process.env.PW_HMR ? 'http://localhost:44225' : 'https://playwright/index.html'));
+ await this._page.mainFrame().goto(progress, process.env.PW_HMR ? 'http://localhost:44225' : 'https://playwright/index.html');
+ });
}
static factory(context: BrowserContext): IRecorderAppFactory {
diff --git a/packages/playwright-core/src/server/trace/recorder/snapshotter.ts b/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
index dcc04d9402..82e1b99936 100644
--- a/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
+++ b/packages/playwright-core/src/server/trace/recorder/snapshotter.ts
@@ -77,6 +77,7 @@ export class Snapshotter {
async resetForReuse() {
// Next time we start recording, we will call addInitScript again.
if (this._initScript) {
+ eventsHelper.removeEventListeners(this._eventListeners);
await this._context.removeInitScripts([this._initScript]);
this._initScript = undefined;
}
@@ -91,7 +92,7 @@ export class Snapshotter {
const { javaScriptEnabled } = this._context._options;
const initScriptSource = `(${frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === undefined})`;
- this._initScript = await this._context.addInitScript(initScriptSource);
+ this._initScript = await this._context.addInitScript(undefined, initScriptSource);
await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, 'main');
}
diff --git a/packages/playwright-core/src/server/types.ts b/packages/playwright-core/src/server/types.ts
index 50bdec8101..80da3ddd26 100644
--- a/packages/playwright-core/src/server/types.ts
+++ b/packages/playwright-core/src/server/types.ts
@@ -34,7 +34,7 @@ export type WaitForFunctionOptions = TimeoutOptions & { pollingInterval?: number
export type LifecycleEvent = 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
export const kLifecycleEvents: Set<LifecycleEvent> = new Set(['load', 'domcontentloaded', 'networkidle', 'commit']);
-export type NavigateOptions = TimeoutOptions & {
+export type NavigateOptions = {
waitUntil?: LifecycleEvent,
};
@@ -133,7 +133,7 @@ export type MouseMultiClickOptions = PointerActionOptions & {
export type World = 'main' | 'utility';
-export type GotoOptions = Omit<NavigateOptions, 'timeout'> & {
+export type GotoOptions = NavigateOptions & {
referer?: string,
};
diff --git a/packages/playwright-core/src/server/webkit/wkBrowser.ts b/packages/playwright-core/src/server/webkit/wkBrowser.ts
index aaf4c197a4..68a9d4edfe 100644
--- a/packages/playwright-core/src/server/webkit/wkBrowser.ts
+++ b/packages/playwright-core/src/server/webkit/wkBrowser.ts
@@ -230,7 +230,7 @@ export class WKBrowserContext extends BrowserContext {
if (this._options.geolocation)
promises.push(this.setGeolocation(this._options.geolocation));
if (this._options.offline)
- promises.push(this.setOffline(this._options.offline));
+ promises.push(this.doUpdateOffline());
if (this._options.httpCredentials)
promises.push(this.setHTTPCredentials(this._options.httpCredentials));
await Promise.all(promises);
@@ -308,8 +308,7 @@ export class WKBrowserContext extends BrowserContext {
await this._browser._browserSession.send('Playwright.setGeolocationOverride', { browserContextId: this._browserContextId, geolocation: payload });
}
- async setExtraHTTPHeaders(headers: types.HeadersArray): Promise<void> {
- this._options.extraHTTPHeaders = headers;
+ async doUpdateExtraHTTPHeaders(): Promise<void> {
for (const page of this.pages())
await (page.delegate as WKPage).updateExtraHTTPHeaders();
}
@@ -320,8 +319,7 @@ export class WKBrowserContext extends BrowserContext {
await (page.delegate as WKPage).updateUserAgent();
}
- async setOffline(offline: boolean): Promise<void> {
- this._options.offline = offline;
+ async doUpdateOffline(): Promise<void> {
for (const page of this.pages())
await (page.delegate as WKPage).updateOffline();
}
diff --git a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
index 3c8769d3ad..0f7db29834 100644
--- a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
+++ b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
@@ -311,6 +311,10 @@ export const methodMetainfo = new Map<string, { internal?: boolean, title?: stri
]);
export const progressTypes = new Set<string>([
+ 'BrowserContext',
+ 'Page',
'Frame',
- 'ElementHandle'
+ 'Worker',
+ 'ElementHandle',
+ 'BindingCall'
]);
diff --git a/packages/protocol/src/channels.d.ts b/packages/protocol/src/channels.d.ts
index fa9302563a..459cc1feef 100644
--- a/packages/protocol/src/channels.d.ts
+++ b/packages/protocol/src/channels.d.ts
@@ -1621,38 +1621,38 @@ export interface BrowserContextEventTarget {
}
export interface BrowserContextChannel extends BrowserContextEventTarget, EventTargetChannel {
_type_BrowserContext: boolean;
- addCookies(params: BrowserContextAddCookiesParams, metadata?: CallMetadata): Promise<BrowserContextAddCookiesResult>;
- addInitScript(params: BrowserContextAddInitScriptParams, metadata?: CallMetadata): Promise<BrowserContextAddInitScriptResult>;
- clearCookies(params: BrowserContextClearCookiesParams, metadata?: CallMetadata): Promise<BrowserContextClearCookiesResult>;
- clearPermissions(params?: BrowserContextClearPermissionsParams, metadata?: CallMetadata): Promise<BrowserContextClearPermissionsResult>;
- close(params: BrowserContextCloseParams, metadata?: CallMetadata): Promise<BrowserContextCloseResult>;
- cookies(params: BrowserContextCookiesParams, metadata?: CallMetadata): Promise<BrowserContextCookiesResult>;
- exposeBinding(params: BrowserContextExposeBindingParams, metadata?: CallMetadata): Promise<BrowserContextExposeBindingResult>;
- grantPermissions(params: BrowserContextGrantPermissionsParams, metadata?: CallMetadata): Promise<BrowserContextGrantPermissionsResult>;
- newPage(params?: BrowserContextNewPageParams, metadata?: CallMetadata): Promise<BrowserContextNewPageResult>;
- registerSelectorEngine(params: BrowserContextRegisterSelectorEngineParams, metadata?: CallMetadata): Promise<BrowserContextRegisterSelectorEngineResult>;
- setTestIdAttributeName(params: BrowserContextSetTestIdAttributeNameParams, metadata?: CallMetadata): Promise<BrowserContextSetTestIdAttributeNameResult>;
- setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, metadata?: CallMetadata): Promise<BrowserContextSetExtraHTTPHeadersResult>;
- setGeolocation(params: BrowserContextSetGeolocationParams, metadata?: CallMetadata): Promise<BrowserContextSetGeolocationResult>;
- setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, metadata?: CallMetadata): Promise<BrowserContextSetHTTPCredentialsResult>;
- setNetworkInterceptionPatterns(params: BrowserContextSetNetworkInterceptionPatternsParams, metadata?: CallMetadata): Promise<BrowserContextSetNetworkInterceptionPatternsResult>;
- setWebSocketInterceptionPatterns(params: BrowserContextSetWebSocketInterceptionPatternsParams, metadata?: CallMetadata): Promise<BrowserContextSetWebSocketInterceptionPatternsResult>;
- setOffline(params: BrowserContextSetOfflineParams, metadata?: CallMetadata): Promise<BrowserContextSetOfflineResult>;
- storageState(params: BrowserContextStorageStateParams, metadata?: CallMetadata): Promise<BrowserContextStorageStateResult>;
- pause(params?: BrowserContextPauseParams, metadata?: CallMetadata): Promise<BrowserContextPauseResult>;
- enableRecorder(params: BrowserContextEnableRecorderParams, metadata?: CallMetadata): Promise<BrowserContextEnableRecorderResult>;
- newCDPSession(params: BrowserContextNewCDPSessionParams, metadata?: CallMetadata): Promise<BrowserContextNewCDPSessionResult>;
- harStart(params: BrowserContextHarStartParams, metadata?: CallMetadata): Promise<BrowserContextHarStartResult>;
- harExport(params: BrowserContextHarExportParams, metadata?: CallMetadata): Promise<BrowserContextHarExportResult>;
- createTempFiles(params: BrowserContextCreateTempFilesParams, metadata?: CallMetadata): Promise<BrowserContextCreateTempFilesResult>;
- updateSubscription(params: BrowserContextUpdateSubscriptionParams, metadata?: CallMetadata): Promise<BrowserContextUpdateSubscriptionResult>;
- clockFastForward(params: BrowserContextClockFastForwardParams, metadata?: CallMetadata): Promise<BrowserContextClockFastForwardResult>;
- clockInstall(params: BrowserContextClockInstallParams, metadata?: CallMetadata): Promise<BrowserContextClockInstallResult>;
- clockPauseAt(params: BrowserContextClockPauseAtParams, metadata?: CallMetadata): Promise<BrowserContextClockPauseAtResult>;
- clockResume(params?: BrowserContextClockResumeParams, metadata?: CallMetadata): Promise<BrowserContextClockResumeResult>;
- clockRunFor(params: BrowserContextClockRunForParams, metadata?: CallMetadata): Promise<BrowserContextClockRunForResult>;
- clockSetFixedTime(params: BrowserContextClockSetFixedTimeParams, metadata?: CallMetadata): Promise<BrowserContextClockSetFixedTimeResult>;
- clockSetSystemTime(params: BrowserContextClockSetSystemTimeParams, metadata?: CallMetadata): Promise<BrowserContextClockSetSystemTimeResult>;
+ addCookies(params: BrowserContextAddCookiesParams, progress?: Progress): Promise<BrowserContextAddCookiesResult>;
+ addInitScript(params: BrowserContextAddInitScriptParams, progress?: Progress): Promise<BrowserContextAddInitScriptResult>;
+ clearCookies(params: BrowserContextClearCookiesParams, progress?: Progress): Promise<BrowserContextClearCookiesResult>;
+ clearPermissions(params?: BrowserContextClearPermissionsParams, progress?: Progress): Promise<BrowserContextClearPermissionsResult>;
+ close(params: BrowserContextCloseParams, progress?: Progress): Promise<BrowserContextCloseResult>;
+ cookies(params: BrowserContextCookiesParams, progress?: Progress): Promise<BrowserContextCookiesResult>;
+ exposeBinding(params: BrowserContextExposeBindingParams, progress?: Progress): Promise<BrowserContextExposeBindingResult>;
+ grantPermissions(params: BrowserContextGrantPermissionsParams, progress?: Progress): Promise<BrowserContextGrantPermissionsResult>;
+ newPage(params?: BrowserContextNewPageParams, progress?: Progress): Promise<BrowserContextNewPageResult>;
+ registerSelectorEngine(params: BrowserContextRegisterSelectorEngineParams, progress?: Progress): Promise<BrowserContextRegisterSelectorEngineResult>;
+ setTestIdAttributeName(params: BrowserContextSetTestIdAttributeNameParams, progress?: Progress): Promise<BrowserContextSetTestIdAttributeNameResult>;
+ setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, progress?: Progress): Promise<BrowserContextSetExtraHTTPHeadersResult>;
+ setGeolocation(params: BrowserContextSetGeolocationParams, progress?: Progress): Promise<BrowserContextSetGeolocationResult>;
+ setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, progress?: Progress): Promise<BrowserContextSetHTTPCredentialsResult>;
+ setNetworkInterceptionPatterns(params: BrowserContextSetNetworkInterceptionPatternsParams, progress?: Progress): Promise<BrowserContextSetNetworkInterceptionPatternsResult>;
+ setWebSocketInterceptionPatterns(params: BrowserContextSetWebSocketInterceptionPatternsParams, progress?: Progress): Promise<BrowserContextSetWebSocketInterceptionPatternsResult>;
+ setOffline(params: BrowserContextSetOfflineParams, progress?: Progress): Promise<BrowserContextSetOfflineResult>;
+ storageState(params: BrowserContextStorageStateParams, progress?: Progress): Promise<BrowserContextStorageStateResult>;
+ pause(params?: BrowserContextPauseParams, progress?: Progress): Promise<BrowserContextPauseResult>;
+ enableRecorder(params: BrowserContextEnableRecorderParams, progress?: Progress): Promise<BrowserContextEnableRecorderResult>;
+ newCDPSession(params: BrowserContextNewCDPSessionParams, progress?: Progress): Promise<BrowserContextNewCDPSessionResult>;
+ harStart(params: BrowserContextHarStartParams, progress?: Progress): Promise<BrowserContextHarStartResult>;
+ harExport(params: BrowserContextHarExportParams, progress?: Progress): Promise<BrowserContextHarExportResult>;
+ createTempFiles(params: BrowserContextCreateTempFilesParams, progress?: Progress): Promise<BrowserContextCreateTempFilesResult>;
+ updateSubscription(params: BrowserContextUpdateSubscriptionParams, progress?: Progress): Promise<BrowserContextUpdateSubscriptionResult>;
+ clockFastForward(params: BrowserContextClockFastForwardParams, progress?: Progress): Promise<BrowserContextClockFastForwardResult>;
+ clockInstall(params: BrowserContextClockInstallParams, progress?: Progress): Promise<BrowserContextClockInstallResult>;
+ clockPauseAt(params: BrowserContextClockPauseAtParams, progress?: Progress): Promise<BrowserContextClockPauseAtResult>;
+ clockResume(params?: BrowserContextClockResumeParams, progress?: Progress): Promise<BrowserContextClockResumeResult>;
+ clockRunFor(params: BrowserContextClockRunForParams, progress?: Progress): Promise<BrowserContextClockRunForResult>;
+ clockSetFixedTime(params: BrowserContextClockSetFixedTimeParams, progress?: Progress): Promise<BrowserContextClockSetFixedTimeResult>;
+ clockSetSystemTime(params: BrowserContextClockSetSystemTimeParams, progress?: Progress): Promise<BrowserContextClockSetSystemTimeResult>;
}
export type BrowserContextBindingCallEvent = {
binding: BindingCallChannel,
@@ -2067,43 +2067,43 @@ export interface PageEventTarget {
}
export interface PageChannel extends PageEventTarget, EventTargetChannel {
_type_Page: boolean;
- addInitScript(params: PageAddInitScriptParams, metadata?: CallMetadata): Promise<PageAddInitScriptResult>;
- close(params: PageCloseParams, metadata?: CallMetadata): Promise<PageCloseResult>;
- emulateMedia(params: PageEmulateMediaParams, metadata?: CallMetadata): Promise<PageEmulateMediaResult>;
- exposeBinding(params: PageExposeBindingParams, metadata?: CallMetadata): Promise<PageExposeBindingResult>;
- goBack(params: PageGoBackParams, metadata?: CallMetadata): Promise<PageGoBackResult>;
- goForward(params: PageGoForwardParams, metadata?: CallMetadata): Promise<PageGoForwardResult>;
- requestGC(params?: PageRequestGCParams, metadata?: CallMetadata): Promise<PageRequestGCResult>;
- registerLocatorHandler(params: PageRegisterLocatorHandlerParams, metadata?: CallMetadata): Promise<PageRegisterLocatorHandlerResult>;
- resolveLocatorHandlerNoReply(params: PageResolveLocatorHandlerNoReplyParams, metadata?: CallMetadata): Promise<PageResolveLocatorHandlerNoReplyResult>;
- unregisterLocatorHandler(params: PageUnregisterLocatorHandlerParams, metadata?: CallMetadata): Promise<PageUnregisterLocatorHandlerResult>;
- reload(params: PageReloadParams, metadata?: CallMetadata): Promise<PageReloadResult>;
- expectScreenshot(params: PageExpectScreenshotParams, metadata?: CallMetadata): Promise<PageExpectScreenshotResult>;
- screenshot(params: PageScreenshotParams, metadata?: CallMetadata): Promise<PageScreenshotResult>;
- setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, metadata?: CallMetadata): Promise<PageSetExtraHTTPHeadersResult>;
- setNetworkInterceptionPatterns(params: PageSetNetworkInterceptionPatternsParams, metadata?: CallMetadata): Promise<PageSetNetworkInterceptionPatternsResult>;
- setWebSocketInterceptionPatterns(params: PageSetWebSocketInterceptionPatternsParams, metadata?: CallMetadata): Promise<PageSetWebSocketInterceptionPatternsResult>;
- setViewportSize(params: PageSetViewportSizeParams, metadata?: CallMetadata): Promise<PageSetViewportSizeResult>;
- keyboardDown(params: PageKeyboardDownParams, metadata?: CallMetadata): Promise<PageKeyboardDownResult>;
- keyboardUp(params: PageKeyboardUpParams, metadata?: CallMetadata): Promise<PageKeyboardUpResult>;
- keyboardInsertText(params: PageKeyboardInsertTextParams, metadata?: CallMetadata): Promise<PageKeyboardInsertTextResult>;
- keyboardType(params: PageKeyboardTypeParams, metadata?: CallMetadata): Promise<PageKeyboardTypeResult>;
- keyboardPress(params: PageKeyboardPressParams, metadata?: CallMetadata): Promise<PageKeyboardPressResult>;
- mouseMove(params: PageMouseMoveParams, metadata?: CallMetadata): Promise<PageMouseMoveResult>;
- mouseDown(params: PageMouseDownParams, metadata?: CallMetadata): Promise<PageMouseDownResult>;
- mouseUp(params: PageMouseUpParams, metadata?: CallMetadata): Promise<PageMouseUpResult>;
- mouseClick(params: PageMouseClickParams, metadata?: CallMetadata): Promise<PageMouseClickResult>;
- mouseWheel(params: PageMouseWheelParams, metadata?: CallMetadata): Promise<PageMouseWheelResult>;
- touchscreenTap(params: PageTouchscreenTapParams, metadata?: CallMetadata): Promise<PageTouchscreenTapResult>;
- accessibilitySnapshot(params: PageAccessibilitySnapshotParams, metadata?: CallMetadata): Promise<PageAccessibilitySnapshotResult>;
- pdf(params: PagePdfParams, metadata?: CallMetadata): Promise<PagePdfResult>;
- snapshotForAI(params?: PageSnapshotForAIParams, metadata?: CallMetadata): Promise<PageSnapshotForAIResult>;
- startJSCoverage(params: PageStartJSCoverageParams, metadata?: CallMetadata): Promise<PageStartJSCoverageResult>;
- stopJSCoverage(params?: PageStopJSCoverageParams, metadata?: CallMetadata): Promise<PageStopJSCoverageResult>;
- startCSSCoverage(params: PageStartCSSCoverageParams, metadata?: CallMetadata): Promise<PageStartCSSCoverageResult>;
- stopCSSCoverage(params?: PageStopCSSCoverageParams, metadata?: CallMetadata): Promise<PageStopCSSCoverageResult>;
- bringToFront(params?: PageBringToFrontParams, metadata?: CallMetadata): Promise<PageBringToFrontResult>;
- updateSubscription(params: PageUpdateSubscriptionParams, metadata?: CallMetadata): Promise<PageUpdateSubscriptionResult>;
+ addInitScript(params: PageAddInitScriptParams, progress?: Progress): Promise<PageAddInitScriptResult>;
+ close(params: PageCloseParams, progress?: Progress): Promise<PageCloseResult>;
+ emulateMedia(params: PageEmulateMediaParams, progress?: Progress): Promise<PageEmulateMediaResult>;
+ exposeBinding(params: PageExposeBindingParams, progress?: Progress): Promise<PageExposeBindingResult>;
+ goBack(params: PageGoBackParams, progress?: Progress): Promise<PageGoBackResult>;
+ goForward(params: PageGoForwardParams, progress?: Progress): Promise<PageGoForwardResult>;
+ requestGC(params?: PageRequestGCParams, progress?: Progress): Promise<PageRequestGCResult>;
+ registerLocatorHandler(params: PageRegisterLocatorHandlerParams, progress?: Progress): Promise<PageRegisterLocatorHandlerResult>;
+ resolveLocatorHandlerNoReply(params: PageResolveLocatorHandlerNoReplyParams, progress?: Progress): Promise<PageResolveLocatorHandlerNoReplyResult>;
+ unregisterLocatorHandler(params: PageUnregisterLocatorHandlerParams, progress?: Progress): Promise<PageUnregisterLocatorHandlerResult>;
+ reload(params: PageReloadParams, progress?: Progress): Promise<PageReloadResult>;
+ expectScreenshot(params: PageExpectScreenshotParams, progress?: Progress): Promise<PageExpectScreenshotResult>;
+ screenshot(params: PageScreenshotParams, progress?: Progress): Promise<PageScreenshotResult>;
+ setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, progress?: Progress): Promise<PageSetExtraHTTPHeadersResult>;
+ setNetworkInterceptionPatterns(params: PageSetNetworkInterceptionPatternsParams, progress?: Progress): Promise<PageSetNetworkInterceptionPatternsResult>;
+ setWebSocketInterceptionPatterns(params: PageSetWebSocketInterceptionPatternsParams, progress?: Progress): Promise<PageSetWebSocketInterceptionPatternsResult>;
+ setViewportSize(params: PageSetViewportSizeParams, progress?: Progress): Promise<PageSetViewportSizeResult>;
+ keyboardDown(params: PageKeyboardDownParams, progress?: Progress): Promise<PageKeyboardDownResult>;
+ keyboardUp(params: PageKeyboardUpParams, progress?: Progress): Promise<PageKeyboardUpResult>;
+ keyboardInsertText(params: PageKeyboardInsertTextParams, progress?: Progress): Promise<PageKeyboardInsertTextResult>;
+ keyboardType(params: PageKeyboardTypeParams, progress?: Progress): Promise<PageKeyboardTypeResult>;
+ keyboardPress(params: PageKeyboardPressParams, progress?: Progress): Promise<PageKeyboardPressResult>;
+ mouseMove(params: PageMouseMoveParams, progress?: Progress): Promise<PageMouseMoveResult>;
+ mouseDown(params: PageMouseDownParams, progress?: Progress): Promise<PageMouseDownResult>;
+ mouseUp(params: PageMouseUpParams, progress?: Progress): Promise<PageMouseUpResult>;
+ mouseClick(params: PageMouseClickParams, progress?: Progress): Promise<PageMouseClickResult>;
+ mouseWheel(params: PageMouseWheelParams, progress?: Progress): Promise<PageMouseWheelResult>;
+ touchscreenTap(params: PageTouchscreenTapParams, progress?: Progress): Promise<PageTouchscreenTapResult>;
+ accessibilitySnapshot(params: PageAccessibilitySnapshotParams, progress?: Progress): Promise<PageAccessibilitySnapshotResult>;
+ pdf(params: PagePdfParams, progress?: Progress): Promise<PagePdfResult>;
+ snapshotForAI(params?: PageSnapshotForAIParams, progress?: Progress): Promise<PageSnapshotForAIResult>;
+ startJSCoverage(params: PageStartJSCoverageParams, progress?: Progress): Promise<PageStartJSCoverageResult>;
+ stopJSCoverage(params?: PageStopJSCoverageParams, progress?: Progress): Promise<PageStopJSCoverageResult>;
+ startCSSCoverage(params: PageStartCSSCoverageParams, progress?: Progress): Promise<PageStartCSSCoverageResult>;
+ stopCSSCoverage(params?: PageStopCSSCoverageParams, progress?: Progress): Promise<PageStopCSSCoverageResult>;
+ bringToFront(params?: PageBringToFrontParams, progress?: Progress): Promise<PageBringToFrontResult>;
+ updateSubscription(params: PageUpdateSubscriptionParams, progress?: Progress): Promise<PageUpdateSubscriptionResult>;
}
export type PageBindingCallEvent = {
binding: BindingCallChannel,
@@ -3288,8 +3288,8 @@ export interface WorkerEventTarget {
}
export interface WorkerChannel extends WorkerEventTarget, Channel {
_type_Worker: boolean;
- evaluateExpression(params: WorkerEvaluateExpressionParams, metadata?: CallMetadata): Promise<WorkerEvaluateExpressionResult>;
- evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, metadata?: CallMetadata): Promise<WorkerEvaluateExpressionHandleResult>;
+ evaluateExpression(params: WorkerEvaluateExpressionParams, progress?: Progress): Promise<WorkerEvaluateExpressionResult>;
+ evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, progress?: Progress): Promise<WorkerEvaluateExpressionHandleResult>;
}
export type WorkerCloseEvent = {};
export type WorkerEvaluateExpressionParams = {
@@ -4111,8 +4111,8 @@ export interface BindingCallEventTarget {
}
export interface BindingCallChannel extends BindingCallEventTarget, Channel {
_type_BindingCall: boolean;
- reject(params: BindingCallRejectParams, metadata?: CallMetadata): Promise<BindingCallRejectResult>;
- resolve(params: BindingCallResolveParams, metadata?: CallMetadata): Promise<BindingCallResolveResult>;
+ reject(params: BindingCallRejectParams, progress?: Progress): Promise<BindingCallRejectResult>;
+ resolve(params: BindingCallResolveParams, progress?: Progress): Promise<BindingCallResolveResult>;
}
export type BindingCallRejectParams = {
error: SerializedError,
diff --git a/packages/protocol/src/protocol.yml b/packages/protocol/src/protocol.yml
index 33d0c97f67..63f30e3dbb 100644
--- a/packages/protocol/src/protocol.yml
+++ b/packages/protocol/src/protocol.yml
@@ -1196,6 +1196,7 @@ EventTarget:
BrowserContext:
type: interface
+ progress: true
extends: EventTarget
@@ -1538,6 +1539,7 @@ BrowserContext:
Page:
type: interface
+ progress: true
extends: EventTarget
@@ -2711,6 +2713,7 @@ Frame:
Worker:
type: interface
+ progress: true
initializer:
url: string
@@ -3499,6 +3502,7 @@ WebSocket:
BindingCall:
type: interface
+ progress: true
initializer:
frame: Frame