blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/stylesheets/rules_iterator.rs

@@ -0,0 +1,397 @@
+/* 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/. */
+
+//! An iterator over a list of rules.
+
+use crate::context::QuirksMode;
+use crate::device::Device;
+use crate::shared_lock::SharedRwLockReadGuard;
+use crate::stylesheets::{
+    CssRule, CssRuleRef, CustomMediaEvaluator, CustomMediaMap, DocumentRule, ImportRule, MediaRule,
+    SupportsRule,
+};
+use smallvec::SmallVec;
+use std::ops::Deref;
+use std::slice;
+
+/// An iterator over a list of rules.
+pub struct RulesIterator<'a, 'b, C, CMM>
+where
+    'b: 'a,
+    C: NestedRuleIterationCondition + 'static,
+    CMM: Deref<Target = CustomMediaMap>,
+{
+    device: &'a Device,
+    quirks_mode: QuirksMode,
+    custom_media: CMM,
+    guard: &'a SharedRwLockReadGuard<'b>,
+    stack: SmallVec<[slice::Iter<'a, CssRule>; 3]>,
+    last_rule_had_children: bool,
+    _phantom: ::std::marker::PhantomData<C>,
+}
+
+impl<'a, 'b, C, CMM> RulesIterator<'a, 'b, C, CMM>
+where
+    'b: 'a,
+    C: NestedRuleIterationCondition + 'static,
+    CMM: Deref<Target = CustomMediaMap>,
+{
+    /// Returns the custom media map passed at construction.
+    pub fn custom_media(&mut self) -> &mut CMM {
+        &mut self.custom_media
+    }
+
+    /// Creates a new `RulesIterator` to iterate over `rules`.
+    pub fn new(
+        device: &'a Device,
+        quirks_mode: QuirksMode,
+        custom_media: CMM,
+        guard: &'a SharedRwLockReadGuard<'b>,
+        rules: slice::Iter<'a, CssRule>,
+    ) -> Self {
+        let mut stack = SmallVec::new();
+        stack.push(rules);
+        Self {
+            device,
+            quirks_mode,
+            custom_media,
+            guard,
+            stack,
+            last_rule_had_children: false,
+            _phantom: ::std::marker::PhantomData,
+        }
+    }
+
+    /// Skips all the remaining children of the last nested rule processed.
+    pub fn skip_children(&mut self) {
+        if self.last_rule_had_children {
+            self.stack.pop();
+            self.last_rule_had_children = false;
+        }
+    }
+
+    /// Returns the children of `rule`, and whether `rule` is effective.
+    pub fn children(
+        rule: &'a CssRule,
+        device: &'a Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: &CustomMediaMap,
+        guard: &'a SharedRwLockReadGuard<'_>,
+        effective: &mut bool,
+    ) -> &'a [CssRule] {
+        *effective = true;
+        match *rule {
+            CssRule::Namespace(_)
+            | CssRule::FontFace(_)
+            | CssRule::CounterStyle(_)
+            | CssRule::CustomMedia(_)
+            | CssRule::Keyframes(_)
+            | CssRule::Margin(_)
+            | CssRule::Property(_)
+            | CssRule::LayerStatement(_)
+            | CssRule::FontFeatureValues(_)
+            | CssRule::FontPaletteValues(_)
+            | CssRule::NestedDeclarations(_)
+            | CssRule::PositionTry(_)
+            | CssRule::ViewTransition(_) => &[],
+            CssRule::Page(ref page_rule) => {
+                let page_rule = page_rule.read_with(guard);
+                let rules = page_rule.rules.read_with(guard);
+                rules.0.as_slice()
+            },
+            CssRule::Style(ref style_rule) => {
+                let style_rule = style_rule.read_with(guard);
+                match style_rule.rules.as_ref() {
+                    Some(r) => r.read_with(guard).0.as_slice(),
+                    None => &[],
+                }
+            },
+            CssRule::Import(ref import_rule) => {
+                let import_rule = import_rule.read_with(guard);
+                if !C::process_import(guard, device, quirks_mode, custom_media_map, import_rule) {
+                    *effective = false;
+                    return &[];
+                }
+                import_rule.stylesheet.rules(guard)
+            },
+            CssRule::Document(ref doc_rule) => {
+                if !C::process_document(guard, device, quirks_mode, doc_rule) {
+                    *effective = false;
+                    return &[];
+                }
+                doc_rule.rules.read_with(guard).0.as_slice()
+            },
+            CssRule::Container(ref container_rule) => {
+                container_rule.rules.read_with(guard).0.as_slice()
+            },
+            CssRule::Media(ref media_rule) => {
+                if !C::process_media(guard, device, quirks_mode, custom_media_map, media_rule) {
+                    *effective = false;
+                    return &[];
+                }
+                media_rule.rules.read_with(guard).0.as_slice()
+            },
+            CssRule::Supports(ref supports_rule) => {
+                if !C::process_supports(guard, device, quirks_mode, supports_rule) {
+                    *effective = false;
+                    return &[];
+                }
+                supports_rule.rules.read_with(guard).0.as_slice()
+            },
+            CssRule::LayerBlock(ref layer_rule) => layer_rule.rules.read_with(guard).0.as_slice(),
+            CssRule::Scope(ref rule) => rule.rules.read_with(guard).0.as_slice(),
+            CssRule::StartingStyle(ref rule) => rule.rules.read_with(guard).0.as_slice(),
+            CssRule::AppearanceBase(ref rule) => rule.rules.read_with(guard).0.as_slice(),
+        }
+    }
+}
+
+impl<'a, 'b, C, CMM> Iterator for RulesIterator<'a, 'b, C, CMM>
+where
+    'b: 'a,
+    C: NestedRuleIterationCondition + 'static,
+    CMM: Deref<Target = CustomMediaMap>,
+{
+    type Item = &'a CssRule;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.last_rule_had_children = false;
+        while !self.stack.is_empty() {
+            let rule = {
+                let nested_iter = self.stack.last_mut().unwrap();
+                match nested_iter.next() {
+                    Some(r) => r,
+                    None => {
+                        self.stack.pop();
+                        continue;
+                    },
+                }
+            };
+
+            let mut effective = true;
+            let children = Self::children(
+                rule,
+                self.device,
+                self.quirks_mode,
+                &self.custom_media,
+                self.guard,
+                &mut effective,
+            );
+            if !effective {
+                continue;
+            }
+            if !children.is_empty() {
+                debug_assert_eq!(
+                    rule.children(self.guard).len(),
+                    children.len(),
+                    "Should agree with CssRule::children if effective"
+                );
+                self.last_rule_had_children = true;
+                self.stack.push(children.iter());
+            }
+            return Some(rule);
+        }
+
+        None
+    }
+}
+
+/// RulesIterator.
+pub trait NestedRuleIterationCondition {
+    /// Whether we should process the nested rules in a given `@import` rule.
+    fn process_import(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: &CustomMediaMap,
+        rule: &ImportRule,
+    ) -> bool;
+
+    /// Whether we should process the nested rules in a given `@media` rule.
+    fn process_media(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: &CustomMediaMap,
+        rule: &MediaRule,
+    ) -> bool;
+
+    /// Whether we should process the nested rules in a given `@-moz-document`
+    /// rule.
+    fn process_document(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        rule: &DocumentRule,
+    ) -> bool;
+
+    /// Whether we should process the nested rules in a given `@supports` rule.
+    fn process_supports(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        rule: &SupportsRule,
+    ) -> bool;
+}
+
+/// A struct that represents the condition that a rule applies to the document.
+pub struct EffectiveRules;
+
+impl EffectiveRules {
+    /// Returns whether a given rule is effective.
+    pub fn is_effective(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: &CustomMediaMap,
+        rule: &CssRuleRef,
+    ) -> bool {
+        match *rule {
+            CssRuleRef::Import(import_rule) => {
+                let import_rule = import_rule.read_with(guard);
+                Self::process_import(guard, device, quirks_mode, custom_media_map, import_rule)
+            },
+            CssRuleRef::Document(doc_rule) => {
+                Self::process_document(guard, device, quirks_mode, doc_rule)
+            },
+            CssRuleRef::Media(media_rule) => {
+                Self::process_media(guard, device, quirks_mode, custom_media_map, media_rule)
+            },
+            CssRuleRef::Supports(supports_rule) => {
+                Self::process_supports(guard, device, quirks_mode, supports_rule)
+            },
+            _ => true,
+        }
+    }
+}
+
+impl NestedRuleIterationCondition for EffectiveRules {
+    fn process_import(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: &CustomMediaMap,
+        rule: &ImportRule,
+    ) -> bool {
+        match rule.stylesheet.media(guard) {
+            Some(m) => m.evaluate(
+                device,
+                quirks_mode,
+                &mut CustomMediaEvaluator::new(custom_media_map, guard),
+            ),
+            None => true,
+        }
+    }
+
+    fn process_media(
+        guard: &SharedRwLockReadGuard,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: &CustomMediaMap,
+        rule: &MediaRule,
+    ) -> bool {
+        rule.media_queries.read_with(guard).evaluate(
+            device,
+            quirks_mode,
+            &mut CustomMediaEvaluator::new(custom_media_map, guard),
+        )
+    }
+
+    fn process_document(
+        _: &SharedRwLockReadGuard,
+        device: &Device,
+        _: QuirksMode,
+        rule: &DocumentRule,
+    ) -> bool {
+        rule.condition.evaluate(device)
+    }
+
+    fn process_supports(
+        _: &SharedRwLockReadGuard,
+        _: &Device,
+        _: QuirksMode,
+        rule: &SupportsRule,
+    ) -> bool {
+        rule.enabled
+    }
+}
+
+/// A filter that processes all the rules in a rule list.
+pub struct AllRules;
+
+impl NestedRuleIterationCondition for AllRules {
+    fn process_import(
+        _: &SharedRwLockReadGuard,
+        _: &Device,
+        _: QuirksMode,
+        _: &CustomMediaMap,
+        _: &ImportRule,
+    ) -> bool {
+        true
+    }
+
+    fn process_media(
+        _: &SharedRwLockReadGuard,
+        _: &Device,
+        _: QuirksMode,
+        _: &CustomMediaMap,
+        _: &MediaRule,
+    ) -> bool {
+        true
+    }
+
+    fn process_document(
+        _: &SharedRwLockReadGuard,
+        _: &Device,
+        _: QuirksMode,
+        _: &DocumentRule,
+    ) -> bool {
+        true
+    }
+
+    fn process_supports(
+        _: &SharedRwLockReadGuard,
+        _: &Device,
+        _: QuirksMode,
+        _: &SupportsRule,
+    ) -> bool {
+        true
+    }
+}
+
+/// An iterator over all the effective rules of a stylesheet.
+///
+/// NOTE: This iterator recurses into `@import` rules.
+pub type EffectiveRulesIterator<'a, 'b, CMM> = RulesIterator<'a, 'b, EffectiveRules, CMM>;
+
+impl<'a, 'b, CMM> EffectiveRulesIterator<'a, 'b, CMM>
+where
+    CMM: Deref<Target = CustomMediaMap>,
+{
+    /// Returns an iterator over the effective children of a rule, even if
+    /// `rule` itself is not effective.
+    pub fn effective_children(
+        device: &'a Device,
+        quirks_mode: QuirksMode,
+        custom_media_map: CMM,
+        guard: &'a SharedRwLockReadGuard<'b>,
+        rule: &'a CssRule,
+    ) -> Self {
+        let children = RulesIterator::<AllRules, CMM>::children(
+            rule,
+            device,
+            quirks_mode,
+            &custom_media_map,
+            guard,
+            &mut false,
+        );
+        EffectiveRulesIterator::new(
+            device,
+            quirks_mode,
+            custom_media_map,
+            guard,
+            children.iter(),
+        )
+    }
+}