blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/rule_tree/mod.rs

@@ -0,0 +1,427 @@
+/* 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/. */
+
+#![deny(unsafe_code)]
+
+//! The rule tree.
+
+use crate::applicable_declarations::{ApplicableDeclarationList, CascadePriority};
+use crate::properties::{LonghandIdSet, PropertyDeclarationBlock};
+use crate::shared_lock::{Locked, StylesheetGuards};
+use crate::stylesheets::layer_rule::LayerOrder;
+use servo_arc::ArcBorrow;
+use smallvec::SmallVec;
+use std::io::{self, Write};
+
+mod core;
+pub mod level;
+mod map;
+mod source;
+mod unsafe_box;
+
+pub use self::core::{RuleTree, StrongRuleNode};
+pub use self::level::{CascadeLevel, CascadeOrigin, ShadowCascadeOrder};
+pub use self::source::StyleSource;
+
+bitflags! {
+    /// Flags that are part of the cascade priority, and that we use to track
+    /// information about where the rule came from.
+    #[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+    pub struct RuleCascadeFlags: u8 {
+        /// Whether the rule is inside a @starting-style block.
+        const STARTING_STYLE = 1 << 0;
+        /// Whether the rule is inside an @appearance-base block.
+        const APPEARANCE_BASE = 1 << 1;
+    }
+}
+
+malloc_size_of::malloc_size_of_is_0!(RuleCascadeFlags);
+
+impl RuleTree {
+    fn dump<W: Write>(&self, guards: &StylesheetGuards, writer: &mut W) {
+        let _ = writeln!(writer, " + RuleTree");
+        self.root().dump(guards, writer, 0);
+    }
+
+    /// Dump the rule tree to stdout.
+    pub fn dump_stdout(&self, guards: &StylesheetGuards) {
+        let mut stdout = io::stdout();
+        self.dump(guards, &mut stdout);
+    }
+
+    /// Inserts the given rules, that must be in proper order by specifity, and
+    /// returns the corresponding rule node representing the last inserted one.
+    ///
+    /// !important rules are detected and inserted into the appropriate position
+    /// in the rule tree. This allows selector matching to ignore importance,
+    /// while still maintaining the appropriate cascade order in the rule tree.
+    pub fn insert_ordered_rules_with_important<'a, I>(
+        &self,
+        iter: I,
+        guards: &StylesheetGuards,
+    ) -> StrongRuleNode
+    where
+        I: Iterator<Item = (StyleSource, CascadePriority)>,
+    {
+        let mut current = self.root().clone();
+
+        let mut found_important = false;
+
+        let mut important_author = SmallVec::<[(StyleSource, CascadePriority); 4]>::new();
+        let mut important_user = SmallVec::<[(StyleSource, CascadePriority); 4]>::new();
+        let mut important_ua = SmallVec::<[(StyleSource, CascadePriority); 4]>::new();
+        let mut transition = None;
+
+        for (source, priority) in iter {
+            let level = priority.cascade_level();
+            debug_assert!(!level.is_important(), "Important levels handled internally");
+
+            let any_important = {
+                let pdb = source.read(level.guard(guards));
+                pdb.any_important()
+            };
+
+            if any_important {
+                found_important = true;
+                match level.origin() {
+                    CascadeOrigin::Author => {
+                        important_author.push((source.clone(), priority.important()))
+                    },
+                    CascadeOrigin::UA => important_ua.push((source.clone(), priority.important())),
+                    CascadeOrigin::User => {
+                        important_user.push((source.clone(), priority.important()))
+                    },
+                    _ => {},
+                };
+            }
+
+            // We don't optimize out empty rules, even though we could.
+            //
+            // Inspector relies on every rule being inserted in the normal level
+            // at least once, in order to return the rules with the correct
+            // specificity order.
+            //
+            // TODO(emilio): If we want to apply these optimizations without
+            // breaking inspector's expectations, we'd need to run
+            // selector-matching again at the inspector's request. That may or
+            // may not be a better trade-off.
+            if level.origin() == CascadeOrigin::Transitions && found_important {
+                // There can be at most one transition, and it will come at
+                // the end of the iterator. Stash it and apply it after
+                // !important rules.
+                debug_assert!(transition.is_none());
+                transition = Some(source);
+            } else {
+                current = current.ensure_child(self.root(), source, priority);
+            }
+        }
+
+        // Early-return in the common case of no !important declarations.
+        if !found_important {
+            return current;
+        }
+
+        // Insert important declarations, in order of increasing importance,
+        // followed by any transition rule.
+        //
+        // Important rules are sorted differently from unimportant ones by
+        // shadow order and cascade order.
+        if !important_author.is_empty()
+            && important_author.first().unwrap().1 != important_author.last().unwrap().1
+        {
+            // We only need to sort if the important rules come from
+            // different trees, but we need this sort to be stable.
+            //
+            // FIXME(emilio): This could maybe be smarter, probably by chunking
+            // the important rules while inserting, and iterating the outer
+            // chunks in reverse order.
+            //
+            // That is, if we have rules with levels like: -1 -1 -1 0 0 0 1 1 1,
+            // we're really only sorting the chunks, while keeping elements
+            // inside the same chunk already sorted. Seems like we could try to
+            // keep a SmallVec-of-SmallVecs with the chunks and just iterate the
+            // outer in reverse.
+            important_author.sort_by_key(|&(_, priority)| priority);
+        }
+
+        for (source, priority) in important_author.drain(..) {
+            current = current.ensure_child(self.root(), source, priority);
+        }
+
+        for (source, priority) in important_user.drain(..) {
+            current = current.ensure_child(self.root(), source, priority);
+        }
+
+        for (source, priority) in important_ua.drain(..) {
+            current = current.ensure_child(self.root(), source, priority);
+        }
+
+        if let Some(source) = transition {
+            current = current.ensure_child(
+                self.root(),
+                source,
+                CascadePriority::new(
+                    CascadeLevel::new(CascadeOrigin::Transitions),
+                    LayerOrder::root(),
+                    RuleCascadeFlags::empty(),
+                ),
+            );
+        }
+
+        current
+    }
+
+    /// Given a list of applicable declarations, insert the rules and return the
+    /// corresponding rule node.
+    pub fn compute_rule_node(
+        &self,
+        applicable_declarations: &mut ApplicableDeclarationList,
+        guards: &StylesheetGuards,
+    ) -> StrongRuleNode {
+        self.insert_ordered_rules_with_important(
+            applicable_declarations.drain(..).map(|d| d.for_rule_tree()),
+            guards,
+        )
+    }
+
+    /// Insert the given rules, that must be in proper order by specifity, and
+    /// return the corresponding rule node representing the last inserted one.
+    pub fn insert_ordered_rules<'a, I>(&self, iter: I) -> StrongRuleNode
+    where
+        I: Iterator<Item = (StyleSource, CascadePriority)>,
+    {
+        self.insert_ordered_rules_from(self.root().clone(), iter)
+    }
+
+    fn insert_ordered_rules_from<'a, I>(&self, from: StrongRuleNode, iter: I) -> StrongRuleNode
+    where
+        I: Iterator<Item = (StyleSource, CascadePriority)>,
+    {
+        let mut current = from;
+        for (source, priority) in iter {
+            current = current.ensure_child(self.root(), source, priority);
+        }
+        current
+    }
+
+    /// Replaces a rule in a given level (if present) for another rule.
+    ///
+    /// Returns the resulting node that represents the new path, or None if
+    /// the old path is still valid.
+    pub fn update_rule_at_level(
+        &self,
+        level: CascadeLevel,
+        layer_order: LayerOrder,
+        pdb: Option<ArcBorrow<Locked<PropertyDeclarationBlock>>>,
+        path: &StrongRuleNode,
+        guards: &StylesheetGuards,
+        important_rules_changed: &mut bool,
+    ) -> Option<StrongRuleNode> {
+        // TODO(emilio): Being smarter with lifetimes we could avoid a bit of
+        // the refcount churn.
+        let mut current = path.clone();
+        *important_rules_changed = false;
+
+        // First walk up until the first less-or-equally specific rule.
+        let mut children = SmallVec::<[_; 10]>::new();
+        while current.cascade_priority().cascade_level() > level {
+            children.push((
+                current.style_source().unwrap().clone(),
+                current.cascade_priority(),
+            ));
+            current = current.parent().unwrap().clone();
+        }
+
+        let cascade_priority = CascadePriority::new(level, layer_order, RuleCascadeFlags::empty());
+
+        // Then remove the one at the level we want to replace, if any.
+        //
+        // NOTE: Here we assume that only one rule can be at the level + priority we're replacing,
+        // which holds because we only use this for HTML style attribute, animations and transition
+        // rules.
+        //
+        // This is certainly true for HTML style attribute rules, animations, transitions, and
+        // SMIL.
+        if current.cascade_priority() == cascade_priority {
+            *important_rules_changed |= level.is_important();
+
+            let current_decls = current.style_source().unwrap().get();
+
+            // If the only rule at the level we're replacing is exactly the
+            // same as `pdb`, we're done, and `path` is still valid.
+            if let Some(ref pdb) = pdb {
+                // If the only rule at the level we're replacing is exactly the
+                // same as `pdb`, we're done, and `path` is still valid.
+                //
+                // TODO(emilio): Another potential optimization is the one where
+                // we can just replace the rule at that level for `pdb`, and
+                // then we don't need to re-create the children, and `path` is
+                // also equally valid. This is less likely, and would require an
+                // in-place mutation of the source, which is, at best, fiddly,
+                // so let's skip it for now.
+                let is_here_already = ArcBorrow::ptr_eq(pdb, &current_decls.borrow_arc());
+                if is_here_already {
+                    debug!("Picking the fast path in rule replacement");
+                    return None;
+                }
+            }
+
+            current = current.parent().unwrap().clone();
+        }
+
+        // Insert the rule if it's relevant at this level in the cascade.
+        //
+        // These optimizations are likely to be important, because the levels where replacements
+        // apply (style and animations) tend to trigger pretty bad styling cases already.
+        if let Some(pdb) = pdb {
+            if level.is_important() {
+                if pdb.read_with(level.guard(guards)).any_important() {
+                    current = current.ensure_child(
+                        self.root(),
+                        StyleSource::from_declarations(pdb.clone_arc()),
+                        cascade_priority,
+                    );
+                    *important_rules_changed = true;
+                }
+            } else if pdb.read_with(level.guard(guards)).any_normal() {
+                current = current.ensure_child(
+                    self.root(),
+                    StyleSource::from_declarations(pdb.clone_arc()),
+                    cascade_priority,
+                );
+            }
+        }
+
+        // Now the rule is in the relevant place, push the children as
+        // necessary.
+        let rule = self.insert_ordered_rules_from(current, children.drain(..).rev());
+        Some(rule)
+    }
+
+    /// Returns whether this rule node has any @starting-style rule.
+    pub fn has_starting_style(path: &StrongRuleNode) -> bool {
+        path.self_and_ancestors().any(|node| {
+            node.cascade_priority()
+                .flags()
+                .intersects(RuleCascadeFlags::STARTING_STYLE)
+        })
+    }
+
+    /// Returns new rule nodes without Transitions level rule.
+    pub fn remove_transition_rule_if_applicable(path: &StrongRuleNode) -> StrongRuleNode {
+        // Return a clone if there is no transition level.
+        if path.cascade_level().origin() != CascadeOrigin::Transitions {
+            return path.clone();
+        }
+
+        path.parent().unwrap().clone()
+    }
+
+    /// Returns new rule node without rules from declarative animations.
+    pub fn remove_animation_rules(&self, path: &StrongRuleNode) -> StrongRuleNode {
+        // Return a clone if there are no animation rules.
+        if !path.has_animation_or_transition_rules() {
+            return path.clone();
+        }
+
+        let iter = path.self_and_ancestors().take_while(|node| {
+            node.cascade_level() >= CascadeLevel::new(CascadeOrigin::SMILOverride)
+        });
+        let mut last = path;
+        let mut children = SmallVec::<[_; 10]>::new();
+        for node in iter {
+            if !node.cascade_level().is_animation() {
+                children.push((
+                    node.style_source().unwrap().clone(),
+                    node.cascade_priority(),
+                ));
+            }
+            last = node;
+        }
+
+        let rule = self
+            .insert_ordered_rules_from(last.parent().unwrap().clone(), children.drain(..).rev());
+        rule
+    }
+}
+
+impl StrongRuleNode {
+    /// Get an iterator for this rule node and its ancestors.
+    pub fn self_and_ancestors(&self) -> SelfAndAncestors<'_> {
+        SelfAndAncestors {
+            current: Some(self),
+        }
+    }
+
+    /// Returns true if there is either animation or transition level rule.
+    pub fn has_animation_or_transition_rules(&self) -> bool {
+        self.self_and_ancestors()
+            .take_while(|node| {
+                node.cascade_level() >= CascadeLevel::new(CascadeOrigin::SMILOverride)
+            })
+            .any(|node| node.cascade_level().is_animation())
+    }
+
+    /// Get a set of properties whose CascadeLevel are higher than Animations
+    /// but not equal to Transitions.
+    ///
+    /// If there are any custom properties, we set the boolean value of the
+    /// returned tuple to true.
+    pub fn get_properties_overriding_animations(
+        &self,
+        guards: &StylesheetGuards,
+    ) -> (LonghandIdSet, bool) {
+        use crate::properties::PropertyDeclarationId;
+
+        // We want to iterate over cascade levels that override the animations
+        // level, i.e.  !important levels and the transitions level.
+        //
+        // However, we actually want to skip the transitions level because
+        // although it is higher in the cascade than animations, when both
+        // transitions and animations are present for a given element and
+        // property, transitions are suppressed so that they don't actually
+        // override animations.
+        let iter = self
+            .self_and_ancestors()
+            .skip_while(|node| node.cascade_level().origin() == CascadeOrigin::Transitions)
+            .take_while(|node| node.cascade_level() > CascadeLevel::new(CascadeOrigin::Animations));
+        let mut result = (LonghandIdSet::new(), false);
+        for node in iter {
+            let style = node.style_source().unwrap();
+            for (decl, important) in style
+                .read(node.cascade_level().guard(guards))
+                .declaration_importance_iter()
+            {
+                // Although we are only iterating over cascade levels that
+                // override animations, in a given property declaration block we
+                // can have a mixture of !important and non-!important
+                // declarations but only the !important declarations actually
+                // override animations.
+                if important.important() {
+                    match decl.id() {
+                        PropertyDeclarationId::Longhand(id) => result.0.insert(id),
+                        PropertyDeclarationId::Custom(_) => result.1 = true,
+                    }
+                }
+            }
+        }
+        result
+    }
+}
+
+/// An iterator over a rule node and its ancestors.
+#[derive(Clone)]
+pub struct SelfAndAncestors<'a> {
+    current: Option<&'a StrongRuleNode>,
+}
+
+impl<'a> Iterator for SelfAndAncestors<'a> {
+    type Item = &'a StrongRuleNode;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.current.inspect(|node| {
+            self.current = node.parent();
+        })
+    }
+}

package/vendor/stylo/rule_tree/source.rs

@@ -0,0 +1,80 @@
+/* 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/. */
+
+#![deny(unsafe_code)]
+
+use crate::properties::PropertyDeclarationBlock;
+use crate::shared_lock::{Locked, SharedRwLockReadGuard};
+use servo_arc::Arc;
+use std::io::Write;
+use std::ptr;
+
+/// A style source for the rule node. It is a declaration block that may come from either a style
+/// rule or a standalone block like animations / transitions / smil / preshints / style attr...
+///
+/// Keeping the style rule around would provide more debugability, but also causes more
+/// pointer-chasing in the common code-path, which is undesired. If needed, we could keep it around
+/// in debug builds or something along those lines.
+#[derive(Clone, Debug)]
+pub struct StyleSource(Arc<Locked<PropertyDeclarationBlock>>);
+
+impl PartialEq for StyleSource {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl StyleSource {
+    #[inline]
+    pub(super) fn key(&self) -> ptr::NonNull<()> {
+        self.0.raw_ptr()
+    }
+
+    /// Creates a StyleSource from a PropertyDeclarationBlock.
+    #[inline]
+    pub fn from_declarations(decls: Arc<Locked<PropertyDeclarationBlock>>) -> Self {
+        Self(decls)
+    }
+
+    pub(super) fn dump<W: Write>(&self, guard: &SharedRwLockReadGuard, writer: &mut W) {
+        let _ = write!(writer, "  -> {:?}", self.read(guard).declarations());
+    }
+
+    /// Read the style source guard, and obtain thus read access to the
+    /// underlying property declaration block.
+    #[inline]
+    pub fn read<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> &'a PropertyDeclarationBlock {
+        self.0.read_with(guard)
+    }
+
+    /// Returns the declaration block if applicable, otherwise None.
+    #[inline]
+    pub fn get(&self) -> &Arc<Locked<PropertyDeclarationBlock>> {
+        &self.0
+    }
+
+    /// Marks this block as part of the rule tree.
+    #[inline]
+    pub fn mark_in_rule_tree(&self) {
+        use std::sync::atomic::Ordering;
+        if self.0.is_static() {
+            // For static pointers, it doesn't matter whether we might be in the rule tree or not,
+            // because those are not mutable.
+            return;
+        }
+        // SAFETY: We're only accessing a relaxed atomic inside the locked object, which we know
+        // is alive. In theory, we could/should track that boolean outside of the
+        // Locked<PropertyDeclarationBlock>, but that is kind of a PITA.
+        #[allow(unsafe_code)]
+        unsafe {
+            // Load before storing: the flag is never cleared, so after the first mark every
+            // store is redundant, and an unconditional store would still take the cache line
+            // exclusive and invalidate it for every other thread reading this block.
+            let immutable = &self.0.read_unchecked().immutable;
+            if !immutable.load(Ordering::Relaxed) {
+                immutable.store(true, Ordering::Relaxed);
+            }
+        }
+    }
+}

package/vendor/stylo/rule_tree/unsafe_box.rs

@@ -0,0 +1,78 @@
+/* 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/. */
+
+#![allow(unsafe_code)]
+
+use std::mem::ManuallyDrop;
+use std::ops::Deref;
+use std::ptr;
+
+/// An unsafe box, derefs to `T`.
+pub(super) struct UnsafeBox<T> {
+    inner: ManuallyDrop<Box<T>>,
+}
+
+impl<T> UnsafeBox<T> {
+    /// Creates a new unsafe box.
+    pub(super) fn from_box(value: Box<T>) -> Self {
+        Self {
+            inner: ManuallyDrop::new(value),
+        }
+    }
+
+    /// Creates a new box from a pointer.
+    ///
+    /// # Safety
+    ///
+    /// The input should point to a valid `T`.
+    pub(super) unsafe fn from_raw(ptr: *mut T) -> Self {
+        unsafe {
+            Self {
+                inner: ManuallyDrop::new(Box::from_raw(ptr)),
+            }
+        }
+    }
+
+    /// Creates a new unsafe box from an existing one.
+    ///
+    /// # Safety
+    ///
+    /// There is no refcounting or whatever else in an unsafe box, so this
+    /// operation can lead to double frees.
+    pub(super) unsafe fn clone(this: &Self) -> Self {
+        unsafe {
+            Self {
+                inner: ptr::read(&this.inner),
+            }
+        }
+    }
+
+    /// Returns a mutable reference to the inner value of this unsafe box.
+    ///
+    /// # Safety
+    ///
+    /// Given `Self::clone`, nothing prevents anyone from creating
+    /// multiple mutable references to the inner value, which is completely UB.
+    pub(crate) unsafe fn deref_mut(this: &mut Self) -> &mut T {
+        &mut this.inner
+    }
+
+    /// Drops the inner value of this unsafe box.
+    ///
+    /// # Safety
+    ///
+    /// Given this doesn't consume the unsafe box itself, this has the same
+    /// safety caveats as `ManuallyDrop::drop`.
+    pub(super) unsafe fn drop(this: &mut Self) {
+        unsafe { ManuallyDrop::drop(&mut this.inner) }
+    }
+}
+
+impl<T> Deref for UnsafeBox<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

package/vendor/stylo/scoped_tls.rs

@@ -0,0 +1,80 @@
+/* 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/. */
+
+//! Stack-scoped thread-local storage for rayon thread pools.
+
+#![allow(unsafe_code)]
+#![deny(missing_docs)]
+
+use crate::global_style_data::STYLO_MAX_THREADS;
+use std::cell::{Ref, RefCell, RefMut};
+use std::ops::DerefMut;
+
+/// A scoped TLS set, that is alive during the `'scope` lifetime.
+///
+/// We use this on Servo to construct thread-local contexts, but clear them once
+/// we're done with restyling.
+///
+/// Note that the cleanup is done on the thread that owns the scoped TLS, thus
+/// the Send bound.
+pub struct ScopedTLS<'scope, T: Send> {
+    pool: Option<&'scope rayon::ThreadPool>,
+    slots: [RefCell<Option<T>>; STYLO_MAX_THREADS],
+}
+
+/// The scoped TLS is `Sync` because no more than one worker thread can access a
+/// given slot.
+unsafe impl<'scope, T: Send> Sync for ScopedTLS<'scope, T> {}
+
+impl<'scope, T: Send> ScopedTLS<'scope, T> {
+    /// Create a new scoped TLS that will last as long as this rayon threadpool
+    /// reference.
+    pub fn new(pool: Option<&'scope rayon::ThreadPool>) -> Self {
+        debug_assert!(pool.is_none_or(|p| p.current_num_threads() <= STYLO_MAX_THREADS));
+        ScopedTLS {
+            pool,
+            slots: Default::default(),
+        }
+    }
+
+    /// Returns the index corresponding to the calling thread in the thread pool.
+    #[inline]
+    pub fn current_thread_index(&self) -> usize {
+        self.pool.map_or(0, |p| p.current_thread_index().unwrap())
+    }
+
+    /// Return an immutable reference to the `Option<T>` that this thread owns.
+    pub fn borrow(&self) -> Ref<'_, Option<T>> {
+        let idx = self.current_thread_index();
+        self.slots[idx].borrow()
+    }
+
+    /// Return a mutable reference to the `Option<T>` that this thread owns.
+    pub fn borrow_mut(&self) -> RefMut<'_, Option<T>> {
+        let idx = self.current_thread_index();
+        self.slots[idx].borrow_mut()
+    }
+
+    /// Ensure that the current data this thread owns is initialized, or
+    /// initialize it using `f`.  We want ensure() to be fast and inline, and we
+    /// want to inline the memmove that initializes the Option<T>.  But we don't
+    /// want to inline space for the entire large T struct in our stack frame.
+    /// That's why we hand `f` a mutable borrow to write to instead of just
+    /// having it return a T.
+    #[inline(always)]
+    pub fn ensure<F: FnOnce(&mut Option<T>)>(&self, f: F) -> RefMut<'_, T> {
+        let mut opt = self.borrow_mut();
+        if opt.is_none() {
+            f(opt.deref_mut());
+        }
+
+        RefMut::map(opt, |x| x.as_mut().unwrap())
+    }
+
+    /// Returns the slots. Safe because if we have a mut reference the tls can't be referenced by
+    /// any other thread.
+    pub fn slots(&mut self) -> &mut [RefCell<Option<T>>] {
+        &mut self.slots
+    }
+}