Animation: update image active frame when update the rendering (#36286)

When no CSS animation exist, register timer for image animation, update
animated image active image frame as part of update_the_rendering, mark
node as dirty if the corresponding image need update. Added unit test to
test ImageAnimationState.

Part of https://github.com/servo/servo/issues/36057, the last step to
let the Animated Image "Move".

Testing: Introduced new WPT RefTest for animated image, but fail because
of https://github.com/servo/servo/issues/36931. New unit test for
`ImageAnimationState`.
Fixes: https://github.com/servo/servo/issues/22903
https://github.com/servo/servo/issues/36057

[Try](1472472966)

---------

Signed-off-by: rayguo17 <rayguo17@gmail.com>

components/script/animations.rs

@@ -76,6 +76,10 @@ impl Animations {
         self.pending_events.borrow_mut().clear();
     }
 
+    pub(crate) fn animations_present(&self) -> bool {
+        self.has_running_animations.get() || !self.pending_events.borrow().is_empty()
+    }
+
     // Mark all animations dirty, if they haven't been marked dirty since the
     // specified `current_timeline_value`. Returns true if animations were marked
     // dirty or false otherwise.

components/script/dom/document.rs

@@ -5051,6 +5051,35 @@ impl Document {
         self.image_animation_manager.borrow_mut()
     }
 
+    pub(crate) fn update_animating_images(&self) {
+        let mut image_animation_manager = self.image_animation_manager.borrow_mut();
+        if !image_animation_manager.image_animations_present() {
+            return;
+        }
+        image_animation_manager
+            .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());
+            // 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 {
+                self.schedule_image_animation_update(next_scheduled_time);
+            }
+        }
+    }
+
+    fn schedule_image_animation_update(&self, next_scheduled_time: f64) {
+        let callback = ImageAnimationUpdateCallback {
+            document: Trusted::new(self),
+        };
+        self.global().schedule_callback(
+            OneshotTimerCallback::ImageAnimationUpdate(callback),
+            Duration::from_secs_f64(next_scheduled_time),
+        );
+    }
+
     /// <https://html.spec.whatwg.org/multipage/#shared-declarative-refresh-steps>
     pub(crate) fn shared_declarative_refresh_steps(&self, content: &[u8]) {
         // 1. If document's will declaratively refresh is true, then return.
@@ -6747,6 +6776,21 @@ impl FakeRequestAnimationFrameCallback {
     }
 }
 
+/// This is a temporary workaround to update animated images,
+/// we should get rid of this after we have refresh driver #3406
+#[derive(JSTraceable, MallocSizeOf)]
+pub(crate) struct ImageAnimationUpdateCallback {
+    /// The document.
+    #[ignore_malloc_size_of = "non-owning"]
+    document: Trusted<Document>,
+}
+
+impl ImageAnimationUpdateCallback {
+    pub(crate) fn invoke(self, can_gc: CanGc) {
+        with_script_thread(|script_thread| script_thread.update_the_rendering(true, can_gc))
+    }
+}
+
 #[derive(JSTraceable, MallocSizeOf)]
 pub(crate) enum AnimationFrameCallback {
     DevtoolsFramerateTick {

components/script/image_animation.rs

@@ -2,20 +2,37 @@
  * 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 fxhash::FxHashMap;
+use compositing_traits::{ImageUpdate, SerializableImageData};
+use embedder_traits::UntrustedNodeAddress;
+use fxhash::{FxHashMap, FxHashSet};
+use ipc_channel::ipc::IpcSharedMemory;
+use libc::c_void;
+use script_bindings::root::Dom;
 use script_layout_interface::ImageAnimationState;
 use style::dom::OpaqueNode;
+use webrender_api::units::DeviceIntSize;
+use webrender_api::{ImageDescriptor, ImageDescriptorFlags, ImageFormat};
+
+use crate::dom::bindings::cell::DomRefCell;
+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)]
+#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
 pub struct ImageAnimationManager {
     #[no_trace]
     pub node_to_image_map: FxHashMap<OpaqueNode, ImageAnimationState>,
+
+    /// A list of nodes with in-progress image animations.
+    rooted_nodes: DomRefCell<FxHashMap<NoTrace<OpaqueNode>, Dom<Node>>>,
 }
 
 impl ImageAnimationManager {
     pub fn new() -> Self {
         ImageAnimationManager {
             node_to_image_map: Default::default(),
+            rooted_nodes: DomRefCell::new(FxHashMap::default()),
         }
     }
 
@@ -25,5 +42,81 @@ impl ImageAnimationManager {
 
     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> {
+        self.node_to_image_map
+            .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 fn update_active_frames(&mut self, window: &Window, now: f64) {
+        let rooted_nodes = self.rooted_nodes.borrow();
+        let updates: Vec<ImageUpdate> = self
+            .node_to_image_map
+            .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::OtherNodeDamage);
+                    }
+                    Some(ImageUpdate::UpdateImage(
+                        image.id.unwrap(),
+                        ImageDescriptor {
+                            format: ImageFormat::BGRA8,
+                            size: DeviceIntSize::new(image.width as i32, image.height as i32),
+                            stride: None,
+                            offset: 0,
+                            flags: ImageDescriptorFlags::ALLOW_MIPMAPS,
+                        },
+                        SerializableImageData::Raw(IpcSharedMemory::from_bytes(frame.bytes)),
+                    ))
+                } else {
+                    None
+                }
+            })
+            .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.
+    #[allow(unsafe_code)]
+    fn root_newly_animating_dom_nodes(&self) {
+        let mut rooted_nodes = self.rooted_nodes.borrow_mut();
+        for opaque_node in self.node_to_image_map.keys() {
+            let opaque_node = *opaque_node;
+            if rooted_nodes.contains_key(&NoTrace(opaque_node)) {
+                continue;
+            }
+            let address = UntrustedNodeAddress(opaque_node.0 as *const c_void);
+            unsafe {
+                rooted_nodes.insert(
+                    NoTrace(opaque_node),
+                    Dom::from_ref(&*from_untrusted_node_address(address)),
+                )
+            };
+        }
     }
 }

components/script/script_thread.rs

@@ -1289,6 +1289,10 @@ impl ScriptThread {
 
             // TODO: Mark paint timing from https://w3c.github.io/paint-timing.
 
+            // Update the rendering of those does not require a reflow.
+            // e.g. animated images.
+            document.update_animating_images();
+
             #[cfg(feature = "webgpu")]
             document.update_rendering_of_webgpu_canvases();
 

components/script/timers.rs

@@ -24,7 +24,9 @@ use crate::dom::bindings::refcounted::Trusted;
 use crate::dom::bindings::reflector::{DomGlobal, DomObject};
 use crate::dom::bindings::root::Dom;
 use crate::dom::bindings::str::DOMString;
-use crate::dom::document::{FakeRequestAnimationFrameCallback, RefreshRedirectDue};
+use crate::dom::document::{
+    FakeRequestAnimationFrameCallback, ImageAnimationUpdateCallback, RefreshRedirectDue,
+};
 use crate::dom::eventsource::EventSourceTimeoutCallback;
 use crate::dom::globalscope::GlobalScope;
 #[cfg(feature = "testbinding")]
@@ -83,6 +85,7 @@ pub(crate) enum OneshotTimerCallback {
     TestBindingCallback(TestBindingCallback),
     FakeRequestAnimationFrame(FakeRequestAnimationFrameCallback),
     RefreshRedirectDue(RefreshRedirectDue),
+    ImageAnimationUpdate(ImageAnimationUpdateCallback),
 }
 
 impl OneshotTimerCallback {
@@ -95,6 +98,7 @@ impl OneshotTimerCallback {
             OneshotTimerCallback::TestBindingCallback(callback) => callback.invoke(),
             OneshotTimerCallback::FakeRequestAnimationFrame(callback) => callback.invoke(can_gc),
             OneshotTimerCallback::RefreshRedirectDue(callback) => callback.invoke(can_gc),
+            OneshotTimerCallback::ImageAnimationUpdate(callback) => callback.invoke(can_gc),
         }
     }
 }