blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/applicable_declarations.rs

@@ -0,0 +1,328 @@
+/* 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/. */
+
+//! Applicable declarations management.
+
+use crate::derives::*;
+use crate::properties::PropertyDeclarationBlock;
+use crate::rule_tree::{CascadeLevel, RuleCascadeFlags, StyleSource};
+use crate::shared_lock::Locked;
+use crate::stylesheets::layer_rule::LayerOrder;
+use servo_arc::Arc;
+use smallvec::SmallVec;
+
+/// List of applicable declarations. This is a transient structure that shuttles
+/// declarations between selector matching and inserting into the rule tree, and
+/// therefore we want to avoid heap-allocation where possible.
+///
+/// In measurements on wikipedia, we pretty much never have more than 8 applicable
+/// declarations, so we could consider making this 8 entries instead of 16.
+/// However, it may depend a lot on workload, and stack space is cheap.
+pub type ApplicableDeclarationList = SmallVec<[ApplicableDeclarationBlock; 16]>;
+
+/// Blink uses 18 bits to store source order, and does not check overflow [1].
+/// That's a limit that could be reached in realistic webpages, so we use
+/// 24 bits and enforce defined behavior in the overflow case.
+///
+/// Note that right now this restriction could be lifted if wanted (because we
+/// no longer stash the cascade level in the remaining bits), but we keep it in
+/// place in case we come up with a use-case for them, lacking reports of the
+/// current limit being too small.
+///
+/// [1] https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/css/
+///     RuleSet.h?l=128&rcl=90140ab80b84d0f889abc253410f44ed54ae04f3
+const SOURCE_ORDER_BITS: usize = 24;
+const SOURCE_ORDER_MAX: u32 = (1 << SOURCE_ORDER_BITS) - 1;
+const SOURCE_ORDER_MASK: u32 = SOURCE_ORDER_MAX;
+
+/// The cascade-level+layer order of this declaration.
+#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)]
+pub struct CascadePriority {
+    cascade_level: CascadeLevel,
+    flags: RuleCascadeFlags,
+    layer_order: LayerOrder,
+}
+
+const_assert_eq!(
+    std::mem::size_of::<CascadePriority>(),
+    std::mem::size_of::<u32>()
+);
+
+impl PartialOrd for CascadePriority {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for CascadePriority {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.cascade_level.cmp(&other.cascade_level).then_with(|| {
+            let ordering = self.layer_order.cmp(&other.layer_order);
+            if ordering == std::cmp::Ordering::Equal {
+                return ordering;
+            }
+            // https://drafts.csswg.org/css-cascade-5/#cascade-layering
+            //
+            //     Cascade layers (like declarations) are ordered by order
+            //     of appearance. When comparing declarations that belong to
+            //     different layers, then for normal rules the declaration
+            //     whose cascade layer is last wins, and for important rules
+            //     the declaration whose cascade layer is first wins.
+            //
+            // But the style attribute layer for some reason is special.
+            if self.cascade_level.is_important()
+                && !self.layer_order.is_style_attribute_layer()
+                && !other.layer_order.is_style_attribute_layer()
+            {
+                ordering.reverse()
+            } else {
+                ordering
+            }
+        })
+    }
+}
+
+/// The kind of revert that we're applying.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RevertKind {
+    /// revert
+    Origin,
+    /// revert-layer
+    Layer,
+    /// revert-rule
+    Rule,
+}
+
+impl CascadePriority {
+    /// Construct a new CascadePriority for a given (level, order, flags) triple.
+    pub fn new(
+        cascade_level: CascadeLevel,
+        layer_order: LayerOrder,
+        flags: RuleCascadeFlags,
+    ) -> Self {
+        Self {
+            cascade_level,
+            flags,
+            layer_order,
+        }
+    }
+
+    /// Returns the flags.
+    #[inline]
+    pub fn flags(&self) -> RuleCascadeFlags {
+        self.flags
+    }
+
+    /// Set given flags.
+    #[inline]
+    pub fn set_flags(&mut self, flags: RuleCascadeFlags) {
+        self.flags.insert(flags);
+    }
+
+    /// Returns the layer order.
+    #[inline]
+    pub fn layer_order(&self) -> LayerOrder {
+        self.layer_order
+    }
+
+    /// Returns the cascade level.
+    #[inline]
+    pub fn cascade_level(&self) -> CascadeLevel {
+        self.cascade_level
+    }
+
+    /// Whether this declaration should be allowed if `revert` / `revert-layer` / `revert-rule`
+    /// have been specified on a given origin.
+    ///
+    /// `self` is the priority at which the revert has been specified.
+    pub fn allows_when_reverted(&self, other: &Self, kind: RevertKind) -> bool {
+        match kind {
+            RevertKind::Origin => {
+                other.cascade_level.origin().origin() < self.cascade_level.origin().origin()
+            },
+            RevertKind::Layer => other.unimportant() < self.unimportant(),
+            // Any other declaration for the same property we apply in the cascade needs to come
+            // from another rule effectively.
+            RevertKind::Rule => true,
+        }
+    }
+
+    /// Convert this priority from "important" to "non-important", if needed.
+    pub fn unimportant(&self) -> Self {
+        Self {
+            cascade_level: self.cascade_level.unimportant(),
+            flags: self.flags,
+            layer_order: self.layer_order,
+        }
+    }
+
+    /// Convert this priority from "non-important" to "important", if needed.
+    pub fn important(&self) -> Self {
+        Self {
+            cascade_level: self.cascade_level.important(),
+            flags: self.flags,
+            layer_order: self.layer_order,
+        }
+    }
+
+    /// The same tree, in author origin, at the root layer.
+    pub fn same_tree_author_normal_at_root_layer() -> Self {
+        Self::new(
+            CascadeLevel::same_tree_author_normal(),
+            LayerOrder::root(),
+            RuleCascadeFlags::empty(),
+        )
+    }
+}
+
+/// Proximity to the scope root.
+///
+/// https://drafts.csswg.org/css-cascade-6/#cascade-proximity
+#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)]
+pub struct ScopeProximity(u16);
+
+impl PartialOrd for ScopeProximity {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ScopeProximity {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // Lower proximity to scope root wins
+        other.0.cmp(&self.0)
+    }
+}
+
+/// Sacrifice the largest possible value for infinity. This makes the comparison
+/// trivial.
+const PROXIMITY_INFINITY: u16 = u16::MAX;
+
+impl ScopeProximity {
+    /// Construct a new scope proximity.
+    pub fn new(proximity: usize) -> Self {
+        if cfg!(debug_assertions) && proximity >= PROXIMITY_INFINITY as usize {
+            warn!("Proximity out of bounds");
+        }
+        Self(proximity.clamp(0, (PROXIMITY_INFINITY - 1) as usize) as u16)
+    }
+
+    /// Create a scope proximity for delcarations outside of any scope root.
+    pub fn infinity() -> Self {
+        Self(PROXIMITY_INFINITY)
+    }
+
+    /// If the proximity is finite, get the value.
+    pub fn get(&self) -> Option<u16> {
+        (self.0 != PROXIMITY_INFINITY).then_some(self.0)
+    }
+}
+
+/// A property declaration together with its precedence among rules of equal
+/// specificity so that we can sort them.
+///
+/// This represents the declarations in a given declaration block for a given
+/// importance.
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub struct ApplicableDeclarationBlock {
+    /// The style source, either a style rule, or a property declaration block.
+    #[ignore_malloc_size_of = "Arc"]
+    pub source: StyleSource,
+    /// Order of appearance in which this rule appears - Set to 0 if not relevant
+    /// (e.g. Declaration from `style="/*...*/"`, presentation hints, animations
+    /// - See `CascadePriority` instead).
+    source_order: u32,
+    /// The specificity of the selector.
+    pub specificity: u32,
+    /// The proximity to the scope root.
+    pub scope_proximity: ScopeProximity,
+    /// The cascade priority of the rule.
+    pub cascade_priority: CascadePriority,
+}
+
+impl ApplicableDeclarationBlock {
+    /// Constructs an applicable declaration block from a given property
+    /// declaration block and importance.
+    #[inline]
+    pub fn from_declarations(
+        declarations: Arc<Locked<PropertyDeclarationBlock>>,
+        level: CascadeLevel,
+        layer_order: LayerOrder,
+    ) -> Self {
+        ApplicableDeclarationBlock {
+            source: StyleSource::from_declarations(declarations),
+            source_order: 0,
+            specificity: 0,
+            scope_proximity: ScopeProximity::infinity(),
+            cascade_priority: CascadePriority::new(level, layer_order, RuleCascadeFlags::empty()),
+        }
+    }
+
+    /// Constructs an applicable declaration block from the given components.
+    #[inline]
+    pub fn new(
+        source: StyleSource,
+        source_order: u32,
+        level: CascadeLevel,
+        specificity: u32,
+        layer_order: LayerOrder,
+        scope_proximity: ScopeProximity,
+        flags: RuleCascadeFlags,
+    ) -> Self {
+        ApplicableDeclarationBlock {
+            source,
+            source_order: source_order & SOURCE_ORDER_MASK,
+            specificity,
+            scope_proximity,
+            cascade_priority: CascadePriority::new(level, layer_order, flags),
+        }
+    }
+
+    /// Returns the source order of the block.
+    #[inline]
+    pub fn source_order(&self) -> u32 {
+        self.source_order
+    }
+
+    /// Returns the cascade level of the block.
+    #[inline]
+    pub fn level(&self) -> CascadeLevel {
+        self.cascade_priority.cascade_level()
+    }
+
+    /// Returns the cascade level of the block.
+    #[inline]
+    pub fn layer_order(&self) -> LayerOrder {
+        self.cascade_priority.layer_order()
+    }
+
+    /// Returns the scope proximity of the block.
+    #[inline]
+    pub fn scope_proximity(&self) -> ScopeProximity {
+        self.scope_proximity
+    }
+
+    /// Convenience method to consume self and return the right thing for the
+    /// rule tree to iterate over.
+    #[inline]
+    pub fn for_rule_tree(self) -> (StyleSource, CascadePriority) {
+        (self.source, self.cascade_priority)
+    }
+
+    /// Return the key used to sort applicable declarations.
+    #[inline]
+    pub fn sort_key(&self) -> (LayerOrder, u32, ScopeProximity, u32) {
+        (
+            self.layer_order(),
+            self.specificity,
+            self.scope_proximity(),
+            self.source_order(),
+        )
+    }
+}
+
+// Size of this struct determines sorting and selector-matching performance.
+size_of_test!(ApplicableDeclarationBlock, 24);

package/vendor/stylo/author_styles.rs

@@ -0,0 +1,79 @@
+/* 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 set of author stylesheets and their computed representation, such as the
+//! ones used for ShadowRoot.
+
+use crate::derives::*;
+use crate::invalidation::stylesheets::StylesheetInvalidationSet;
+use crate::shared_lock::SharedRwLockReadGuard;
+use crate::stylesheet_set::AuthorStylesheetSet;
+use crate::stylesheets::StylesheetInDocument;
+use crate::stylist::CascadeData;
+use crate::stylist::Stylist;
+use servo_arc::Arc;
+use std::sync::LazyLock;
+
+/// A set of author stylesheets and their computed representation, such as the
+/// ones used for ShadowRoot.
+#[derive(MallocSizeOf)]
+pub struct GenericAuthorStyles<S>
+where
+    S: StylesheetInDocument + PartialEq + 'static,
+{
+    /// The sheet collection, which holds the sheet pointers, the invalidations,
+    /// and all that stuff.
+    pub stylesheets: AuthorStylesheetSet<S>,
+    /// The actual cascade data computed from the stylesheets.
+    #[ignore_malloc_size_of = "Measured as part of the stylist"]
+    pub data: Arc<CascadeData>,
+}
+
+pub use self::GenericAuthorStyles as AuthorStyles;
+
+static EMPTY_CASCADE_DATA: LazyLock<Arc<CascadeData>> =
+    LazyLock::new(|| Arc::new_leaked(CascadeData::new()));
+
+impl<S> Default for GenericAuthorStyles<S>
+where
+    S: StylesheetInDocument + PartialEq + 'static,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<S> GenericAuthorStyles<S>
+where
+    S: StylesheetInDocument + PartialEq + 'static,
+{
+    /// Create an empty AuthorStyles.
+    #[inline]
+    pub fn new() -> Self {
+        Self {
+            stylesheets: AuthorStylesheetSet::new(),
+            data: EMPTY_CASCADE_DATA.clone(),
+        }
+    }
+
+    /// Flush the pending sheet changes, updating `data` as appropriate.
+    #[inline]
+    pub fn flush(
+        &mut self,
+        stylist: &mut Stylist,
+        guard: &SharedRwLockReadGuard,
+    ) -> StylesheetInvalidationSet {
+        let (flusher, mut invalidations) = self.stylesheets.flush();
+        let result = stylist.rebuild_author_data(
+            &self.data,
+            flusher.sheets,
+            guard,
+            &mut invalidations.cascade_data_difference,
+        );
+        if let Ok(Some(new_data)) = result {
+            self.data = new_data;
+        }
+        invalidations
+    }
+}

package/vendor/stylo/bezier.rs

@@ -0,0 +1,176 @@
+/* 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/. */
+
+//! Parametric Bézier curves.
+//!
+//! This is based on `WebCore/platform/graphics/UnitBezier.h` in WebKit.
+
+#![deny(missing_docs)]
+
+use crate::values::CSSFloat;
+
+const NEWTON_METHOD_ITERATIONS: u8 = 8;
+
+/// A unit cubic Bézier curve, used for timing functions in CSS transitions and animations.
+pub struct Bezier {
+    ax: f64,
+    bx: f64,
+    cx: f64,
+    ay: f64,
+    by: f64,
+    cy: f64,
+}
+
+impl Bezier {
+    /// Calculate the output of a unit cubic Bézier curve from the two middle control points.
+    ///
+    /// X coordinate is time, Y coordinate is function advancement.
+    /// The nominal range for both is 0 to 1.
+    ///
+    /// The start and end points are always (0, 0) and (1, 1) so that a transition or animation
+    /// starts at 0% and ends at 100%.
+    pub fn calculate_bezier_output(
+        progress: f64,
+        epsilon: f64,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+    ) -> f64 {
+        // Check for a linear curve.
+        if x1 == y1 && x2 == y2 {
+            return progress;
+        }
+
+        // Ensure that we return 0 or 1 on both edges.
+        if progress == 0.0 {
+            return 0.0;
+        }
+        if progress == 1.0 {
+            return 1.0;
+        }
+
+        // For negative values, try to extrapolate with tangent (p1 - p0) or,
+        // if p1 is coincident with p0, with (p2 - p0).
+        if progress < 0.0 {
+            if x1 > 0.0 {
+                return progress * y1 as f64 / x1 as f64;
+            }
+            if y1 == 0.0 && x2 > 0.0 {
+                return progress * y2 as f64 / x2 as f64;
+            }
+            // If we can't calculate a sensible tangent, don't extrapolate at all.
+            return 0.0;
+        }
+
+        // For values greater than 1, try to extrapolate with tangent (p2 - p3) or,
+        // if p2 is coincident with p3, with (p1 - p3).
+        if progress > 1.0 {
+            if x2 < 1.0 {
+                return 1.0 + (progress - 1.0) * (y2 as f64 - 1.0) / (x2 as f64 - 1.0);
+            }
+            if y2 == 1.0 && x1 < 1.0 {
+                return 1.0 + (progress - 1.0) * (y1 as f64 - 1.0) / (x1 as f64 - 1.0);
+            }
+            // If we can't calculate a sensible tangent, don't extrapolate at all.
+            return 1.0;
+        }
+
+        Bezier::new(x1, y1, x2, y2).solve(progress, epsilon)
+    }
+
+    #[inline]
+    fn new(x1: CSSFloat, y1: CSSFloat, x2: CSSFloat, y2: CSSFloat) -> Bezier {
+        let cx = 3. * x1 as f64;
+        let bx = 3. * (x2 as f64 - x1 as f64) - cx;
+
+        let cy = 3. * y1 as f64;
+        let by = 3. * (y2 as f64 - y1 as f64) - cy;
+
+        Bezier {
+            ax: 1.0 - cx - bx,
+            bx,
+            cx,
+            ay: 1.0 - cy - by,
+            by,
+            cy,
+        }
+    }
+
+    #[inline]
+    fn sample_curve_x(&self, t: f64) -> f64 {
+        // ax * t^3 + bx * t^2 + cx * t
+        ((self.ax * t + self.bx) * t + self.cx) * t
+    }
+
+    #[inline]
+    fn sample_curve_y(&self, t: f64) -> f64 {
+        ((self.ay * t + self.by) * t + self.cy) * t
+    }
+
+    #[inline]
+    fn sample_curve_derivative_x(&self, t: f64) -> f64 {
+        (3.0 * self.ax * t + 2.0 * self.bx) * t + self.cx
+    }
+
+    #[inline]
+    fn solve_curve_x(&self, x: f64, epsilon: f64) -> f64 {
+        // Fast path: Use Newton's method.
+        let mut t = x;
+        for _ in 0..NEWTON_METHOD_ITERATIONS {
+            let x2 = self.sample_curve_x(t);
+            if x2.approx_eq(x, epsilon) {
+                return t;
+            }
+            let dx = self.sample_curve_derivative_x(t);
+            if dx.approx_eq(0.0, 1e-6) {
+                break;
+            }
+            t -= (x2 - x) / dx;
+        }
+
+        // Slow path: Use bisection.
+        let (mut lo, mut hi, mut t) = (0.0, 1.0, x);
+
+        if t < lo {
+            return lo;
+        }
+        if t > hi {
+            return hi;
+        }
+
+        while lo < hi {
+            let x2 = self.sample_curve_x(t);
+            if x2.approx_eq(x, epsilon) {
+                return t;
+            }
+            if x > x2 {
+                lo = t
+            } else {
+                hi = t
+            }
+            t = (hi - lo) / 2.0 + lo
+        }
+
+        t
+    }
+
+    /// Solve the bezier curve for a given `x` and an `epsilon`, that should be
+    /// between zero and one.
+    #[inline]
+    fn solve(&self, x: f64, epsilon: f64) -> f64 {
+        self.sample_curve_y(self.solve_curve_x(x, epsilon))
+    }
+}
+
+trait ApproxEq {
+    fn approx_eq(self, value: Self, epsilon: Self) -> bool;
+}
+
+impl ApproxEq for f64 {
+    #[inline]
+    fn approx_eq(self, value: f64, epsilon: f64) -> bool {
+        (self - value).abs() < epsilon
+    }
+}