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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
/* 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/. */
//! Restyle hints: an optimization to avoid unnecessarily matching selectors.
use crate::traversal_flags::TraversalFlags;
bitflags! {
/// The kind of restyle we need to do for a given element.
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct RestyleHint: u16 {
/// Do a selector match of the element.
const RESTYLE_SELF = 1 << 0;
/// Do a selector match of the element's pseudo-elements. Always to be combined with
/// RESTYLE_SELF.
const RESTYLE_PSEUDOS = 1 << 1;
/// Do a selector match if the element is a pseudo-element.
const RESTYLE_SELF_IF_PSEUDO = 1 << 2;
/// Do a selector match of the element's descendants.
const RESTYLE_DESCENDANTS = 1 << 3;
/// Recascade the current element.
const RECASCADE_SELF = 1 << 4;
/// Recascade the current element if it inherits any reset style.
const RECASCADE_SELF_IF_INHERIT_RESET_STYLE = 1 << 5;
/// Recascade all descendant elements.
const RECASCADE_DESCENDANTS = 1 << 6;
/// Replace the style data coming from CSS transitions without updating
/// any other style data. This hint is only processed in animation-only
/// traversal which is prior to normal traversal.
const RESTYLE_CSS_TRANSITIONS = 1 << 7;
/// Replace the style data coming from CSS animations without updating
/// any other style data. This hint is only processed in animation-only
/// traversal which is prior to normal traversal.
const RESTYLE_CSS_ANIMATIONS = 1 << 8;
/// Don't re-run selector-matching on the element, only the style
/// attribute has changed, and this change didn't have any other
/// dependencies.
const RESTYLE_STYLE_ATTRIBUTE = 1 << 9;
/// Replace the style data coming from SMIL animations without updating
/// any other style data. This hint is only processed in animation-only
/// traversal which is prior to normal traversal.
const RESTYLE_SMIL = 1 << 10;
/// Match self if this element is dependent on a style query.
const RESTYLE_IF_AFFECTED_BY_STYLE_QUERIES = 1 << 11;
/// Match self or descendants if dependent on a named style query.
const RESTYLE_IF_AFFECTED_BY_NAMED_STYLE_CONTAINER = 1 << 12;
/// Do a selector match of the element if it depends on an ancestor's font.
const RESTYLE_IF_AFFECTED_BY_ANCESTOR_FONT = 1 << 13;
}
}
impl RestyleHint {
/// Creates a new `RestyleHint` indicating that the current element and all
/// its descendants must be fully restyled.
#[inline]
pub fn restyle_subtree() -> Self {
RestyleHint::RESTYLE_SELF | RestyleHint::RESTYLE_DESCENDANTS
}
/// Creates a new `RestyleHint` indicating that the current element and all
/// its descendants must be recascaded.
#[inline]
pub fn recascade_subtree() -> Self {
RestyleHint::RECASCADE_SELF | RestyleHint::RECASCADE_DESCENDANTS
}
/// Returns whether this hint invalidates the element and all its
/// descendants.
#[inline]
pub fn contains_subtree(&self) -> bool {
self.contains(Self::restyle_subtree())
}
/// Returns whether we'll recascade all of the descendants.
#[inline]
pub fn will_recascade_subtree(&self) -> bool {
self.contains_subtree() || self.contains(Self::recascade_subtree())
}
/// Returns whether we need to restyle this element.
pub fn has_non_animation_invalidations(&self) -> bool {
!(*self & !Self::for_animations()).is_empty()
}
/// Propagates this restyle hint to a child element.
pub fn propagate(&mut self, traversal_flags: &TraversalFlags) -> Self {
use std::mem;
// In the middle of an animation only restyle, we don't need to
// propagate any restyle hints, and we need to remove ourselves.
if traversal_flags.for_animation_only() {
self.remove_animation_hints();
return Self::empty();
}
debug_assert!(
!self.has_animation_hint(),
"There should not be any animation restyle hints \
during normal traversal"
);
// Else we should clear ourselves, and return the propagated hint.
mem::replace(self, Self::empty()).propagate_for_non_animation_restyle()
}
/// Returns a new `RestyleHint` appropriate for children of the current element.
fn propagate_for_non_animation_restyle(&self) -> Self {
if self.contains(RestyleHint::RESTYLE_DESCENDANTS) {
return Self::restyle_subtree();
}
let mut result = Self::empty();
if self.contains(Self::RESTYLE_PSEUDOS) {
result |= Self::RESTYLE_SELF_IF_PSEUDO;
}
if self.contains(Self::RECASCADE_DESCENDANTS) {
result |= Self::recascade_subtree();
}
if self.contains(Self::RESTYLE_IF_AFFECTED_BY_ANCESTOR_FONT) {
result |= Self::RESTYLE_IF_AFFECTED_BY_ANCESTOR_FONT;
}
if self.contains(Self::RESTYLE_IF_AFFECTED_BY_NAMED_STYLE_CONTAINER) {
// We may need to restyle further down the tree if rules are
// declared for a named container.
// e.g @container my-name {#b {...}}
// and <div id=a> <div> <div id=b> </div> </div> </div>
// If a toggles `container-name: my-name` the rules for #b
// also invalidate. This is why we need one hint for unnamed
// container and one for named containers.
result |= Self::RESTYLE_IF_AFFECTED_BY_NAMED_STYLE_CONTAINER;
}
result
}
/// Returns a hint that contains all the replacement hints.
pub fn replacements() -> Self {
RestyleHint::RESTYLE_STYLE_ATTRIBUTE | Self::for_animations()
}
/// The replacements for the animation cascade levels.
#[inline]
pub fn for_animations() -> Self {
RestyleHint::RESTYLE_SMIL
| RestyleHint::RESTYLE_CSS_ANIMATIONS
| RestyleHint::RESTYLE_CSS_TRANSITIONS
}
/// Returns whether the hint specifies that an animation cascade level must
/// be replaced.
#[inline]
pub fn has_animation_hint(&self) -> bool {
self.intersects(Self::for_animations())
}
/// Returns whether the hint specifies that an animation cascade level must
/// be replaced.
#[inline]
pub fn has_animation_hint_or_recascade(&self) -> bool {
self.intersects(
Self::for_animations()
| Self::RECASCADE_SELF
| Self::RECASCADE_SELF_IF_INHERIT_RESET_STYLE,
)
}
/// Returns whether the hint specifies some restyle work other than an
/// animation cascade level replacement.
#[inline]
pub fn has_non_animation_hint(&self) -> bool {
!(*self & !Self::for_animations()).is_empty()
}
/// Returns whether the hint specifies that some cascade levels must be
/// replaced.
#[inline]
pub fn has_replacements(&self) -> bool {
self.intersects(Self::replacements())
}
/// Removes all of the animation-related hints.
#[inline]
pub fn remove_animation_hints(&mut self) {
self.remove(Self::for_animations());
// While RECASCADE_SELF is not animation-specific, we only ever add and process it during
// traversal. If we are here, removing animation hints, then we are in an animation-only
// traversal, and we know that any RECASCADE_SELF flag must have been set due to changes in
// inherited values after restyling for animations, and thus we want to remove it so that
// we don't later try to restyle the element during a normal restyle.
// (We could have separate RECASCADE_SELF_NORMAL and RECASCADE_SELF_ANIMATIONS flags to
// make it clear, but this isn't currently necessary.)
self.remove(Self::RECASCADE_SELF | Self::RECASCADE_SELF_IF_INHERIT_RESET_STYLE);
}
}
impl Default for RestyleHint {
fn default() -> Self {
Self::empty()
}
}
#[cfg(feature = "servo")]
malloc_size_of::malloc_size_of_is_0!(RestyleHint);