Skip to content

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

chore: introduce screencast listener (#39520)

Yury Semikhatsky1a9c7e63d650
diff --git a/packages/playwright-core/src/server/chromium/crPage.ts b/packages/playwright-core/src/server/chromium/crPage.ts
index c6d80f63d5..9f56a3b9e5 100644
--- a/packages/playwright-core/src/server/chromium/crPage.ts
+++ b/packages/playwright-core/src/server/chromium/crPage.ts
@@ -886,7 +886,7 @@ class FrameSession {
this._client._sendMayFail('Page.screencastFrameAck', { sessionId: payload.sessionId });
});
const buffer = Buffer.from(payload.data, 'base64');
- this._page.emit(Page.Events.ScreencastFrame, {
+ this._page.screencast.onScreencastFrame({
buffer,
frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1000 : Date.now(),
viewportWidth: payload.metadata.deviceWidth,
diff --git a/packages/playwright-core/src/server/devtoolsController.ts b/packages/playwright-core/src/server/devtoolsController.ts
index 0a85d3498d..ed431eea0a 100644
--- a/packages/playwright-core/src/server/devtoolsController.ts
+++ b/packages/playwright-core/src/server/devtoolsController.ts
@@ -28,6 +28,7 @@ import type { RegisteredListener } from '../utils';
import type { Transport } from './utils/httpServer';
import type { CRBrowser } from './chromium/crBrowser';
import type { ElementInfo } from '@recorder/recorderTypes';
+import type { ScreencastListener } from './screencast';
import type { DevToolsChannel, DevToolsChannelEvents, Tab } from '@devtools/devtoolsChannel';
export class DevToolsController {
@@ -68,7 +69,7 @@ class DevToolsConnection implements Transport, DevToolsChannel {
selectedPage: Page | null = null;
private _lastFrameData: string | null = null;
private _lastViewportSize: { width: number, height: number } | null = null;
- private _pageListeners: RegisteredListener[] = [];
+ private _screencastFrameListener: ScreencastListener | null = null;
private _contextListeners: RegisteredListener[] = [];
private _recorderListeners: RegisteredListener[] = [];
private _context: BrowserContext;
@@ -240,9 +241,8 @@ class DevToolsConnection implements Transport, DevToolsChannel {
return;
if (this.selectedPage) {
- eventsHelper.removeEventListeners(this._pageListeners);
- this._pageListeners = [];
- await this.selectedPage.screencast.stopScreencast(this);
+ await this.selectedPage.screencast.stopScreencast(this._screencastFrameListener!);
+ this._screencastFrameListener = null;
}
this.selectedPage = page;
@@ -250,11 +250,8 @@ class DevToolsConnection implements Transport, DevToolsChannel {
this._lastViewportSize = null;
this._sendTabList();
- this._pageListeners.push(
- eventsHelper.addEventListener(page, Page.Events.ScreencastFrame, frame => this._writeFrame(frame.buffer, frame.width, frame.height))
- );
-
- await page.screencast.startScreencast(this, { width: 1280, height: 800, quality: 90 });
+ this._screencastFrameListener = frame => this._writeFrame(frame.buffer, frame.viewportWidth, frame.viewportHeight);
+ await page.screencast.startScreencast(this._screencastFrameListener, { width: 1280, height: 800, quality: 90 });
}
private async _deselectPage() {
@@ -262,9 +259,9 @@ class DevToolsConnection implements Transport, DevToolsChannel {
return;
const promises = [];
promises.push(this._cancelPicking());
- eventsHelper.removeEventListeners(this._pageListeners);
- this._pageListeners = [];
- promises.push(this.selectedPage.screencast.stopScreencast(this));
+ const screencastFrameListener = this._screencastFrameListener!;
+ this._screencastFrameListener = null;
+ promises.push(this.selectedPage.screencast.stopScreencast(screencastFrameListener));
this.selectedPage = null;
this._lastFrameData = null;
this._lastViewportSize = null;
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 5cdd38b83e..14bd1b0aa0 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -30,7 +30,6 @@ import { SdkObject } from '../instrumentation';
import { deserializeURLMatch, urlMatches } from '../../utils/isomorphic/urlMatch';
import { PageAgentDispatcher } from './pageAgentDispatcher';
import { Recorder } from '../recorder';
-import { eventsHelper } from '../utils/eventsHelper';
import { disposeAll } from '../disposable';
import type { Artifact } from '../artifact';
@@ -48,7 +47,7 @@ import type * as channels from '@protocol/channels';
import type { Progress } from '@protocol/progress';
import type { URLMatch } from '../../utils/isomorphic/urlMatch';
import type { ScreencastFrame } from '../types';
-import type { RegisteredListener } from '../utils/eventsHelper';
+import type { ScreencastListener } from '../screencast';
export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, BrowserContextDispatcher> implements channels.PageChannel {
_type_EventTarget = true;
@@ -63,7 +62,7 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
private _locatorHandlers = new Set<number>();
private _jsCoverageActive = false;
private _cssCoverageActive = false;
- private _screencastFrameListener: RegisteredListener | null = null;
+ private _screencastListener: ScreencastListener | null = null;
static from(parentScope: BrowserContextDispatcher, page: Page): PageDispatcher {
return PageDispatcher.fromNullable(parentScope, page)!;
@@ -366,21 +365,24 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
}
async startScreencast(params: channels.PageStartScreencastParams, progress?: Progress): Promise<channels.PageStartScreencastResult> {
- if (this._screencastFrameListener)
+ if (this._screencastListener)
throw new Error('Screencast is already running');
const size = params.maxSize || { width: 800, height: 800 };
- // TODO: move to screencast and make startScrencast accept a listener.
- this._screencastFrameListener = eventsHelper.addEventListener(this._page, Page.Events.ScreencastFrame, (frame: ScreencastFrame) => {
+ this._screencastListener = (frame: ScreencastFrame) => {
this._dispatchEvent('screencastFrame', { data: frame.buffer });
- });
- await this._page.screencast.startScreencast(this, { quality: 90, width: size.width, height: size.height });
+ };
+ await this._page.screencast.startScreencast(this._screencastListener, { quality: 90, width: size.width, height: size.height });
}
async stopScreencast(params: channels.PageStopScreencastParams, progress?: Progress): Promise<channels.PageStopScreencastResult> {
- if (this._screencastFrameListener)
- eventsHelper.removeEventListeners([this._screencastFrameListener]);
- this._screencastFrameListener = null;
- return this._page.screencast.stopScreencast(this);
+ await this._stopScreencast();
+ }
+
+ private async _stopScreencast() {
+ const listener = this._screencastListener;
+ this._screencastListener = null;
+ if (listener)
+ await this._page.screencast.stopScreencast(listener);
}
async videoStart(params: channels.PageVideoStartParams, progress: Progress): Promise<channels.PageVideoStartResult> {
@@ -450,9 +452,7 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
if (this._cssCoverageActive)
(this._page.coverage as CRCoverage).stopCSSCoverage().catch(() => {});
this._cssCoverageActive = false;
- if (this._screencastFrameListener)
- eventsHelper.removeEventListeners([this._screencastFrameListener]);
- this._screencastFrameListener = null;
+ this._stopScreencast().catch(() => {});
}
async setDockTile(params: channels.PageSetDockTileParams): Promise<void> {
diff --git a/packages/playwright-core/src/server/firefox/ffPage.ts b/packages/playwright-core/src/server/firefox/ffPage.ts
index ac82272e8d..ef3f391190 100644
--- a/packages/playwright-core/src/server/firefox/ffPage.ts
+++ b/packages/playwright-core/src/server/firefox/ffPage.ts
@@ -490,7 +490,7 @@ export class FFPage implements PageDelegate {
});
const buffer = Buffer.from(event.data, 'base64');
- this._page.emit(Page.Events.ScreencastFrame, {
+ this._page.screencast.onScreencastFrame({
buffer,
frameSwapWallTime: event.timestamp * 1000, // timestamp is in seconds, we need to convert to milliseconds.
viewportWidth: event.deviceWidth,
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index 51a91df429..95cd244ebb 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -131,7 +131,6 @@ const PageEvent = {
FrameDetached: 'framedetached',
InternalFrameNavigatedToNewDocument: 'internalframenavigatedtonewdocument',
LocatorHandlerTriggered: 'locatorhandlertriggered',
- ScreencastFrame: 'screencastframe',
WebSocket: 'websocket',
Worker: 'worker',
} as const;
@@ -146,7 +145,6 @@ export type PageEventMap = {
[PageEvent.FrameDetached]: [frame: frames.Frame];
[PageEvent.InternalFrameNavigatedToNewDocument]: [frame: frames.Frame];
[PageEvent.LocatorHandlerTriggered]: [uid: number];
- [PageEvent.ScreencastFrame]: [frame: types.ScreencastFrame];
[PageEvent.WebSocket]: [webSocket: network.WebSocket];
[PageEvent.Worker]: [worker: Worker];
};
diff --git a/packages/playwright-core/src/server/screencast.ts b/packages/playwright-core/src/server/screencast.ts
index 42c6f44640..6e59e42d6a 100644
--- a/packages/playwright-core/src/server/screencast.ts
+++ b/packages/playwright-core/src/server/screencast.ts
@@ -15,7 +15,7 @@
*/
import path from 'path';
-import { assert, createGuid, eventsHelper, RegisteredListener } from '../utils';
+import { assert, createGuid } from '../utils';
import { debugLogger } from '../utils';
import { VideoRecorder } from './videoRecorder';
import { Page } from './page';
@@ -24,17 +24,19 @@ import { validateVideoSize } from './browserContext';
import type * as types from './types';
+export type ScreencastListener = (frame: types.ScreencastFrame) => void;
+
export class Screencast {
private _page: Page;
private _videoRecorder: VideoRecorder | null = null;
private _videoId: string | null = null;
- private _screencastClients = new Set<unknown>();
+ private _listeners = new Set<ScreencastListener>();
private _screencastOptions: { width: number, height: number, quality: number } | null = null;
// Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
// When throttling for tracing, 200ms between frames, except for 10 frames around the action.
private _frameThrottler = new FrameThrottler(10, 35, 200);
- private _frameListener: RegisteredListener | null = null;
+ private _videoFrameListener: ScreencastListener | null = null;
constructor(page: Page) {
this._page = page;
@@ -44,9 +46,16 @@ export class Screencast {
this._frameThrottler.dispose();
}
- setOptions(options: { width: number, height: number, quality: number } | null) {
- this._setOptions(options).catch(e => debugLogger.log('error', e));
- this._frameThrottler.setThrottlingEnabled(!!options);
+ startForTracing(listener: ScreencastListener) {
+ // If screencast is already running, use the same options, it's ok for tracing.
+ const options = this._screencastOptions || { width: 800, height: 800, quality: 90 };
+ this.startScreencast(listener, options).catch(e => debugLogger.log('error', e));
+ this._frameThrottler.setThrottlingEnabled(true);
+ }
+
+ stopForTracing(listener: ScreencastListener) {
+ this.stopScreencast(listener).catch(e => debugLogger.log('error', e));
+ this._frameThrottler.setThrottlingEnabled(false);
}
throttleFrameAck(ack: () => void) {
@@ -81,7 +90,7 @@ export class Screencast {
};
this._videoRecorder = new VideoRecorder(ffmpegPath, videoOptions);
- this._frameListener = eventsHelper.addEventListener(this._page, Page.Events.ScreencastFrame, frame => this._videoRecorder!.writeFrame(frame.buffer, frame.frameSwapWallTime / 1000));
+ this._videoFrameListener = frame => this._videoRecorder!.writeFrame(frame.buffer, frame.frameSwapWallTime / 1000);
this._page.waitForInitializedOrError().then(p => {
if (p instanceof Error)
this.stopVideoRecording().catch(() => {});
@@ -93,7 +102,7 @@ export class Screencast {
const videoId = this._videoId;
assert(videoId);
this._page.once(Page.Events.Close, () => this.stopVideoRecording().catch(() => {}));
- await this.startScreencast(this._videoRecorder, {
+ await this.startScreencast(this._videoFrameListener!, {
quality: 90,
width: options.width,
height: options.height,
@@ -104,14 +113,13 @@ export class Screencast {
async stopVideoRecording(): Promise<void> {
if (!this._videoId)
return;
- if (this._frameListener)
- eventsHelper.removeEventListeners([this._frameListener]);
- this._frameListener = null;
+ const videoFrameListener = this._videoFrameListener!;
+ this._videoFrameListener = null;
const videoId = this._videoId;
this._videoId = null;
const videoRecorder = this._videoRecorder!;
this._videoRecorder = null;
- await this.stopScreencast(videoRecorder);
+ await this.stopScreencast(videoFrameListener);
await videoRecorder.stop();
// Keep the video artifact in the map until encoding is fully finished, if the context
// starts closing before the video is fully written to disk it will wait for it.
@@ -133,20 +141,13 @@ export class Screencast {
await this.stopVideoRecording();
}
- private async _setOptions(options: { width: number, height: number, quality: number } | null): Promise<void> {
- if (options)
- await this.startScreencast(this, options);
- else
- await this.stopScreencast(this);
- }
-
- async startScreencast(client: unknown, options: { width: number, height: number, quality: number }) {
+ async startScreencast(listener: ScreencastListener, options: { width: number, height: number, quality: number }) {
if (this._screencastOptions) {
if (options.width !== this._screencastOptions.width || options.height !== this._screencastOptions.height || options.quality !== this._screencastOptions.quality)
throw new Error(`Screencast is already running with different options (${this._screencastOptions.width}x${this._screencastOptions.height} quality=${this._screencastOptions.quality})`);
}
- this._screencastClients.add(client);
- if (this._screencastClients.size === 1) {
+ this._listeners.add(listener);
+ if (this._listeners.size === 1) {
this._screencastOptions = options;
await this._page.delegate.startScreencast({
width: options.width,
@@ -156,13 +157,18 @@ export class Screencast {
}
}
- async stopScreencast(client: unknown) {
- this._screencastClients.delete(client);
- if (!this._screencastClients.size) {
+ async stopScreencast(listener: ScreencastListener) {
+ this._listeners.delete(listener);
+ if (!this._listeners.size) {
this._screencastOptions = null;
await this._page.delegate.stopScreencast();
}
}
+
+ onScreencastFrame(frame: types.ScreencastFrame) {
+ for (const listener of this._listeners)
+ listener(frame);
+ }
}
class FrameThrottler {
diff --git a/packages/playwright-core/src/server/trace/recorder/tracing.ts b/packages/playwright-core/src/server/trace/recorder/tracing.ts
index a79a85efb1..93d9ce5817 100644
--- a/packages/playwright-core/src/server/trace/recorder/tracing.ts
+++ b/packages/playwright-core/src/server/trace/recorder/tracing.ts
@@ -50,6 +50,7 @@ import type { FrameSnapshot } from '@trace/snapshot';
import type * as trace from '@trace/trace';
import type { Progress } from '@protocol/progress';
import type * as types from '../../types';
+import type { ScreencastListener } from '../../screencast';
const version: trace.VERSION = 8;
@@ -75,13 +76,12 @@ type RecordingState = {
groupStack: string[];
};
-const kScreencastOptions = { width: 800, height: 600, quality: 90 };
-
export class Tracing extends SdkObject implements InstrumentationListener, SnapshotterDelegate, HarTracerDelegate {
private _fs = new SerializedFS();
private _snapshotter?: Snapshotter;
private _harTracer: HarTracer;
private _screencastListeners: RegisteredListener[] = [];
+ private _pageScreencastListeners = new Map<Page, ScreencastListener>();
private _eventListeners: RegisteredListener[] = [];
private _context: BrowserContext | APIRequestContext;
// Note: state should only be touched inside API methods, but not inside trace operations.
@@ -281,8 +281,13 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
eventsHelper.removeEventListeners(this._screencastListeners);
if (!(this._context instanceof BrowserContext))
return;
- for (const page of this._context.pages())
- page.screencast.setOptions(null);
+ for (const page of this._context.pages()) {
+ const listener = this._pageScreencastListeners.get(page);
+ if (listener) {
+ page.screencast.stopForTracing(listener);
+ this._pageScreencastListeners.delete(page);
+ }
+ }
}
private _allocateNewTraceFile(state: RecordingState) {
@@ -593,26 +598,25 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
}
private _startScreencastInPage(page: Page) {
- page.screencast.setOptions(kScreencastOptions);
const prefix = page.guid;
- this._screencastListeners.push(
- eventsHelper.addEventListener(page, Page.Events.ScreencastFrame, (params: types.ScreencastFrame) => {
- const suffix = Date.now();
- const sha1 = `${prefix}-${suffix}.jpeg`;
- const event: trace.ScreencastFrameTraceEvent = {
- type: 'screencast-frame',
- pageId: page.guid,
- sha1,
- width: params.viewportWidth,
- height: params.viewportHeight,
- timestamp: monotonicTime(),
- frameSwapWallTime: params.frameSwapWallTime,
- };
- // Make sure to write the screencast frame before adding a reference to it.
- this._appendResource(sha1, params.buffer);
- this._appendTraceEvent(event);
- }),
- );
+ const listener = (params: types.ScreencastFrame) => {
+ const suffix = Date.now();
+ const sha1 = `${prefix}-${suffix}.jpeg`;
+ const event: trace.ScreencastFrameTraceEvent = {
+ type: 'screencast-frame',
+ pageId: page.guid,
+ sha1,
+ width: params.viewportWidth,
+ height: params.viewportHeight,
+ timestamp: monotonicTime(),
+ frameSwapWallTime: params.frameSwapWallTime,
+ };
+ // Make sure to write the screencast frame before adding a reference to it.
+ this._appendResource(sha1, params.buffer);
+ this._appendTraceEvent(event);
+ };
+ this._pageScreencastListeners.set(page, listener);
+ page.screencast.startForTracing(listener);
}
private _appendTraceEvent(event: trace.TraceEvent) {
diff --git a/packages/playwright-core/src/server/webkit/wkPage.ts b/packages/playwright-core/src/server/webkit/wkPage.ts
index 1dc976039a..a2c848e720 100644
--- a/packages/playwright-core/src/server/webkit/wkPage.ts
+++ b/packages/playwright-core/src/server/webkit/wkPage.ts
@@ -947,7 +947,7 @@ export class WKPage implements PageDelegate {
this._pageProxySession.sendMayFail('Screencast.screencastFrameAck', { generation });
});
const buffer = Buffer.from(event.data, 'base64');
- this._page.emit(Page.Events.ScreencastFrame, {
+ this._page.screencast.onScreencastFrame({
buffer,
frameSwapWallTime: event.timestamp
// timestamp is in seconds, we need to convert to milliseconds.
diff --git a/tests/library/tracing.spec.ts b/tests/library/tracing.spec.ts
index 72e3966af0..7dc0771616 100644
--- a/tests/library/tracing.spec.ts
+++ b/tests/library/tracing.spec.ts
@@ -436,7 +436,7 @@ for (const params of [
browserTest.fixme(params.id === 'fit' && browserName === 'webkit' && platform === 'linux', 'Image size is flaky');
browserTest.fixme(browserName === 'firefox' && !headless, 'Image size is different');
- const scale = Math.min(800 / params.width, 600 / params.height, 1);
+ const scale = Math.min(800 / params.width, 800 / params.height, 1);
const previewWidth = params.width * scale;
const previewHeight = params.height * scale;
diff --git a/tests/library/video.spec.ts b/tests/library/video.spec.ts
index 59d45bf2e9..da6ddf7a8e 100644
--- a/tests/library/video.spec.ts
+++ b/tests/library/video.spec.ts
@@ -812,7 +812,7 @@ it.describe('screencast', () => {
});
it('video.start/stop twice', async ({ browser }, testInfo) => {
- const size = { width: 800, height: 600 };
+ const size = { width: 800, height: 800 };
const context = await browser.newContext({ viewport: size });
const page = await context.newPage();
@@ -868,10 +868,10 @@ it.describe('screencast', () => {
await context.close();
});
- it('video.start should finish when page is closed', async ({ browser, browserName }, testInfo) => {
+ it('video.start should finish when page is closed', async ({ browser }, testInfo) => {
const context = await browser.newContext();
const page = await context.newPage();
- await page.video().start({ size: { width: 800, height: 600 } });
+ await page.video().start({ size: { width: 800, height: 800 } });
await page.evaluate(() => document.body.style.backgroundColor = 'red');
await rafraf(page, 100);
const videoPath = await page.video().path();
@@ -886,7 +886,7 @@ it.describe('screencast', () => {
});
it('empty video', async ({ browser }, testInfo) => {
- const size = { width: 800, height: 600 };
+ const size = { width: 800, height: 800 };
const context = await browser.newContext({ viewport: size });
const page = await context.newPage();
await page.video().start({ size });