blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/stylesheets/scope_rule.rs

@@ -0,0 +1,511 @@
+/* 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/. */
+
+//! A [`@scope`][scope] rule.
+//!
+//! [scope]: https://drafts.csswg.org/css-cascade-6/#scoped-styles
+
+use crate::applicable_declarations::ScopeProximity;
+use crate::derives::*;
+use crate::dom::TElement;
+use crate::parser::ParserContext;
+use crate::selector_parser::{SelectorImpl, SelectorParser};
+use crate::shared_lock::{
+    DeepCloneWithLock, Locked, SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard,
+};
+use crate::simple_buckets_map::SimpleBucketsMap;
+use crate::stylesheets::CssRules;
+use cssparser::{Parser, SourceLocation, ToCss};
+#[cfg(feature = "gecko")]
+use malloc_size_of::{
+    MallocSizeOfOps, MallocUnconditionalShallowSizeOf, MallocUnconditionalSizeOf,
+};
+use selectors::context::{MatchingContext, QuirksMode};
+use selectors::matching::matches_selector;
+use selectors::parser::{Component, ParseRelative, Selector, SelectorList};
+use selectors::OpaqueElement;
+use servo_arc::Arc;
+use std::fmt::{self, Write};
+use style_traits::{CssStringWriter, CssWriter, ParseError};
+
+/// A scoped rule.
+#[derive(Debug, ToShmem)]
+pub struct ScopeRule {
+    /// Bounds at which this rule applies.
+    pub bounds: ScopeBounds,
+    /// The nested rules inside the block.
+    pub rules: Arc<Locked<CssRules>>,
+    /// The source position where this rule was found.
+    pub source_location: SourceLocation,
+}
+
+impl DeepCloneWithLock for ScopeRule {
+    fn deep_clone_with_lock(&self, lock: &SharedRwLock, guard: &SharedRwLockReadGuard) -> Self {
+        let rules = self.rules.read_with(guard);
+        Self {
+            bounds: self.bounds.clone(),
+            rules: Arc::new(lock.wrap(rules.deep_clone_with_lock(lock, guard))),
+            source_location: self.source_location,
+        }
+    }
+}
+
+impl ToCssWithGuard for ScopeRule {
+    fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
+        dest.write_str("@scope")?;
+        {
+            let mut writer = CssWriter::new(dest);
+            if let Some(start) = self.bounds.start.as_ref() {
+                writer.write_str(" (")?;
+                start.to_css(&mut writer)?;
+                writer.write_char(')')?;
+            }
+            if let Some(end) = self.bounds.end.as_ref() {
+                writer.write_str(" to (")?;
+                end.to_css(&mut writer)?;
+                writer.write_char(')')?;
+            }
+        }
+        self.rules.read_with(guard).to_css_block(guard, dest)
+    }
+}
+
+impl ScopeRule {
+    /// Measure heap usage.
+    #[cfg(feature = "gecko")]
+    pub fn size_of(&self, guard: &SharedRwLockReadGuard, ops: &mut MallocSizeOfOps) -> usize {
+        self.rules.unconditional_shallow_size_of(ops)
+            + self.rules.read_with(guard).size_of(guard, ops)
+            + self.bounds.size_of(ops)
+    }
+}
+
+/// Bounds of the scope.
+#[derive(Debug, Clone, ToShmem)]
+pub struct ScopeBounds {
+    /// Start of the scope.
+    pub start: Option<SelectorList<SelectorImpl>>,
+    /// End of the scope.
+    pub end: Option<SelectorList<SelectorImpl>>,
+}
+
+impl ScopeBounds {
+    #[cfg(feature = "gecko")]
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        fn bound_size_of(
+            bound: &Option<SelectorList<SelectorImpl>>,
+            ops: &mut MallocSizeOfOps,
+        ) -> usize {
+            bound
+                .as_ref()
+                .map(|list| list.unconditional_size_of(ops))
+                .unwrap_or(0)
+        }
+        bound_size_of(&self.start, ops) + bound_size_of(&self.end, ops)
+    }
+}
+
+fn parse_scope(
+    context: &ParserContext,
+    input: &mut Parser,
+    parse_relative: ParseRelative,
+    for_end: bool,
+) -> Result<Option<SelectorList<SelectorImpl>>, ParseError> {
+    input.try_parse(|input| {
+        if for_end {
+            // scope-end not existing is valid.
+            if input.try_parse(|i| i.expect_ident_matching("to")).is_err() {
+                return Ok(None);
+            }
+        }
+        let parens = input.try_parse(|i| i.expect_parenthesis_block());
+        if for_end {
+            // `@scope to {}` is NOT valid.
+            parens?;
+        } else if parens.is_err() {
+            // `@scope {}` is valid.
+            return Ok(None);
+        }
+        input.parse_nested_block(|input| {
+            let selector_parser = SelectorParser {
+                stylesheet_origin: context.stylesheet_origin,
+                namespaces: &context.namespaces,
+                url_data: context.url_data,
+                for_supports_rule: false,
+            };
+            let parse_relative = if for_end {
+                ParseRelative::ForScope
+            } else {
+                parse_relative
+            };
+            Ok(Some(SelectorList::parse_disallow_pseudo(
+                &selector_parser,
+                input,
+                parse_relative,
+            )?))
+        })
+    })
+}
+
+impl ScopeBounds {
+    /// Parse a container condition.
+    pub fn parse(
+        context: &ParserContext,
+        input: &mut Parser,
+        parse_relative: ParseRelative,
+    ) -> Result<Self, ParseError> {
+        let start = parse_scope(context, input, parse_relative, false)?;
+        let end = parse_scope(context, input, parse_relative, true)?;
+        Ok(Self { start, end })
+    }
+}
+
+/// Types of implicit scope root.
+#[derive(Debug, Copy, Clone, MallocSizeOf)]
+pub enum ImplicitScopeRoot {
+    /// This implicit scope root is in the light tree.
+    InLightTree(OpaqueElement),
+    /// This implicit scope root is the document element, regardless of which (light|shadow) tree
+    /// the element being matched is. This is the case for e.g. if you specified an implicit scope
+    /// within a user stylesheet.
+    DocumentElement,
+    /// The implicit scope root is in a constructed stylesheet - the scope root the element
+    /// under consideration's shadow root (If one exists).
+    Constructed,
+    /// This implicit scope root is in the shadow tree.
+    InShadowTree(OpaqueElement),
+    /// This implicit scope root is the shadow host of the stylesheet-containing shadow tree.
+    ShadowHost(OpaqueElement),
+}
+
+impl ImplicitScopeRoot {
+    /// Return true if this matches the shadow host.
+    pub fn matches_shadow_host(&self) -> bool {
+        match self {
+            Self::InLightTree(..) | Self::InShadowTree(..) | Self::DocumentElement => false,
+            Self::ShadowHost(..) | Self::Constructed => true,
+        }
+    }
+
+    /// Return the implicit scope root element.
+    pub fn element(&self, current_host: Option<OpaqueElement>) -> ImplicitScopeTarget {
+        match self {
+            Self::InLightTree(e) | Self::InShadowTree(e) | Self::ShadowHost(e) => {
+                ImplicitScopeTarget::Element(*e)
+            },
+            Self::Constructed | Self::DocumentElement => {
+                if matches!(self, Self::Constructed) {
+                    if let Some(host) = current_host {
+                        return ImplicitScopeTarget::Element(host);
+                    }
+                }
+                ImplicitScopeTarget::DocumentElement
+            },
+        }
+    }
+}
+
+/// Target of this implicit scope.
+pub enum ImplicitScopeTarget {
+    /// Target matches only the specified element.
+    Element(OpaqueElement),
+    /// Implicit scope whose target is the document element.
+    DocumentElement,
+}
+
+impl ImplicitScopeTarget {
+    /// Check if this element is the implicit scope.
+    fn check<E: TElement>(&self, element: E) -> bool {
+        match self {
+            Self::Element(e) => element.opaque() == *e,
+            Self::DocumentElement => element.is_root(),
+        }
+    }
+}
+
+/// Target of this scope.
+pub enum ScopeTarget<'a> {
+    /// Target matches an element matching the specified selector list.
+    Selector(&'a SelectorList<SelectorImpl>),
+    /// Target matches an implicit scope target.
+    Implicit(ImplicitScopeTarget),
+}
+
+impl<'a> ScopeTarget<'a> {
+    /// Check if the given element is the scope.
+    fn check<E: TElement>(
+        &self,
+        element: E,
+        scope: Option<OpaqueElement>,
+        scope_subject_map: &ScopeSubjectMap,
+        context: &mut MatchingContext<E::Impl>,
+    ) -> bool {
+        match self {
+            Self::Selector(list) => context.nest_for_scope_condition(scope, |context| {
+                if scope_subject_map.early_reject(element, context.quirks_mode()) {
+                    return false;
+                }
+                for selector in list.slice().iter() {
+                    if matches_selector(selector, 0, None, &element, context) {
+                        return true;
+                    }
+                }
+                false
+            }),
+            Self::Implicit(t) => t.check(element),
+        }
+    }
+}
+
+/// A scope root candidate.
+#[derive(Clone, Copy, Debug)]
+pub struct ScopeRootCandidate {
+    /// This candidate's scope root.
+    pub root: OpaqueElement,
+    /// Ancestor hop from the element under consideration to this scope root.
+    pub proximity: ScopeProximity,
+}
+
+impl ScopeRootCandidate {
+    /// Get the element corresponding to this scope root candidate.
+    pub fn get_scope_root_element<E>(&self, originating_element: E) -> Option<E>
+    where
+        E: TElement,
+    {
+        // Could just unsafe-convert from opaque element - technically
+        // faster as well, but it doesn't seem worth having to manually
+        // assure safety every time.
+        let mut e = originating_element;
+        let hops = self.proximity.get()?;
+        for _ in 0..hops {
+            e = e.parent_element()?;
+        }
+        debug_assert_eq!(e.opaque(), self.root);
+        Some(e)
+    }
+}
+
+/// Collect potential scope roots for a given element and its scope target.
+/// The check may not pass the ceiling, if specified.
+pub fn collect_scope_roots<E>(
+    element: E,
+    ceiling: Option<OpaqueElement>,
+    context: &mut MatchingContext<E::Impl>,
+    target: &ScopeTarget,
+    matches_shadow_host: bool,
+    scope_subject_map: &ScopeSubjectMap,
+) -> Vec<ScopeRootCandidate>
+where
+    E: TElement,
+{
+    let mut result = vec![];
+    let mut parent = Some(element);
+    let mut proximity = 0usize;
+    while let Some(p) = parent {
+        if target.check(p, ceiling, scope_subject_map, context) {
+            result.push(ScopeRootCandidate {
+                root: p.opaque(),
+                proximity: ScopeProximity::new(proximity),
+            });
+            // Note that we can't really break here - we need to consider
+            // ALL scope roots to figure out whch one didn't end.
+        }
+        if ceiling == Some(p.opaque()) {
+            break;
+        }
+        parent = p.parent_element();
+        proximity += 1;
+        // We we got to the top of the shadow tree - keep going
+        // if we may match the shadow host.
+        if parent.is_none() && matches_shadow_host {
+            parent = p.containing_shadow_host();
+        }
+    }
+    result
+}
+
+/// Given the scope-end selector, check if the element is outside of the scope.
+/// That is, check if any ancestor to the root matches the scope-end selector.
+pub fn element_is_outside_of_scope<E>(
+    selector: &Selector<E::Impl>,
+    element: E,
+    root: OpaqueElement,
+    context: &mut MatchingContext<E::Impl>,
+    root_may_be_shadow_host: bool,
+) -> bool
+where
+    E: TElement,
+{
+    let mut parent = Some(element);
+    context.nest_for_scope_condition(Some(root), |context| {
+        while let Some(p) = parent {
+            if matches_selector(selector, 0, None, &p, context) {
+                return true;
+            }
+            if p.opaque() == root {
+                // Reached the top, not lying outside of scope.
+                break;
+            }
+            parent = p.parent_element();
+            if parent.is_none() && root_may_be_shadow_host {
+                if let Some(host) = p.containing_shadow_host() {
+                    // Pretty much an edge case where user specified scope-start and -end of :host
+                    return host.opaque() == root;
+                }
+            }
+        }
+        false
+    })
+}
+
+/// A map containing simple selectors in subjects of scope selectors.
+/// This allows fast-rejecting scopes before running the full match.
+#[derive(Clone, Debug, Default, MallocSizeOf)]
+pub struct ScopeSubjectMap {
+    buckets: SimpleBucketsMap<()>,
+    any: bool,
+}
+
+impl ScopeSubjectMap {
+    /// Add the `<scope-start>` of a scope.
+    pub fn add_bound_start(
+        &mut self,
+        selectors: &SelectorList<SelectorImpl>,
+        quirks_mode: QuirksMode,
+    ) {
+        if self.add_selector_list(selectors, quirks_mode) {
+            self.any = true;
+        }
+    }
+
+    fn add_selector_list(
+        &mut self,
+        selectors: &SelectorList<SelectorImpl>,
+        quirks_mode: QuirksMode,
+    ) -> bool {
+        let mut is_any = false;
+        for selector in selectors.slice().iter() {
+            is_any = is_any || self.add_selector(selector, quirks_mode);
+        }
+        is_any
+    }
+
+    fn add_selector(&mut self, selector: &Selector<SelectorImpl>, quirks_mode: QuirksMode) -> bool {
+        let mut is_any = true;
+        let iter = selector.iter();
+        for c in iter {
+            let component_any = match c {
+                Component::Class(cls) => {
+                    match self.buckets.classes.try_entry(cls.0.clone(), quirks_mode) {
+                        Ok(e) => {
+                            e.or_insert(());
+                            false
+                        },
+                        Err(_) => true,
+                    }
+                },
+                Component::ID(id) => match self.buckets.ids.try_entry(id.0.clone(), quirks_mode) {
+                    Ok(e) => {
+                        e.or_insert(());
+                        false
+                    },
+                    Err(_) => true,
+                },
+                Component::LocalName(local_name) => {
+                    self.buckets
+                        .local_names
+                        .insert(local_name.lower_name.clone(), ());
+                    false
+                },
+                Component::Is(list) | Component::Where(list) => {
+                    self.add_selector_list(list, quirks_mode)
+                },
+                _ => true,
+            };
+
+            is_any = is_any && component_any;
+        }
+        is_any
+    }
+
+    /// Shrink the map as much as possible.
+    pub fn shrink_if_needed(&mut self) {
+        self.buckets.shrink_if_needed();
+    }
+
+    /// Clear the map.
+    pub fn clear(&mut self) {
+        self.buckets.clear();
+        self.any = false;
+    }
+
+    /// Could a given element possibly be a scope root?
+    fn early_reject<E: TElement>(&self, element: E, quirks_mode: QuirksMode) -> bool {
+        if self.any {
+            return false;
+        }
+
+        if let Some(id) = element.id() {
+            if self.buckets.ids.get(id, quirks_mode).is_some() {
+                return false;
+            }
+        }
+
+        let mut found = false;
+        element.each_class(|cls| {
+            if self.buckets.classes.get(cls, quirks_mode).is_some() {
+                found = true;
+            }
+        });
+        if found {
+            return false;
+        }
+
+        if self.buckets.local_names.get(element.local_name()).is_some() {
+            return false;
+        }
+
+        true
+    }
+}
+
+/// Determine if this selector list, when used as a scope bound selector, is considered trivial.
+pub fn scope_selector_list_is_trivial(list: &SelectorList<SelectorImpl>) -> bool {
+    fn scope_selector_is_trivial(selector: &Selector<SelectorImpl>) -> bool {
+        // A selector is trivial if:
+        // * There is no selector conditional on its siblings and/or descendant to match, and
+        // * There is no dependency on sibling relations, and
+        // * There's no ID selector in the selector. A more correct approach may be to ensure that
+        //   scoping roots of the style sharing candidates and targets have matching IDs, but that
+        //   requires re-plumbing what we pass around for scope roots.
+        let mut iter = selector.iter();
+        loop {
+            for c in iter.by_ref() {
+                match c {
+                    Component::ID(_)
+                    | Component::Nth(_)
+                    | Component::NthOf(_)
+                    | Component::Has(_) => return false,
+                    Component::Is(list) | Component::Where(list) | Component::Negation(list) => {
+                        if !scope_selector_list_is_trivial(list) {
+                            return false;
+                        }
+                    },
+                    _ => (),
+                }
+            }
+
+            match iter.next_sequence() {
+                Some(c) => {
+                    if c.is_sibling() {
+                        return false;
+                    }
+                },
+                None => return true,
+            }
+        }
+    }
+
+    list.slice().iter().all(scope_selector_is_trivial)
+}

package/vendor/stylo/stylesheets/starting_style_rule.rs

@@ -0,0 +1,54 @@
+/* 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/. */
+
+//! before-change style: the `@starting-style` rules.
+//! https://drafts.csswg.org/css-transitions-2/#defining-before-change-style
+
+use crate::derives::*;
+use crate::shared_lock::{DeepCloneWithLock, Locked};
+use crate::shared_lock::{SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard};
+use crate::stylesheets::CssRules;
+use cssparser::SourceLocation;
+#[cfg(feature = "gecko")]
+use malloc_size_of::{MallocSizeOfOps, MallocUnconditionalShallowSizeOf};
+use servo_arc::Arc;
+use std::fmt::{self, Debug, Write};
+use style_traits::CssStringWriter;
+
+/// A [`@starting-style`][starting-style] rule.
+///
+/// [starting-style]: https://drafts.csswg.org/css-transitions-2/#at-ruledef-starting-style
+#[derive(Debug, ToShmem)]
+pub struct StartingStyleRule {
+    /// The nested rules to this starting-style rule.
+    pub rules: Arc<Locked<CssRules>>,
+    /// The source position where this starting-style rule was found.
+    pub source_location: SourceLocation,
+}
+
+impl StartingStyleRule {
+    /// Measure heap usage.
+    #[cfg(feature = "gecko")]
+    pub fn size_of(&self, guard: &SharedRwLockReadGuard, ops: &mut MallocSizeOfOps) -> usize {
+        self.rules.unconditional_shallow_size_of(ops)
+            + self.rules.read_with(guard).size_of(guard, ops)
+    }
+}
+
+impl ToCssWithGuard for StartingStyleRule {
+    fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
+        dest.write_str("@starting-style")?;
+        self.rules.read_with(guard).to_css_block(guard, dest)
+    }
+}
+
+impl DeepCloneWithLock for StartingStyleRule {
+    fn deep_clone_with_lock(&self, lock: &SharedRwLock, guard: &SharedRwLockReadGuard) -> Self {
+        let rules = self.rules.read_with(guard);
+        StartingStyleRule {
+            rules: Arc::new(lock.wrap(rules.deep_clone_with_lock(lock, guard))),
+            source_location: self.source_location,
+        }
+    }
+}

package/vendor/stylo/stylesheets/style_rule.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/. */
+
+//! A style rule.
+
+use crate::derives::*;
+use crate::properties::PropertyDeclarationBlock;
+use crate::selector_parser::SelectorImpl;
+use crate::shared_lock::{
+    DeepCloneWithLock, Locked, SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard,
+};
+use crate::stylesheets::{style_or_page_rule_to_css, CssRules};
+use cssparser::SourceLocation;
+#[cfg(feature = "gecko")]
+use malloc_size_of::{
+    MallocSizeOf, MallocSizeOfOps, MallocUnconditionalShallowSizeOf, MallocUnconditionalSizeOf,
+};
+use selectors::SelectorList;
+use servo_arc::Arc;
+use std::fmt::{self, Write};
+use style_traits::CssStringWriter;
+
+/// A style rule, with selectors and declarations.
+#[derive(Debug, ToShmem)]
+pub struct StyleRule {
+    /// The list of selectors in this rule.
+    pub selectors: SelectorList<SelectorImpl>,
+    /// The declaration block with the properties it contains.
+    pub block: Arc<Locked<PropertyDeclarationBlock>>,
+    /// The nested rules to this style rule. Only non-`None` when nesting is enabled.
+    pub rules: Option<Arc<Locked<CssRules>>>,
+    /// The location in the sheet where it was found.
+    pub source_location: SourceLocation,
+}
+
+impl DeepCloneWithLock for StyleRule {
+    /// Deep clones this StyleRule.
+    fn deep_clone_with_lock(
+        &self,
+        lock: &SharedRwLock,
+        guard: &SharedRwLockReadGuard,
+    ) -> StyleRule {
+        StyleRule {
+            selectors: self.selectors.clone(),
+            block: Arc::new(lock.wrap(self.block.read_with(guard).clone())),
+            rules: self.rules.as_ref().map(|rules| {
+                let rules = rules.read_with(guard);
+                Arc::new(lock.wrap(rules.deep_clone_with_lock(lock, guard)))
+            }),
+            source_location: self.source_location,
+        }
+    }
+}
+
+impl StyleRule {
+    /// Measure heap usage.
+    #[cfg(feature = "gecko")]
+    pub fn size_of(&self, guard: &SharedRwLockReadGuard, ops: &mut MallocSizeOfOps) -> usize {
+        let mut n = 0;
+        n += self.selectors.unconditional_size_of(ops);
+        n += self.block.unconditional_shallow_size_of(ops)
+            + self.block.read_with(guard).size_of(ops);
+        if let Some(ref rules) = self.rules {
+            n += rules.unconditional_shallow_size_of(ops)
+                + rules.read_with(guard).size_of(guard, ops)
+        }
+        n
+    }
+}
+
+impl ToCssWithGuard for StyleRule {
+    /// https://drafts.csswg.org/cssom/#serialize-a-css-rule CSSStyleRule
+    fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
+        use cssparser::ToCss;
+        self.selectors.to_css(dest)?;
+        dest.write_char(' ')?;
+        style_or_page_rule_to_css(self.rules.as_ref(), &self.block, guard, dest)
+    }
+}