Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 20:50:07 +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

1
components/script/Cargo.toml
View file

@ -95,6 +95,7 @@ net_traits = { workspace = true }
nom = "7.1.3"
num-traits = { workspace = true }
num_cpus = { workspace = true }
parking_lot = { workspace = true }
percent-encoding = { workspace = true }
phf = "0.11"
pixels = { path = "../pixels" }

12
components/script/dom/document.rs
View file

@ -4189,7 +4189,7 @@ impl Document {
DomRefCell::new(AnimationTimeline::new())
},
animations: DomRefCell::new(Animations::new()),
image_animation_manager: DomRefCell::new(ImageAnimationManager::new()),
image_animation_manager: DomRefCell::new(ImageAnimationManager::default()),
dirty_root: Default::default(),
declarative_refresh: Default::default(),
pending_input_events: Default::default(),
@ -4960,6 +4960,7 @@ impl Document {
self.animations
.borrow()
.do_post_reflow_update(&self.window, self.current_animation_timeline_value());
self.image_animation_manager().update_rooted_dom_nodes();
}
pub(crate) fn cancel_animations_for_node(&self, node: &Node) {
@ -4998,12 +4999,9 @@ impl Document {
pub(crate) fn image_animation_manager(&self) -> Ref<ImageAnimationManager> {
self.image_animation_manager.borrow()
}
pub(crate) fn image_animation_manager_mut(&self) -> RefMut<ImageAnimationManager> {
self.image_animation_manager.borrow_mut()
}
pub(crate) fn update_animating_images(&self) {
let mut image_animation_manager = self.image_animation_manager.borrow_mut();
let image_animation_manager = self.image_animation_manager.borrow();
if !image_animation_manager.image_animations_present() {
return;
}
@ -5011,8 +5009,8 @@ impl Document {
.update_active_frames(&self.window, self.current_animation_timeline_value());
if !self.animations().animations_present() {
let next_scheduled_time =
image_animation_manager.next_schedule_time(self.current_animation_timeline_value());
let next_scheduled_time = image_animation_manager
.next_scheduled_time(self.current_animation_timeline_value());
// TODO: Once we have refresh signal from the compositor,
// we should get rid of timer for animated image update.
if let Some(next_scheduled_time) = next_scheduled_time {

7
components/script/dom/window.rs
View file

@ -2218,9 +2218,7 @@ impl Window {
pending_restyles,
animation_timeline_value: document.current_animation_timeline_value(),
animations: document.animations().sets.clone(),
node_to_image_animation_map: document
.image_animation_manager_mut()
.take_image_animate_set(),
node_to_animating_image_map: document.image_animation_manager().node_to_image_map(),
theme: self.theme.get(),
highlighted_dom_node,
};
@ -2297,9 +2295,6 @@ impl Window {
if !size_messages.is_empty() {
self.send_to_constellation(ScriptToConstellationMessage::IFrameSizes(size_messages));
}
document
.image_animation_manager_mut()
.restore_image_animate_set(results.node_to_image_animation_map);
document.update_animations_post_reflow();
self.update_constellation_epoch();

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));
}
}