Associated damage type WIP

Signed-off-by: Nico Burns <[email protected]>

Author: nicoburns

style/context.rs

@@ -9,7 +9,7 @@ use crate::animation::DocumentAnimationSet;
 use crate::bloom::StyleBloom;
 use crate::computed_value_flags::ComputedValueFlags;
 use crate::data::{EagerPseudoStyles, ElementData};
-use crate::dom::{SendElement, TElement};
+use crate::dom::{SendElement, TElement, TRestyleDamage};
 #[cfg(feature = "gecko")]
 use crate::gecko_bindings::structs;
 use crate::parallel::{STACK_SAFETY_MARGIN_KB, STYLE_THREAD_STACK_SIZE_KB};
@@ -263,7 +263,7 @@ pub struct ElementCascadeInputs {
 impl ElementCascadeInputs {
     /// Construct inputs from previous cascade results, if any.
     #[inline]
-    pub fn new_from_element_data(data: &ElementData) -> Self {
+    pub fn new_from_element_data<D: TRestyleDamage>(data: &ElementData<D>) -> Self {
         debug_assert!(data.has_styles());
         ElementCascadeInputs {
             primary: CascadeInputs::new_from_style(data.styles.primary()),

style/data.rs

@@ -6,11 +6,11 @@
 
 use crate::computed_value_flags::ComputedValueFlags;
 use crate::context::{SharedStyleContext, StackLimitChecker};
-use crate::dom::TElement;
+use crate::dom::{TElement, TRestyleDamage};
 use crate::invalidation::element::invalidator::InvalidationResult;
 use crate::invalidation::element::restyle_hints::RestyleHint;
 use crate::properties::ComputedValues;
-use crate::selector_parser::{PseudoElement, RestyleDamage, EAGER_PSEUDO_COUNT};
+use crate::selector_parser::{PseudoElement, EAGER_PSEUDO_COUNT};
 use crate::style_resolver::{PrimaryStyle, ResolvedElementStyles, ResolvedStyle};
 #[cfg(feature = "gecko")]
 use malloc_size_of::MallocSizeOfOps;
@@ -249,7 +249,7 @@ impl fmt::Debug for ElementStyles {
 /// inside of layout data, which itself hangs directly off the Element. In
 /// both cases, it is wrapped inside an AtomicRefCell to ensure thread safety.
 #[derive(Debug, Default)]
-pub struct ElementData {
+pub struct ElementData<RestyleDamage: TRestyleDamage> {
     /// The styles for the element and its pseudo-elements.
     pub styles: ElementStyles,
 
@@ -266,7 +266,14 @@ pub struct ElementData {
 }
 
 // There's one of these per rendered elements so it better be small.
-size_of_test!(ElementData, 24);
+// mod element_data_test {
+//     use crate::dom::TRestyleDamage;
+//     use super::ElementData;
+//     #[derive(Debug, Copy, Clone, Default)]
+//     struct SizeOfRestyleDamage(u32);
+//     impl TRestyleDamage for SizeOfRestyleDamage {}
+//     size_of_test!(ElementData<SizeOfRestyleDamage>, 24);
+// }
 
 /// The kind of restyle that a single element should do.
 #[derive(Debug)]
@@ -282,11 +289,11 @@ pub enum RestyleKind {
     CascadeOnly,
 }
 
-impl ElementData {
+impl<RestyleDamage: TRestyleDamage> ElementData<RestyleDamage> {
     /// Invalidates style for this element, its descendants, and later siblings,
     /// based on the snapshot of the element that we took when attributes or
     /// state changed.
-    pub fn invalidate_style_if_needed<'a, E: TElement>(
+    pub fn invalidate_style_if_needed<'a, E: TElement<RestyleDamage = RestyleDamage>>(
         &mut self,
         element: E,
         shared_context: &SharedStyleContext,
@@ -389,8 +396,8 @@ impl ElementData {
             return None;
         }
 
-        let needs_to_match_self = hint.intersects(RestyleHint::RESTYLE_SELF) ||
-            (hint.intersects(RestyleHint::RESTYLE_SELF_IF_PSEUDO) && style.is_pseudo_style());
+        let needs_to_match_self = hint.intersects(RestyleHint::RESTYLE_SELF)
+            || (hint.intersects(RestyleHint::RESTYLE_SELF_IF_PSEUDO) && style.is_pseudo_style());
         if needs_to_match_self {
             return Some(RestyleKind::MatchAndCascade);
         }
@@ -405,9 +412,9 @@ impl ElementData {
             ));
         }
 
-        let needs_to_recascade_self = hint.intersects(RestyleHint::RECASCADE_SELF) ||
-            (hint.intersects(RestyleHint::RECASCADE_SELF_IF_INHERIT_RESET_STYLE) &&
-                style
+        let needs_to_recascade_self = hint.intersects(RestyleHint::RECASCADE_SELF)
+            || (hint.intersects(RestyleHint::RECASCADE_SELF_IF_INHERIT_RESET_STYLE)
+                && style
                     .flags
                     .contains(ComputedValueFlags::INHERITS_RESET_STYLE));
         if needs_to_recascade_self {
@@ -447,9 +454,9 @@ impl ElementData {
             ));
         }
 
-        let needs_to_recascade_self = hint.intersects(RestyleHint::RECASCADE_SELF) ||
-            (hint.intersects(RestyleHint::RECASCADE_SELF_IF_INHERIT_RESET_STYLE) &&
-                style
+        let needs_to_recascade_self = hint.intersects(RestyleHint::RECASCADE_SELF)
+            || (hint.intersects(RestyleHint::RECASCADE_SELF_IF_INHERIT_RESET_STYLE)
+                && style
                     .flags
                     .contains(ComputedValueFlags::INHERITS_RESET_STYLE));
         if needs_to_recascade_self {
@@ -471,7 +478,7 @@ impl ElementData {
     /// Drops restyle flags and damage from the element.
     #[inline]
     pub fn clear_restyle_flags_and_damage(&mut self) {
-        self.damage = RestyleDamage::empty();
+        self.damage.clear();
         self.flags.remove(ElementDataFlags::WAS_RESTYLED);
     }
 
@@ -521,8 +528,8 @@ impl ElementData {
     /// we need for style sharing, the latter does not.
     pub fn safe_for_cousin_sharing(&self) -> bool {
         if self.flags.intersects(
-            ElementDataFlags::TRAVERSED_WITHOUT_STYLING |
-                ElementDataFlags::PRIMARY_STYLE_REUSED_VIA_RULE_NODE,
+            ElementDataFlags::TRAVERSED_WITHOUT_STYLING
+                | ElementDataFlags::PRIMARY_STYLE_REUSED_VIA_RULE_NODE,
         ) {
             return false;
         }

style/dom.rs

@@ -14,7 +14,7 @@ use crate::context::UpdateAnimationsTasks;
 use crate::data::ElementData;
 use crate::media_queries::Device;
 use crate::properties::{AnimationDeclarations, ComputedValues, PropertyDeclarationBlock};
-use crate::selector_parser::{AttrValue, Lang, PseudoElement, RestyleDamage, SelectorImpl};
+use crate::selector_parser::{AttrValue, Lang, PseudoElement, SelectorImpl};
 use crate::shared_lock::{Locked, SharedRwLock};
 use crate::stylesheets::scope_rule::ImplicitScopeRoot;
 use crate::stylist::CascadeData;
@@ -30,7 +30,7 @@ use servo_arc::{Arc, ArcBorrow};
 use std::fmt;
 use std::fmt::Debug;
 use std::hash::Hash;
-use std::ops::Deref;
+use std::ops::{BitOrAssign, Deref};
 
 pub use style_traits::dom::OpaqueNode;
 
@@ -383,13 +383,51 @@ pub trait TShadowRoot: Sized + Copy + Clone + Debug + PartialEq {
     }
 }
 
+/// Represents restyle damage (whether to repaint, relayout, etc based on changed styles)
+///
+/// Stylo is mostly agnostic to this type which is used by the embedder. This trait represents the
+/// minimal interface that Stylo does need to the type.
+pub trait TRestyleDamage: Copy + Clone + Default + Debug + BitOrAssign {
+    /// Clear/reset all damage flags
+    fn clear(&mut self);
+    /// Whether the damage is empty ("no styles changed")
+    fn is_empty(&self) -> bool;
+    /// Mark the element as needing it's (eager) pseudo-elements rebuilt
+    fn set_rebuild_pseudos(&mut self);
+}
+
+/// Represents the result of comparing an element's old and new style.
+#[derive(Debug)]
+pub struct StyleDifference<RestyleDamage: TRestyleDamage> {
+    /// The resulting damage.
+    pub damage: RestyleDamage,
+
+    /// Whether any styles changed.
+    pub change: StyleChange,
+}
+
+/// Represents whether or not the style of an element has changed.
+#[derive(Clone, Copy, Debug)]
+pub enum StyleChange {
+    /// The style hasn't changed.
+    Unchanged,
+    /// The style has changed.
+    Changed {
+        /// Whether only reset structs changed.
+        reset_only: bool,
+    },
+}
+
 /// The element trait, the main abstraction the style crate acts over.
 pub trait TElement:
     Eq + PartialEq + Debug + Hash + Sized + Copy + Clone + SelectorsElement<Impl = SelectorImpl>
 {
     /// The concrete node type.
     type ConcreteNode: TNode<ConcreteElement = Self>;
 
+    /// The type representing restyle damage flags
+    type RestyleDamage: TRestyleDamage;
+
     /// A concrete children iterator type in order to iterate over the `Node`s.
     ///
     /// TODO(emilio): We should eventually replace this with the `impl Trait`
@@ -583,7 +621,7 @@ pub trait TElement:
 
     /// Returns whether the element's styles are up-to-date after traversal
     /// (i.e. in post traversal).
-    fn has_current_styles(&self, data: &ElementData) -> bool {
+    fn has_current_styles(&self, data: &ElementData<Self::RestyleDamage>) -> bool {
         if self.has_snapshot() && !self.handled_snapshot() {
             return false;
         }
@@ -670,7 +708,7 @@ pub trait TElement:
     ///
     /// Unsafe because it can race to allocate and leak if not used with
     /// exclusive access to the element.
-    unsafe fn ensure_data(&self) -> AtomicRefMut<ElementData>;
+    unsafe fn ensure_data(&self) -> AtomicRefMut<ElementData<Self::RestyleDamage>>;
 
     /// Clears the element data reference, if any.
     ///
@@ -681,10 +719,10 @@ pub trait TElement:
     fn has_data(&self) -> bool;
 
     /// Immutably borrows the ElementData.
-    fn borrow_data(&self) -> Option<AtomicRef<ElementData>>;
+    fn borrow_data(&self) -> Option<AtomicRef<ElementData<Self::RestyleDamage>>>;
 
     /// Mutably borrows the ElementData.
-    fn mutate_data(&self) -> Option<AtomicRefMut<ElementData>>;
+    fn mutate_data(&self) -> Option<AtomicRefMut<ElementData<Self::RestyleDamage>>>;
 
     /// Whether we should skip any root- or item-based display property
     /// blockification on this element.  (This function exists so that Gecko
@@ -909,9 +947,20 @@ pub trait TElement:
         None
     }
 
-    /// Compute the damage incurred by the change from the `_old` to `_new`.
-    fn compute_layout_damage(_old: &ComputedValues, _new: &ComputedValues) -> RestyleDamage {
-        Default::default()
+    /// Given the old and new style of this element, and whether it's a
+    /// pseudo-element, compute the restyle damage used to determine which
+    /// kind of layout or painting operations we'll need.
+    fn compute_style_difference(
+        &self,
+        _old: &ComputedValues,
+        _new: &ComputedValues,
+        pseudo: Option<&PseudoElement>,
+    ) -> StyleDifference<Self::RestyleDamage> {
+        debug_assert!(pseudo.map_or(true, |p| p.is_eager()));
+        StyleDifference {
+            damage: Default::default(),
+            change: StyleChange::Unchanged,
+        }
     }
 }
 

style/invalidation/element/relative_selector.rs

@@ -1020,7 +1020,7 @@ pub struct RelativeSelectorOuterInvalidationProcessor<'a, 'b, E: TElement> {
     /// The current shadow host, if any.
     pub host: Option<OpaqueElement>,
     /// Data for the element being invalidated.
-    pub data: &'a mut ElementData,
+    pub data: &'a mut ElementData<E::RestyleDamage>,
     /// Dependency to be processed.
     pub dependency: &'b Dependency,
     /// Matching context to use for invalidation.

style/invalidation/element/state_and_attributes.rs

@@ -7,7 +7,7 @@
 
 use crate::context::SharedStyleContext;
 use crate::data::ElementData;
-use crate::dom::{TElement, TNode};
+use crate::dom::{TElement, TNode, TRestyleDamage};
 use crate::invalidation::element::element_wrapper::{ElementSnapshot, ElementWrapper};
 use crate::invalidation::element::invalidation_map::*;
 use crate::invalidation::element::invalidator::{
@@ -56,7 +56,7 @@ where
 pub struct StateAndAttrInvalidationProcessor<'a, 'b: 'a, E: TElement> {
     shared_context: &'a SharedStyleContext<'b>,
     element: E,
-    data: &'a mut ElementData,
+    data: &'a mut ElementData<E::RestyleDamage>,
     matching_context: MatchingContext<'a, E::Impl>,
     traversal_map: SiblingTraversalMap<E>,
 }
@@ -66,7 +66,7 @@ impl<'a, 'b: 'a, E: TElement + 'b> StateAndAttrInvalidationProcessor<'a, 'b, E>
     pub fn new(
         shared_context: &'a SharedStyleContext<'b>,
         element: E,
-        data: &'a mut ElementData,
+        data: &'a mut ElementData<E::RestyleDamage>,
         selector_caches: &'a mut SelectorCaches,
     ) -> Self {
         let matching_context = MatchingContext::new_for_visited(
@@ -125,7 +125,7 @@ where
 
 /// Whether we should process the descendants of a given element for style
 /// invalidation.
-pub fn should_process_descendants(data: &ElementData) -> bool {
+pub fn should_process_descendants<D: TRestyleDamage>(data: &ElementData<D>) -> bool {
     !data.styles.is_display_none() && !data.hint.contains(RestyleHint::RESTYLE_DESCENDANTS)
 }
 

style/matching.rs

@@ -13,15 +13,15 @@ use crate::context::CascadeInputs;
 use crate::context::{ElementCascadeInputs, QuirksMode};
 use crate::context::{SharedStyleContext, StyleContext};
 use crate::data::{ElementData, ElementStyles};
-use crate::dom::TElement;
+use crate::dom::{TElement, TRestyleDamage, StyleChange};
 #[cfg(feature = "servo")]
 use crate::dom::TNode;
 use crate::invalidation::element::restyle_hints::RestyleHint;
 use crate::properties::longhands::display::computed_value::T as Display;
 use crate::properties::ComputedValues;
 use crate::properties::PropertyDeclarationBlock;
 use crate::rule_tree::{CascadeLevel, StrongRuleNode};
-use crate::selector_parser::{PseudoElement, RestyleDamage};
+use crate::selector_parser::{PseudoElement};
 use crate::shared_lock::Locked;
 use crate::style_resolver::StyleResolverForElement;
 use crate::style_resolver::{PseudoElementResolution, ResolvedElementStyles};
@@ -30,28 +30,6 @@ use crate::stylist::RuleInclusion;
 use crate::traversal_flags::TraversalFlags;
 use servo_arc::{Arc, ArcBorrow};
 
-/// Represents the result of comparing an element's old and new style.
-#[derive(Debug)]
-pub struct StyleDifference {
-    /// The resulting damage.
-    pub damage: RestyleDamage,
-
-    /// Whether any styles changed.
-    pub change: StyleChange,
-}
-
-/// Represents whether or not the style of an element has changed.
-#[derive(Clone, Copy, Debug)]
-pub enum StyleChange {
-    /// The style hasn't changed.
-    Unchanged,
-    /// The style has changed.
-    Changed {
-        /// Whether only reset structs changed.
-        reset_only: bool,
-    },
-}
-
 /// Whether or not newly computed values for an element need to be cascaded to
 /// children (or children might need to be re-matched, e.g., for container
 /// queries).
@@ -778,7 +756,7 @@ trait PrivateMatchMethods: TElement {
     fn accumulate_damage_for(
         &self,
         shared_context: &SharedStyleContext,
-        damage: &mut RestyleDamage,
+        damage: &mut Self::RestyleDamage,
         old_values: &ComputedValues,
         new_values: &ComputedValues,
         pseudo: Option<&PseudoElement>,
@@ -937,7 +915,7 @@ pub trait MatchMethods: TElement {
     fn finish_restyle(
         &self,
         context: &mut StyleContext<Self>,
-        data: &mut ElementData,
+        data: &mut ElementData<Self::RestyleDamage>,
         mut new_styles: ResolvedElementStyles,
         important_rules_changed: bool,
     ) -> ChildRestyleRequirement {
@@ -1120,7 +1098,7 @@ pub trait MatchMethods: TElement {
                     let old_pseudo_should_exist =
                         old.as_ref().map_or(false, |s| pseudo.should_exist(s));
                     if new_pseudo_should_exist != old_pseudo_should_exist {
-                        data.damage |= RestyleDamage::reconstruct();
+                        data.damage.set_rebuild_pseudos();
                         return restyle_requirement;
                     }
                 },
@@ -1155,19 +1133,6 @@ pub trait MatchMethods: TElement {
         );
         result
     }
-
-    /// Given the old and new style of this element, and whether it's a
-    /// pseudo-element, compute the restyle damage used to determine which
-    /// kind of layout or painting operations we'll need.
-    fn compute_style_difference(
-        &self,
-        old_values: &ComputedValues,
-        new_values: &ComputedValues,
-        pseudo: Option<&PseudoElement>,
-    ) -> StyleDifference {
-        debug_assert!(pseudo.map_or(true, |p| p.is_eager()));
-        RestyleDamage::compute_style_difference::<Self>(old_values, new_values)
-    }
 }
 
 impl<E: TElement> MatchMethods for E {}