Skip to content

🎥 Make videos programmatically with React

fix(web-renderer): cancel pending native paint waits

Alec Watts92d9476ac7db
diff --git a/packages/web-renderer/src/html-in-canvas.ts b/packages/web-renderer/src/html-in-canvas.ts
index 5f5b9bcda7..6caa60163e 100644
--- a/packages/web-renderer/src/html-in-canvas.ts
+++ b/packages/web-renderer/src/html-in-canvas.ts
@@ -99,16 +99,44 @@ export const setupHtmlInCanvas = ({
const waitForPaint = (
layoutCanvas: HTMLCanvasWithLayoutSubtree,
+ signal: AbortSignal | null,
): Promise<void> => {
- return new Promise((resolve) => {
- // Chromium dispatches paint during compositor commit. Resume in a new task
- // so WebGL context eviction cannot destroy a texture layer during commit.
- // Remove this workaround once the Chromium fix ships in supported Chrome versions.
- // https://github.com/remotion-dev/remotion/issues/12293
- layoutCanvas.addEventListener('paint', () => setTimeout(resolve, 0), {
- once: true,
- });
- layoutCanvas.requestPaint!();
+ return new Promise((resolve, reject) => {
+ let paintTimer: ReturnType<typeof setTimeout> | null = null;
+ const cleanup = () => {
+ layoutCanvas.removeEventListener('paint', onPaint);
+ signal?.removeEventListener('abort', onAbort);
+ if (paintTimer !== null) {
+ clearTimeout(paintTimer);
+ }
+ };
+ const onAbort = () => {
+ cleanup();
+ reject(signal!.reason);
+ };
+ const onPaint = () => {
+ // Chromium dispatches paint during compositor commit. Resume in a new task
+ // so WebGL context eviction cannot destroy a texture layer during commit.
+ // Remove this workaround once the Chromium fix ships in supported Chrome versions.
+ // https://github.com/remotion-dev/remotion/issues/12293
+ paintTimer = setTimeout(() => {
+ cleanup();
+ resolve();
+ }, 0);
+ };
+ if (signal?.aborted) {
+ onAbort();
+ return;
+ }
+
+ layoutCanvas.addEventListener('paint', onPaint, {once: true});
+ signal?.addEventListener('abort', onAbort, {once: true});
+ try {
+ layoutCanvas.requestPaint!();
+ } catch (error) {
+ cleanup();
+ reject(error);
+ }
});
};
@@ -124,11 +152,13 @@ export const drawWithHtmlInCanvas = async ({
element,
scaledWidth,
scaledHeight,
+ signal,
}: {
htmlInCanvasContext: HtmlInCanvasContext;
element: HTMLElement;
scaledWidth: number;
scaledHeight: number;
+ signal: AbortSignal | null;
}): Promise<OffscreenCanvasRenderingContext2D> => {
const {ctx, layoutCanvas} = htmlInCanvasContext;
@@ -140,7 +170,7 @@ export const drawWithHtmlInCanvas = async ({
layoutCanvas.height = scaledHeight;
}
- await waitForPaint(layoutCanvas);
+ await waitForPaint(layoutCanvas, signal);
ctx.reset();
ctx.drawElementImage(element, 0, 0, scaledWidth, scaledHeight);
diff --git a/packages/web-renderer/src/take-screenshot.ts b/packages/web-renderer/src/take-screenshot.ts
index df83608f4c..ba0a41f50e 100644
--- a/packages/web-renderer/src/take-screenshot.ts
+++ b/packages/web-renderer/src/take-screenshot.ts
@@ -67,10 +67,15 @@ export const createLayer = async ({
element,
scaledWidth,
scaledHeight,
+ signal: internalState.maskImageLoaderState.signal,
});
onHtmlInCanvasLayerOutcome({native: true});
return offCtx;
} catch (err) {
+ if (internalState.maskImageLoaderState.signal?.aborted) {
+ throw err;
+ }
+
const detail = err instanceof Error ? err.message : JSON.stringify(err);
onHtmlInCanvasLayerOutcome({
native: false,
diff --git a/packages/web-renderer/src/test/html-in-canvas-cancellation.test.ts b/packages/web-renderer/src/test/html-in-canvas-cancellation.test.ts
new file mode 100644
index 0000000000..451944220d
--- /dev/null
+++ b/packages/web-renderer/src/test/html-in-canvas-cancellation.test.ts
@@ -0,0 +1,87 @@
+import {expect, test, vi} from 'vitest';
+import {
+ drawWithHtmlInCanvas,
+ type HtmlInCanvasContext,
+} from '../html-in-canvas';
+
+for (const stage of ['before request', 'waiting for paint', 'after paint']) {
+ test(`cancels native capture ${stage} and releases paint resources`, async () => {
+ vi.useFakeTimers();
+ try {
+ const layoutCanvas = Object.assign(new EventTarget(), {
+ width: 1,
+ height: 1,
+ requestPaint: vi.fn(),
+ });
+ const removePaint = vi.spyOn(layoutCanvas, 'removeEventListener');
+ const controller = new AbortController();
+ const removeAbort = vi.spyOn(controller.signal, 'removeEventListener');
+ const reason = new Error('capture cancelled');
+ const reset = vi.fn();
+ const drawElementImage = vi.fn();
+ if (stage === 'before request') {
+ controller.abort(reason);
+ }
+
+ const capture = drawWithHtmlInCanvas({
+ htmlInCanvasContext: {
+ layoutCanvas,
+ ctx: {reset, drawElementImage},
+ wasDrawable: false,
+ } as unknown as HtmlInCanvasContext,
+ element: {} as HTMLElement,
+ scaledWidth: 1,
+ scaledHeight: 1,
+ signal: controller.signal,
+ });
+ // Attach the rejection handler before cancelling or flushing timers.
+ const rejected = expect(capture).rejects.toBe(reason);
+ if (stage === 'after paint') {
+ layoutCanvas.dispatchEvent(new Event('paint'));
+ }
+
+ controller.abort(reason);
+ await vi.runAllTimersAsync();
+ await rejected;
+ expect(removePaint).toHaveBeenCalledWith('paint', expect.any(Function));
+ expect(removeAbort).toHaveBeenCalledWith('abort', expect.any(Function));
+ expect(vi.getTimerCount()).toBe(0);
+ expect(reset).not.toHaveBeenCalled();
+ expect(drawElementImage).not.toHaveBeenCalled();
+ expect(layoutCanvas.requestPaint).toHaveBeenCalledTimes(
+ stage === 'before request' ? 0 : 1,
+ );
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+}
+
+test('removes native paint and abort listeners if requestPaint throws', async () => {
+ const reason = new Error('requestPaint failed');
+ const layoutCanvas = Object.assign(new EventTarget(), {
+ width: 1,
+ height: 1,
+ requestPaint: () => {
+ throw reason;
+ },
+ });
+ const controller = new AbortController();
+ const removePaint = vi.spyOn(layoutCanvas, 'removeEventListener');
+ const removeAbort = vi.spyOn(controller.signal, 'removeEventListener');
+ await expect(
+ drawWithHtmlInCanvas({
+ htmlInCanvasContext: {
+ layoutCanvas,
+ ctx: {},
+ wasDrawable: false,
+ } as unknown as HtmlInCanvasContext,
+ element: {} as HTMLElement,
+ scaledWidth: 1,
+ scaledHeight: 1,
+ signal: controller.signal,
+ }),
+ ).rejects.toBe(reason);
+ expect(removePaint).toHaveBeenCalledWith('paint', expect.any(Function));
+ expect(removeAbort).toHaveBeenCalledWith('abort', expect.any(Function));
+});
diff --git a/packages/web-renderer/src/test/html-in-canvas.test.tsx b/packages/web-renderer/src/test/html-in-canvas.test.tsx
index 929ac69377..f41d07c3d0 100644
--- a/packages/web-renderer/src/test/html-in-canvas.test.tsx
+++ b/packages/web-renderer/src/test/html-in-canvas.test.tsx
@@ -98,6 +98,7 @@ test('can evict WebGL contexts after native capture without crashing', async (t)
element,
scaledWidth: 100,
scaledHeight: 100,
+ signal: null,
});
const lostBefore = contexts.filter((gl) => gl.isContextLost()).length;
// Without a task boundary in waitForPaint, this continuation still runs