Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-07 23:43:39 +01:00
Code Issues Projects Releases Packages Wiki Activity

script: Properly root nodes with animating images (#37689)

Browse source 
This change fixes an issue and makes a few more minor improvements to
the `ImageAnimationState`:

1. Image rooting and unrooted now happens in one step from
   `Window::update_animations_post_reflow`.
2. The `node_to_animating_image_map` is now stored as a shared `RwLock`
   so that it doesn't need to be taken and then replaced in the
`ImageAnimationState` during reflow. This should prevent a hypothetical
issue
   where image animations are restarted during empty reflows.
3. General naming and idiomatic Rust usage improvements.

Testing: This doesn't really have any obvious behavioral changes,
because all
reflows currently trigger a restyle. It becomes a serious problem with
#37677
and this change fixes the failing test there.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
This commit is contained in:
Martin Robinson 2025-06-25 15:52:11 +02:00 • committed by GitHub
parent b89a44c539
commit a66a257b38
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 107 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

123
components/script/image_animation.rs
View file

@ -2,12 +2,16 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use std::sync::Arc;
use compositing_traits::{ImageUpdate, SerializableImageData};
use embedder_traits::UntrustedNodeAddress;
use fxhash::{FxHashMap, FxHashSet};
use fxhash::FxHashMap;
use ipc_channel::ipc::IpcSharedMemory;
use layout_api::ImageAnimationState;
use libc::c_void;
use malloc_size_of::MallocSizeOf;
use parking_lot::RwLock;
use script_bindings::root::Dom;
use style::dom::OpaqueNode;
use webrender_api::units::DeviceIntSize;
@ -18,97 +22,90 @@ use crate::dom::bindings::trace::NoTrace;
use crate::dom::node::{Node, from_untrusted_node_address};
use crate::dom::window::Window;
#[derive(Clone, Debug, Default, JSTraceable, MallocSizeOf)]
#[derive(Clone, Debug, Default, JSTraceable)]
#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
pub struct ImageAnimationManager {
#[no_trace]
pub node_to_image_map: FxHashMap<OpaqueNode, ImageAnimationState>,
node_to_image_map: Arc<RwLock<FxHashMap<OpaqueNode, ImageAnimationState>>>,
/// A list of nodes with in-progress image animations.
///
/// TODO(mrobinson): This does not properly handle animating images that are in pseudo-elements.
rooted_nodes: DomRefCell<FxHashMap<NoTrace<OpaqueNode>, Dom<Node>>>,
}
impl MallocSizeOf for ImageAnimationManager {
fn size_of(&self, ops: &mut malloc_size_of::MallocSizeOfOps) -> usize {
(*self.node_to_image_map.read()).size_of(ops) + self.rooted_nodes.size_of(ops)
}
}
impl ImageAnimationManager {
pub fn new() -> Self {
ImageAnimationManager {
node_to_image_map: Default::default(),
rooted_nodes: DomRefCell::new(FxHashMap::default()),
}
pub(crate) fn node_to_image_map(
&self,
) -> Arc<RwLock<FxHashMap<OpaqueNode, ImageAnimationState>>> {
self.node_to_image_map.clone()
}
pub fn take_image_animate_set(&mut self) -> FxHashMap<OpaqueNode, ImageAnimationState> {
std::mem::take(&mut self.node_to_image_map)
}
pub fn restore_image_animate_set(&mut self, map: FxHashMap<OpaqueNode, ImageAnimationState>) {
let _ = std::mem::replace(&mut self.node_to_image_map, map);
self.root_newly_animating_dom_nodes();
self.unroot_unused_nodes();
}
pub fn next_schedule_time(&self, now: f64) -> Option<f64> {
pub(crate) fn next_scheduled_time(&self, now: f64) -> Option<f64> {
self.node_to_image_map
.read()
.values()
.map(|state| state.time_to_next_frame(now))
.min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
}
pub fn image_animations_present(&self) -> bool {
!self.node_to_image_map.is_empty()
pub(crate) fn image_animations_present(&self) -> bool {
!self.node_to_image_map.read().is_empty()
}
pub fn update_active_frames(&mut self, window: &Window, now: f64) {
pub(crate) fn update_active_frames(&self, window: &Window, now: f64) {
let rooted_nodes = self.rooted_nodes.borrow();
let updates: Vec<ImageUpdate> = self
let updates = self
.node_to_image_map
.write()
.iter_mut()
.filter_map(|(node, state)| {
if state.update_frame_for_animation_timeline_value(now) {
let image = &state.image;
let frame = image
.frames()
.nth(state.active_frame)
.expect("active_frame should within range of frames");
if let Some(node) = rooted_nodes.get(&NoTrace(*node)) {
node.dirty(crate::dom::node::NodeDamage::Other);
}
Some(ImageUpdate::UpdateImage(
image.id.unwrap(),
ImageDescriptor {
format: ImageFormat::BGRA8,
size: DeviceIntSize::new(
image.metadata.width as i32,
image.metadata.height as i32,
),
stride: None,
offset: 0,
flags: ImageDescriptorFlags::ALLOW_MIPMAPS,
},
SerializableImageData::Raw(IpcSharedMemory::from_bytes(frame.bytes)),
))
} else {
None
if !state.update_frame_for_animation_timeline_value(now) {
return None;
}
let image = &state.image;
let frame = image
.frames()
.nth(state.active_frame)
.expect("active_frame should within range of frames");
if let Some(node) = rooted_nodes.get(&NoTrace(*node)) {
node.dirty(crate::dom::node::NodeDamage::Other);
}
Some(ImageUpdate::UpdateImage(
image.id.unwrap(),
ImageDescriptor {
format: ImageFormat::BGRA8,
size: DeviceIntSize::new(
image.metadata.width as i32,
image.metadata.height as i32,
),
stride: None,
offset: 0,
flags: ImageDescriptorFlags::ALLOW_MIPMAPS,
},
SerializableImageData::Raw(IpcSharedMemory::from_bytes(frame.bytes)),
))
})
.collect();
window.compositor_api().update_images(updates);
}
// Unroot any nodes that we have rooted but no longer have animating images.
fn unroot_unused_nodes(&self) {
let nodes: FxHashSet<&OpaqueNode> = self.node_to_image_map.keys().collect();
self.rooted_nodes
.borrow_mut()
.retain(|node, _| nodes.contains(&node.0));
}
/// Ensure that all nodes with Image animations are rooted. This should be called
/// immediately after a restyle, to ensure that these addresses are still valid.
/// Ensure that all nodes with animating images are rooted and unroots any nodes that
/// no longer have an animating image. This should be called immediately after a
/// restyle, to ensure that these addresses are still valid.
#[allow(unsafe_code)]
fn root_newly_animating_dom_nodes(&self) {
pub(crate) fn update_rooted_dom_nodes(&self) {
let mut rooted_nodes = self.rooted_nodes.borrow_mut();
for opaque_node in self.node_to_image_map.keys() {
let node_to_image_map = self.node_to_image_map.read();
for opaque_node in node_to_image_map.keys() {
let opaque_node = *opaque_node;
if rooted_nodes.contains_key(&NoTrace(opaque_node)) {
continue;
@ -121,5 +118,7 @@ impl ImageAnimationManager {
)
};
}
rooted_nodes.retain(|node, _| node_to_image_map.contains_key(&node.0));
}
}