diff --git a/src/renderer/src/assets/main.css b/src/renderer/src/assets/main.css index dc33745c134..3b983c5a9dd 100644 --- a/src/renderer/src/assets/main.css +++ b/src/renderer/src/assets/main.css @@ -1819,6 +1819,10 @@ html.native-shell .app-layout { animation: agent-spinner-rotate 86400s steps(1036800, end) infinite; } +.agent-working-spinner[data-animation-offscreen] { + animation: none; +} + @media (prefers-reduced-motion: reduce) { .agent-working-spinner { animation: none; diff --git a/src/renderer/src/components/AgentWorkingSpinner.tsx b/src/renderer/src/components/AgentWorkingSpinner.tsx index 2b576f32fa1..763380067a4 100644 --- a/src/renderer/src/components/AgentWorkingSpinner.tsx +++ b/src/renderer/src/components/AgentWorkingSpinner.tsx @@ -1,5 +1,6 @@ import React from 'react' import { cn } from '@/lib/utils' +import { observeOffscreenAnimation } from '@/lib/offscreen-animation-pause' const SPINNER_ANIMATION_NAME = 'agent-spinner-rotate' @@ -26,10 +27,16 @@ function handleSpinnerAnimationStart(event: React.AnimationEvent void { + return observeOffscreenAnimation(el) +} + // CSS compositor rotation avoids JS input-thread work; callers provide size. export function AgentWorkingSpinner({ className }: { className?: string }): React.JSX.Element { return ( []) => void + +const observers: { callback: Callback; disconnect: ReturnType }[] = [] + +class FakeIntersectionObserver { + observe = vi.fn() + unobserve = vi.fn() + disconnect = vi.fn() + constructor(callback: Callback) { + observers.push({ callback, disconnect: this.disconnect }) + } +} + +describe('observeOffscreenAnimation', () => { + afterEach(() => { + observers.length = 0 + vi.unstubAllGlobals() + }) + + it('marks elements only while they are outside the viewport', () => { + vi.stubGlobal('IntersectionObserver', FakeIntersectionObserver) + const element = document.createElement('span') + const release = observeOffscreenAnimation(element) + + observers[0].callback([{ target: element, isIntersecting: false }]) + expect(element.hasAttribute(OFFSCREEN_ANIMATION_ATTRIBUTE)).toBe(true) + observers[0].callback([{ target: element, isIntersecting: true }]) + expect(element.hasAttribute(OFFSCREEN_ANIMATION_ATTRIBUTE)).toBe(false) + + observers[0].callback([{ target: element, isIntersecting: false }]) + release() + expect(element.hasAttribute(OFFSCREEN_ANIMATION_ATTRIBUTE)).toBe(false) + }) + + it('shares one observer and disconnects it after the last release', () => { + vi.stubGlobal('IntersectionObserver', FakeIntersectionObserver) + const releaseFirst = observeOffscreenAnimation(document.createElement('span')) + const releaseSecond = observeOffscreenAnimation(document.createElement('span')) + expect(observers).toHaveLength(1) + + releaseFirst() + expect(observers[0].disconnect).not.toHaveBeenCalled() + releaseSecond() + expect(observers[0].disconnect).toHaveBeenCalledOnce() + + observeOffscreenAnimation(document.createElement('span'))() + expect(observers).toHaveLength(2) + }) + + it('leaves animations running where IntersectionObserver is unavailable', () => { + vi.stubGlobal('IntersectionObserver', undefined) + const element = document.createElement('span') + observeOffscreenAnimation(element)() + expect(element.hasAttribute(OFFSCREEN_ANIMATION_ATTRIBUTE)).toBe(false) + }) +}) diff --git a/src/renderer/src/lib/offscreen-animation-pause.ts b/src/renderer/src/lib/offscreen-animation-pause.ts new file mode 100644 index 00000000000..f530f15f7e2 --- /dev/null +++ b/src/renderer/src/lib/offscreen-animation-pause.ts @@ -0,0 +1,36 @@ +// Running CSS animations make the compositor tick every refresh even when scrolled out of view or clipped. +export const OFFSCREEN_ANIMATION_ATTRIBUTE = 'data-animation-offscreen' + +let observer: IntersectionObserver | null = null +let observedCount = 0 + +function getObserver(): IntersectionObserver | null { + if (typeof IntersectionObserver !== 'function') { + return null + } + observer ??= new IntersectionObserver((entries) => { + for (const entry of entries) { + entry.target.toggleAttribute(OFFSCREEN_ANIMATION_ATTRIBUTE, !entry.isIntersecting) + } + }) + return observer +} + +/** Marks the element while it is outside the viewport so CSS can stop its animation. */ +export function observeOffscreenAnimation(element: Element): () => void { + const shared = getObserver() + if (shared === null) { + return () => {} + } + shared.observe(element) + observedCount++ + return () => { + shared.unobserve(element) + element.removeAttribute(OFFSCREEN_ANIMATION_ATTRIBUTE) + observedCount-- + if (observedCount === 0) { + shared.disconnect() + observer = null + } + } +} diff --git a/tests/tools/benchmarks/spinner-rendering/app-variants.mjs b/tests/tools/benchmarks/spinner-rendering/app-variants.mjs index 1b105db19a1..3808352f1b6 100644 --- a/tests/tools/benchmarks/spinner-rendering/app-variants.mjs +++ b/tests/tools/benchmarks/spinner-rendering/app-variants.mjs @@ -4,6 +4,12 @@ export const spinnerVariants = { .agent-working-spinner { animation-duration: 1s; animation-timing-function: steps(12, end); } `, long: '', + // Keeps scrolled-out rings animating, as before offscreen pausing. + unpaused: ` + .agent-working-spinner[data-animation-offscreen] { + animation: agent-spinner-rotate 86400s steps(1036800, end) infinite; + } + `, // Retain the rejected containment experiment for reproducible ablation. contained: '.spinner-benchmark-container { content-visibility: auto; overflow-clip-margin: var(--spacing); }' diff --git a/tests/tools/benchmarks/spinner-rendering/trace-iterations.mjs b/tests/tools/benchmarks/spinner-rendering/trace-iterations.mjs index 430dcf257ad..158a851b0e1 100644 --- a/tests/tools/benchmarks/spinner-rendering/trace-iterations.mjs +++ b/tests/tools/benchmarks/spinner-rendering/trace-iterations.mjs @@ -2,7 +2,7 @@ import { writeFileSync } from 'node:fs' export async function traceIterations(cdp, outputPath, durationMs = 2200) { await cdp.send('Tracing.start', { - categories: 'devtools.timeline', + categories: 'devtools.timeline,toplevel,cc,disabled-by-default-cc.debug.scheduler', transferMode: 'ReturnAsStream' }) await new Promise((resolve) => setTimeout(resolve, durationMs)) @@ -23,11 +23,33 @@ export async function traceIterations(cdp, outputPath, durationMs = 2200) { } writeFileSync(outputPath, json) const events = JSON.parse(json).traceEvents + const compositorThreads = new Set( + events + .filter((event) => event.name === 'thread_name' && event.args?.name === 'Compositor') + .map((event) => `${event.pid}:${event.tid}`) + ) + const onCompositor = events.filter((event) => compositorThreads.has(`${event.pid}:${event.tid}`)) + const perSecond = (count) => Math.round((count * 1000) / durationMs) return { durationMs, iterationEvents: events.filter( (event) => event.name === 'EventDispatch' && event.args?.data?.type === 'animationiteration' ).length, - styleUpdates: events.filter((event) => event.name === 'UpdateLayoutTree').length + styleUpdates: events.filter((event) => event.name === 'UpdateLayoutTree').length, + // A spinner that wakes the compositor every refresh shows up as many no-damage frames. + compositorFramesPerSecond: perSecond( + onCompositor.filter((event) => event.name === 'Scheduler::BeginImplFrame').length + ), + noDamageFramesPerSecond: perSecond( + onCompositor.filter((event) => event.name === 'EarlyOut_NoDamage').length + ), + compositorThreadMsPerSecond: + Math.round( + (onCompositor + .filter((event) => event.name === 'ThreadControllerImpl::RunTask') + .reduce((total, event) => total + (event.tdur ?? event.dur ?? 0), 0) / + durationMs) * + 10 + ) / 10 } } diff --git a/tests/tools/benchmarks/spinner-rendering/verify-rendering.mjs b/tests/tools/benchmarks/spinner-rendering/verify-rendering.mjs index 85f8b4920f9..edaf2bee856 100644 --- a/tests/tools/benchmarks/spinner-rendering/verify-rendering.mjs +++ b/tests/tools/benchmarks/spinner-rendering/verify-rendering.mjs @@ -6,6 +6,10 @@ async function waitForPhase(page) { .waitForFunction(() => [...document.querySelectorAll('[data-agent-spinner]')].every((element) => { const animations = element.getAnimations({ subtree: true }) + // Offscreen rings must hold no animation; onscreen ones run on the shared phase. + if (element.hasAttribute('data-animation-offscreen')) { + return animations.length === 0 + } return ( animations.length === 1 && animations[0].startTime === 0 && @@ -53,6 +57,9 @@ export async function verifyRendering(app, page, outputDir) { await page.emulateMedia({ reducedMotion: 'no-preference' }) await waitForPhase(page) await page.evaluate(() => window.spinnerBenchmark.render({ count: 200, offset: 5000 })) + await page.waitForFunction( + () => document.querySelectorAll('[data-agent-spinner][data-animation-offscreen]').length === 200 + ) await waitForPhase(page) await page.evaluate(() => { document.querySelector('#scroller').scrollTop = 5000 @@ -104,6 +111,7 @@ export async function verifyRendering(app, page, outputDir) { ) return { pixelComparisons, + offscreenPause: true, iterationEvents, phases: true, reducedMotion: true,