blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/driver.rs

@@ -0,0 +1,172 @@
+/* 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/. */
+
+//! Implements traversal over the DOM tree. The traversal starts in sequential
+//! mode, and optionally parallelizes as it discovers work.
+
+#![deny(missing_docs)]
+
+use crate::context::{PerThreadTraversalStatistics, StyleContext};
+use crate::context::{ThreadLocalStyleContext, TraversalStatistics};
+use crate::dom::{SendNode, TElement, TNode};
+use crate::parallel;
+use crate::scoped_tls::ScopedTLS;
+use crate::traversal::{DomTraversal, PreTraverseToken};
+use std::collections::VecDeque;
+use std::time::Instant;
+
+#[cfg(feature = "servo")]
+fn should_report_statistics() -> bool {
+    false
+}
+
+#[cfg(feature = "gecko")]
+fn should_report_statistics() -> bool {
+    unsafe { !crate::gecko_bindings::structs::ServoTraversalStatistics_sSingleton.is_null() }
+}
+
+#[cfg(feature = "servo")]
+fn report_statistics(_stats: &PerThreadTraversalStatistics) {
+    unreachable!("Servo never report stats");
+}
+
+#[cfg(feature = "gecko")]
+fn report_statistics(stats: &PerThreadTraversalStatistics) {
+    // This should only be called in the main thread, or it may be racy
+    // to update the statistics in a global variable.
+    unsafe {
+        debug_assert!(crate::gecko_bindings::bindings::Gecko_IsMainThread());
+        let gecko_stats = crate::gecko_bindings::structs::ServoTraversalStatistics_sSingleton;
+        (*gecko_stats).mElementsTraversed += stats.elements_traversed;
+        (*gecko_stats).mElementsStyled += stats.elements_styled;
+        (*gecko_stats).mElementsMatched += stats.elements_matched;
+        (*gecko_stats).mStylesShared += stats.styles_shared;
+        (*gecko_stats).mStylesReused += stats.styles_reused;
+    }
+}
+
+fn with_pool_in_place_scope<'scope>(
+    work_unit_max: usize,
+    pool: Option<&rayon::ThreadPool>,
+    closure: impl FnOnce(Option<&rayon::ScopeFifo<'scope>>) + Send + 'scope,
+) {
+    if work_unit_max == 0 || pool.is_none() {
+        closure(None);
+    } else {
+        let pool = pool.unwrap();
+        pool.in_place_scope_fifo(|scope| {
+            #[cfg(feature = "gecko")]
+            debug_assert_eq!(
+                pool.current_thread_index(),
+                Some(0),
+                "Main thread should be the first thread"
+            );
+            if cfg!(feature = "gecko") || pool.current_thread_index().is_some() {
+                closure(Some(scope));
+            } else {
+                scope.spawn_fifo(|scope| closure(Some(scope)));
+            }
+        });
+    }
+}
+
+/// See documentation of the pref for performance characteristics.
+fn work_unit_max() -> usize {
+    crate::pref!("layout.css.stylo-work-unit-size") as usize
+}
+
+/// Do a DOM traversal for top-down and (optionally) bottom-up processing, generic over `D`.
+///
+/// We use an adaptive traversal strategy. We start out with simple sequential processing, until we
+/// arrive at a wide enough level in the DOM that the parallel traversal would parallelize it.
+/// If a thread pool is provided, we then transfer control over to the parallel traversal.
+///
+/// Returns true if the traversal was parallel, and also returns the statistics object containing
+/// information on nodes traversed (on nightly only). Not all of its fields will be initialized
+/// since we don't call finish().
+pub fn traverse_dom<E, D>(
+    traversal: &D,
+    token: PreTraverseToken<E>,
+    pool: Option<&rayon::ThreadPool>,
+) -> E
+where
+    E: TElement,
+    D: DomTraversal<E>,
+{
+    let root = token
+        .traversal_root()
+        .expect("Should've ensured we needed to traverse");
+
+    let report_stats = should_report_statistics();
+    let dump_stats = traversal.shared_context().options.dump_style_statistics;
+    let start_time = if dump_stats {
+        Some(Instant::now())
+    } else {
+        None
+    };
+
+    // Declare the main-thread context, as well as the worker-thread contexts,
+    // which we may or may not instantiate. It's important to declare the worker-
+    // thread contexts first, so that they get dropped second. This matters because:
+    //   * ThreadLocalContexts borrow AtomicRefCells in TLS.
+    //   * Dropping a ThreadLocalContext can run SequentialTasks.
+    //   * Sequential tasks may call into functions like
+    //     Servo_StyleSet_GetBaseComputedValuesForElement, which instantiate a
+    //     ThreadLocalStyleContext on the main thread. If the main thread
+    //     ThreadLocalStyleContext has not released its TLS borrow by that point,
+    //     we'll panic on double-borrow.
+    let mut scoped_tls = ScopedTLS::<ThreadLocalStyleContext<E>>::new(pool);
+    // Process the nodes breadth-first. This helps keep similar traversal characteristics for the
+    // style sharing cache.
+    let work_unit_max = work_unit_max();
+
+    let send_root = unsafe { SendNode::new(root.as_node()) };
+    with_pool_in_place_scope(work_unit_max, pool, |maybe_scope| {
+        let mut tlc = scoped_tls.ensure(parallel::create_thread_local_context);
+        tlc.current_dom_depth = send_root.depth();
+
+        let mut context = StyleContext {
+            shared: traversal.shared_context(),
+            thread_local: &mut tlc,
+        };
+
+        let mut discovered = VecDeque::with_capacity(work_unit_max * 2);
+        let opaque_root = send_root.opaque();
+        discovered.push_back(send_root);
+        parallel::style_trees(
+            &mut context,
+            discovered,
+            opaque_root,
+            work_unit_max,
+            maybe_scope,
+            traversal,
+            &scoped_tls,
+        );
+    });
+
+    // Collect statistics from thread-locals if requested.
+    if dump_stats || report_stats {
+        let mut aggregate = PerThreadTraversalStatistics::default();
+        for slot in scoped_tls.slots() {
+            if let Some(cx) = slot.get_mut() {
+                aggregate += cx.statistics.clone();
+            }
+        }
+
+        if report_stats {
+            report_statistics(&aggregate);
+        }
+        // dump statistics to stdout if requested
+        if dump_stats {
+            let parallel = pool.is_some();
+            let stats =
+                TraversalStatistics::new(aggregate, traversal, parallel, start_time.unwrap());
+            if stats.is_large {
+                println!("{}", stats);
+            }
+        }
+    }
+
+    root
+}

package/vendor/stylo/error_reporting.rs

@@ -0,0 +1,484 @@
+/* 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/. */
+
+//! Types used to report parsing errors.
+
+#![deny(missing_docs)]
+
+use crate::selector_parser::SelectorImpl;
+use crate::stylesheets::UrlExtraData;
+use cssparser::{BasicParseErrorKind, ParseErrorKind, SourceLocation};
+use selectors::SelectorList;
+use selectors::parser::{Combinator, Component, RelativeSelector, Selector};
+use selectors::visitor::{SelectorListKind, SelectorVisitor};
+use std::fmt;
+use style_traits::ParseError;
+
+/// Errors that can be encountered while parsing CSS.
+#[derive(Debug)]
+pub enum ContextualParseError<'a> {
+    /// A property declaration was not recognized.
+    UnsupportedPropertyDeclaration(&'a str, ParseError, &'a [SelectorList<SelectorImpl>]),
+    /// A property descriptor was not recognized.
+    UnsupportedPropertyDescriptor(&'a str, ParseError),
+    /// A font face descriptor was not recognized.
+    UnsupportedFontFaceDescriptor(&'a str, ParseError),
+    /// A font feature values descriptor was not recognized.
+    UnsupportedFontFeatureValuesDescriptor(&'a str, ParseError),
+    /// A font palette values descriptor was not recognized.
+    UnsupportedFontPaletteValuesDescriptor(&'a str, ParseError),
+    /// A keyframe rule was not valid.
+    InvalidKeyframeRule(&'a str, ParseError),
+    /// A font feature values rule was not valid.
+    InvalidFontFeatureValuesRule(&'a str, ParseError),
+    /// A rule was invalid for some reason.
+    InvalidRule(&'a str, ParseError),
+    /// A rule was not recognized.
+    UnsupportedRule(&'a str, ParseError),
+    /// A viewport descriptor declaration was not recognized.
+    UnsupportedViewportDescriptorDeclaration(&'a str, ParseError),
+    /// A counter style descriptor declaration was not recognized.
+    UnsupportedCounterStyleDescriptorDeclaration(&'a str, ParseError),
+    /// A counter style rule had no symbols.
+    InvalidCounterStyleWithoutSymbols(String),
+    /// A counter style rule had less than two symbols.
+    InvalidCounterStyleNotEnoughSymbols(String),
+    /// A counter style rule did not have additive-symbols.
+    InvalidCounterStyleWithoutAdditiveSymbols,
+    /// A counter style rule had extends with symbols.
+    InvalidCounterStyleExtendsWithSymbols,
+    /// A counter style rule had extends with additive-symbols.
+    InvalidCounterStyleExtendsWithAdditiveSymbols,
+    /// A media rule was invalid for some reason.
+    InvalidMediaRule(&'a str, ParseError),
+    /// A value was not recognized.
+    UnsupportedValue(&'a str, ParseError),
+    /// A never-matching `:host` selector was found.
+    NeverMatchingHostSelector(String),
+    /// A view-transition declaration was not recognized.
+    UnsupportedViewTransitionDescriptor(&'a str, ParseError),
+}
+
+impl<'a> fmt::Display for ContextualParseError<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fn parse_error_to_str(err: &ParseError, f: &mut fmt::Formatter) -> fmt::Result {
+            match err.kind {
+                ParseErrorKind::Basic(BasicParseErrorKind::UnexpectedToken) => {
+                    write!(f, "found unexpected token")
+                },
+                ParseErrorKind::Basic(BasicParseErrorKind::TooManyNestedBlocks) => {
+                    write!(f, "too many nested blocks")
+                },
+                ParseErrorKind::Basic(BasicParseErrorKind::EndOfInput) => {
+                    write!(f, "unexpected end of input")
+                },
+                ParseErrorKind::Basic(BasicParseErrorKind::AtRuleInvalid) => {
+                    write!(f, "@ rule invalid")
+                },
+                ParseErrorKind::Basic(BasicParseErrorKind::AtRuleBodyInvalid) => {
+                    write!(f, "@ rule invalid")
+                },
+                ParseErrorKind::Basic(BasicParseErrorKind::QualifiedRuleInvalid) => {
+                    write!(f, "qualified rule invalid")
+                },
+                ParseErrorKind::Custom(ref err) => write!(f, "{:?}", err),
+            }
+        }
+
+        match *self {
+            ContextualParseError::UnsupportedPropertyDeclaration(decl, ref err, _selectors) => {
+                write!(f, "Unsupported property declaration: '{}', ", decl)?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedPropertyDescriptor(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @property descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedFontFaceDescriptor(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @font-face descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedFontFeatureValuesDescriptor(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @font-feature-values descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedFontPaletteValuesDescriptor(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @font-palette-values descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::InvalidKeyframeRule(rule, ref err) => {
+                write!(f, "Invalid keyframe rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::InvalidFontFeatureValuesRule(rule, ref err) => {
+                write!(f, "Invalid font feature value rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::InvalidRule(rule, ref err) => {
+                write!(f, "Invalid rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedRule(rule, ref err) => {
+                write!(f, "Unsupported rule: '{}', ", rule)?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedViewportDescriptorDeclaration(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @viewport descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedCounterStyleDescriptorDeclaration(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @counter-style descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::InvalidCounterStyleWithoutSymbols(ref system) => write!(
+                f,
+                "Invalid @counter-style rule: 'system: {}' without 'symbols'",
+                system
+            ),
+            ContextualParseError::InvalidCounterStyleNotEnoughSymbols(ref system) => write!(
+                f,
+                "Invalid @counter-style rule: 'system: {}' less than two 'symbols'",
+                system
+            ),
+            ContextualParseError::InvalidCounterStyleWithoutAdditiveSymbols => write!(
+                f,
+                "Invalid @counter-style rule: 'system: additive' without 'additive-symbols'"
+            ),
+            ContextualParseError::InvalidCounterStyleExtendsWithSymbols => write!(
+                f,
+                "Invalid @counter-style rule: 'system: extends …' with 'symbols'"
+            ),
+            ContextualParseError::InvalidCounterStyleExtendsWithAdditiveSymbols => write!(
+                f,
+                "Invalid @counter-style rule: 'system: extends …' with 'additive-symbols'"
+            ),
+            ContextualParseError::InvalidMediaRule(media_rule, ref err) => {
+                write!(f, "Invalid media rule: {}, ", media_rule)?;
+                parse_error_to_str(err, f)
+            },
+            ContextualParseError::UnsupportedValue(_value, ref err) => parse_error_to_str(err, f),
+            ContextualParseError::NeverMatchingHostSelector(ref selector) => {
+                write!(f, ":host selector is not featureless: {}", selector)
+            },
+            ContextualParseError::UnsupportedViewTransitionDescriptor(decl, ref err) => {
+                write!(
+                    f,
+                    "Unsupported @view-transition descriptor declaration: '{}', ",
+                    decl
+                )?;
+                parse_error_to_str(err, f)
+            },
+        }
+    }
+}
+
+/// A generic trait for an error reporter.
+pub trait ParseErrorReporter {
+    /// Called when the style engine detects an error.
+    ///
+    /// Returns the current input being parsed, an approximate source location
+    /// for the error, and a message.
+    fn report_error(
+        &self,
+        url: &UrlExtraData,
+        location: SourceLocation,
+        error: ContextualParseError,
+    );
+}
+
+/// An error reporter that uses [the `log` crate](https://github.com/rust-lang-nursery/log)
+/// at `info` level.
+///
+/// This logging is silent by default, and can be enabled with a `RUST_LOG=style=info`
+/// environment variable.
+/// (See [`env_logger`](https://rust-lang-nursery.github.io/log/env_logger/).)
+#[cfg(feature = "servo")]
+pub struct RustLogReporter;
+
+#[cfg(feature = "servo")]
+impl ParseErrorReporter for RustLogReporter {
+    fn report_error(
+        &self,
+        url: &UrlExtraData,
+        location: SourceLocation,
+        error: ContextualParseError,
+    ) {
+        if log_enabled!(log::Level::Info) {
+            info!(
+                "Url:\t{}\n{}:{} {}",
+                url.as_str(),
+                location.line,
+                location.column,
+                error
+            )
+        }
+    }
+}
+
+/// Any warning a selector may generate.
+/// TODO(dshin): Bug 1860634 - Merge with never matching host selector warning, which is part of the rule parser.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum SelectorWarningKind {
+    /// Relative Selector with not enough constraint, either outside or inside the selector. e.g. `*:has(.a)`, `.a:has(*)`.
+    /// May cause expensive invalidations for every element inserted and/or removed.
+    UnconstraintedRelativeSelector,
+    /// `:scope` can have 3 meanings, but in all cases, the relationship is defined strictly by an ancestor-descendant
+    /// relationship. This means that any presence of sibling selectors to its right would make it never match.
+    SiblingCombinatorAfterScopeSelector,
+}
+
+impl SelectorWarningKind {
+    /// Get all warnings for this selector.
+    pub fn from_selector(selector: &Selector<SelectorImpl>) -> Vec<Self> {
+        let mut result = vec![];
+        if UnconstrainedRelativeSelectorVisitor::has_warning(selector, 0, false) {
+            result.push(SelectorWarningKind::UnconstraintedRelativeSelector);
+        }
+        if SiblingCombinatorAfterScopeSelectorVisitor::has_warning(selector) {
+            result.push(SelectorWarningKind::SiblingCombinatorAfterScopeSelector);
+        }
+        result
+    }
+}
+
+/// Per-compound state for finding unconstrained relative selectors.
+struct PerCompoundState {
+    /// Is there a relative selector in this compound?
+    relative_selector_found: bool,
+    /// Is this compound constrained in any way?
+    constrained: bool,
+    /// Nested below, or inside relative selector?
+    in_relative_selector: bool,
+}
+
+impl PerCompoundState {
+    fn new(in_relative_selector: bool) -> Self {
+        Self {
+            relative_selector_found: false,
+            constrained: false,
+            in_relative_selector,
+        }
+    }
+}
+
+/// Visitor to check if there's any unconstrained relative selector.
+struct UnconstrainedRelativeSelectorVisitor {
+    compound_state: PerCompoundState,
+}
+
+impl UnconstrainedRelativeSelectorVisitor {
+    fn new(in_relative_selector: bool) -> Self {
+        Self {
+            compound_state: PerCompoundState::new(in_relative_selector),
+        }
+    }
+
+    fn has_warning(
+        selector: &Selector<SelectorImpl>,
+        offset: usize,
+        in_relative_selector: bool,
+    ) -> bool {
+        let relative_selector = matches!(
+            selector.iter_raw_parse_order_from(0).next().unwrap(),
+            Component::RelativeSelectorAnchor
+        );
+        debug_assert!(
+            !relative_selector || offset == 0,
+            "Checking relative selector from non-rightmost?"
+        );
+        let mut visitor = Self::new(in_relative_selector);
+        let mut iter = if relative_selector {
+            selector.iter_skip_relative_selector_anchor()
+        } else {
+            selector.iter_from(offset)
+        };
+        loop {
+            visitor.compound_state = PerCompoundState::new(in_relative_selector);
+
+            for s in &mut iter {
+                s.visit(&mut visitor);
+            }
+
+            if (visitor.compound_state.relative_selector_found
+                || visitor.compound_state.in_relative_selector)
+                && !visitor.compound_state.constrained
+            {
+                return true;
+            }
+
+            if iter.next_sequence().is_none() {
+                break;
+            }
+        }
+        false
+    }
+}
+
+impl SelectorVisitor for UnconstrainedRelativeSelectorVisitor {
+    type Impl = SelectorImpl;
+
+    fn visit_simple_selector(&mut self, c: &Component<Self::Impl>) -> bool {
+        match c {
+            // Deferred to visit_selector_list
+            Component::Is(..)
+            | Component::Where(..)
+            | Component::Negation(..)
+            | Component::Has(..) => (),
+            Component::ExplicitUniversalType => (),
+            _ => self.compound_state.constrained |= true,
+        };
+        true
+    }
+
+    fn visit_selector_list(
+        &mut self,
+        _list_kind: SelectorListKind,
+        list: &[Selector<Self::Impl>],
+    ) -> bool {
+        let mut all_constrained = true;
+        for s in list {
+            let mut offset = 0;
+            // First, check the rightmost compound for constraint at this level.
+            if !self.compound_state.in_relative_selector {
+                let mut nested = Self::new(false);
+                let mut iter = s.iter();
+                loop {
+                    for c in &mut iter {
+                        c.visit(&mut nested);
+                        offset += 1;
+                    }
+
+                    let c = iter.next_sequence();
+                    offset += 1;
+                    if c.is_none_or(|c| !c.is_pseudo_element()) {
+                        break;
+                    }
+                }
+                // Every single selector in the list must be constrained.
+                all_constrained &= nested.compound_state.constrained;
+            }
+
+            if offset >= s.len() {
+                continue;
+            }
+
+            // Then, recurse in to check at the deeper level.
+            if Self::has_warning(s, offset, self.compound_state.in_relative_selector) {
+                self.compound_state.constrained = false;
+                if !self.compound_state.in_relative_selector {
+                    self.compound_state.relative_selector_found = true;
+                }
+                return false;
+            }
+        }
+        self.compound_state.constrained |= all_constrained;
+        true
+    }
+
+    fn visit_relative_selector_list(&mut self, list: &[RelativeSelector<Self::Impl>]) -> bool {
+        debug_assert!(
+            !self.compound_state.in_relative_selector,
+            "Nested relative selector"
+        );
+        self.compound_state.relative_selector_found = true;
+
+        for rs in list {
+            // If the inside is unconstrained, we are unconstrained no matter what.
+            if Self::has_warning(&rs.selector, 0, true) {
+                self.compound_state.constrained = false;
+                return false;
+            }
+        }
+        true
+    }
+}
+
+struct SiblingCombinatorAfterScopeSelectorVisitor {
+    right_combinator_is_sibling: bool,
+    found: bool,
+}
+
+impl SiblingCombinatorAfterScopeSelectorVisitor {
+    fn new(right_combinator_is_sibling: bool) -> Self {
+        Self {
+            right_combinator_is_sibling,
+            found: false,
+        }
+    }
+    fn has_warning(selector: &Selector<SelectorImpl>) -> bool {
+        if !selector.has_scope_selector() {
+            return false;
+        }
+        let visitor = SiblingCombinatorAfterScopeSelectorVisitor::new(false);
+        visitor.find_never_matching_scope_selector(selector)
+    }
+
+    fn find_never_matching_scope_selector(mut self, selector: &Selector<SelectorImpl>) -> bool {
+        selector.visit(&mut self);
+        self.found
+    }
+}
+
+impl SelectorVisitor for SiblingCombinatorAfterScopeSelectorVisitor {
+    type Impl = SelectorImpl;
+
+    fn visit_simple_selector(&mut self, c: &Component<Self::Impl>) -> bool {
+        if !matches!(c, Component::Scope | Component::ImplicitScope) {
+            return true;
+        }
+        // e.g. `:scope ~ .a` will never match.
+        if self.right_combinator_is_sibling {
+            self.found = true;
+        }
+        true
+    }
+
+    fn visit_selector_list(
+        &mut self,
+        _list_kind: SelectorListKind,
+        list: &[Selector<Self::Impl>],
+    ) -> bool {
+        for s in list {
+            let list_visitor = Self::new(self.right_combinator_is_sibling);
+            self.found |= list_visitor.find_never_matching_scope_selector(s);
+        }
+        true
+    }
+
+    fn visit_complex_selector(&mut self, combinator_to_right: Option<Combinator>) -> bool {
+        if let Some(c) = combinator_to_right {
+            // Subject compounds' state is determined by the outer visitor. e.g: When there's `:is(.a .b) ~ .c`,
+            // the inner visitor is assumed to be constructed with right_combinator_is_sibling == true.
+            self.right_combinator_is_sibling = c.is_sibling();
+        }
+        true
+    }
+
+    // It's harder to discern if use of :scope <sibling-combinator> is invalid - at least for now, defer.
+}