1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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 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()),
}
}
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> {
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)),
)
};
}
}
}
|
