Skip to content

Commit 26a3f1f

Browse files
committed
perf(engine): skip the screenshot on frames the page reports unchanged in beginframe capture
1 parent 5a07ea2 commit 26a3f1f

3 files changed

Lines changed: 87 additions & 6 deletions

File tree

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
import { spawnSync } from "node:child_process";
2+
import puppeteer, { type Browser } from "puppeteer-core";
3+
import { afterAll, beforeAll, describe, expect, it } from "vitest";
4+
import { resolveHeadlessShellPath } from "./browserManager.js";
5+
import { beginFrameCapture } from "./screenshotService.js";
6+
import { closeTestChrome } from "./__fixtures__/loopback.js";
7+
8+
const chromePath = resolveHeadlessShellPath();
9+
const hasBrowser = chromePath !== undefined && spawnSync(chromePath, ["--version"]).status === 0;
10+
const INTERVAL = 1000 / 30;
11+
const options = { width: 160, height: 90, fps: { num: 30, den: 1 }, format: "jpeg" as const };
12+
13+
describe.skipIf(!hasBrowser)("beginFrameCapture reuse", () => {
14+
let browser: Browser;
15+
beforeAll(async () => {
16+
browser = await puppeteer.launch({
17+
executablePath: chromePath,
18+
headless: true,
19+
args: [
20+
"--no-sandbox",
21+
"--disable-dev-shm-usage",
22+
"--deterministic-mode",
23+
"--enable-begin-frame-control",
24+
"--disable-new-content-rendering-timeout",
25+
"--run-all-compositor-stages-before-draw",
26+
],
27+
});
28+
}, 30_000);
29+
afterAll(() => closeTestChrome(browser));
30+
31+
it("reuses a frame only when the page reports no change, never a stale one", async () => {
32+
const page = await browser.newPage();
33+
await page.setViewport({ width: 160, height: 90 });
34+
await page.setContent(
35+
`<body style="margin:0"><div id="b" style="width:160px;height:90px;background:#f00"></div></body>`,
36+
);
37+
const grab = (tick: number) => beginFrameCapture(page, options, tick * INTERVAL, INTERVAL);
38+
const paint = (color: string) =>
39+
page.evaluate(
40+
(c) => ((document.getElementById("b") as HTMLElement).style.background = c),
41+
color,
42+
);
43+
44+
// The first ticks after load may still report paint settling; reuse starts once it ends.
45+
let tick = 1;
46+
let last = await grab(tick);
47+
expect(last.hasDamage).toBe(true);
48+
let held = await grab(++tick);
49+
while (held.hasDamage && tick < 8) {
50+
last = held;
51+
held = await grab(++tick);
52+
}
53+
expect(held.hasDamage).toBe(false);
54+
expect(held.buffer.equals(last.buffer)).toBe(true);
55+
const first = held;
56+
57+
await paint("#00f");
58+
const changed = await grab(++tick);
59+
expect(changed.hasDamage).toBe(true);
60+
expect(changed.buffer.equals(first.buffer)).toBe(false);
61+
await page.close();
62+
}, 30_000);
63+
});

‎packages/engine/src/services/frameCapture.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -72,6 +72,7 @@ import {
7272
} from "./browserManager.js";
7373
import {
7474
beginFrameCapture,
75+
forgetBeginFrameCapture,
7576
ensureRenderFrameSiblings,
7677
getCdpSession,
7778
pageContentExceedsCaptureHeight,
@@ -4504,6 +4505,7 @@ async function captureFrameSurface(
45044505
interval: session.beginFrameIntervalMs,
45054506
noDisplayUpdates: false,
45064507
});
4508+
forgetBeginFrameCapture(page);
45074509
session.beginFrameSeekPresented = true;
45084510
}
45094511
const result = await beginFrameCapture(

‎packages/engine/src/services/screenshotService.ts‎

Lines changed: 22 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -108,12 +108,16 @@ export async function probeBeginFrameLiveness(
108108
* Requires chrome-headless-shell with --enable-begin-frame-control and
109109
* --deterministic-mode flags.
110110
*/
111-
// Cache the last valid screenshot buffer per page for hasDamage=false frames.
112-
// When Chrome reports no visual change, we reuse the previous frame rather than
113-
// attempting Page.captureScreenshot (which times out in beginFrame mode since
114-
// the compositor is paused).
111+
// The last buffer beginFrameCapture returned per page. A screenshot BeginFrame always
112+
// reports damage, so a frame is reused only when a screenshot-less BeginFrame right after
113+
// the seek reports none. Any BeginFrame sent elsewhere moves the display past this buffer:
114+
// call forgetBeginFrameCapture first.
115115
const lastFrameCache = new WeakMap<Page, Buffer>();
116116

117+
export function forgetBeginFrameCapture(page: Page): void {
118+
lastFrameCache.delete(page);
119+
}
120+
117121
const PENDING_FRAME_RETRIES = 5;
118122

119123
async function sendBeginFrame(
@@ -156,14 +160,26 @@ export async function beginFrameCapture(
156160
optimizeForSpeed: true,
157161
} as const;
158162

159-
const result = await sendBeginFrame(client, { frameTimeTicks, interval, screenshot });
163+
const cached = lastFrameCache.get(page);
164+
let screenshotTicks = frameTimeTicks;
165+
if (cached) {
166+
const probe = await sendBeginFrame(client, { frameTimeTicks, interval });
167+
if (!probe.hasDamage) return { buffer: cached, hasDamage: false };
168+
screenshotTicks = frameTimeTicks + interval / 2;
169+
}
170+
const result = await sendBeginFrame(client, {
171+
frameTimeTicks: screenshotTicks,
172+
interval,
173+
screenshot,
174+
});
160175

161176
let buffer: Buffer;
162177
if (result.screenshotData) {
163178
buffer = Buffer.from(result.screenshotData, "base64");
179+
// The screenshot leaves damage that the next BeginFrame would report; settle it now.
180+
await sendBeginFrame(client, { frameTimeTicks: screenshotTicks + interval / 4, interval });
164181
lastFrameCache.set(page, buffer);
165182
} else {
166-
const cached = lastFrameCache.get(page);
167183
if (cached) {
168184
buffer = cached;
169185
} else {

0 commit comments

Comments
 (0)