blitz-pdf 0.0.0-stage → 0.1.1

package/vendor/stylo/servo/encoding_support.rs

@@ -0,0 +1,81 @@
+/* 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/. */
+
+//! Parsing stylesheets from bytes (not `&str`).
+
+use crate::context::QuirksMode;
+use crate::error_reporting::ParseErrorReporter;
+use crate::media_queries::MediaList;
+use crate::shared_lock::{Locked, SharedRwLock};
+use crate::stylesheets::{AllowImportRules, Origin, Stylesheet, StylesheetLoader, UrlExtraData};
+use cssparser::{stylesheet_encoding, EncodingSupport};
+use servo_arc::Arc;
+use std::borrow::Cow;
+use std::str;
+
+struct EncodingRs;
+
+impl EncodingSupport for EncodingRs {
+    type Encoding = &'static encoding_rs::Encoding;
+
+    fn utf8() -> Self::Encoding {
+        encoding_rs::UTF_8
+    }
+
+    fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool {
+        *encoding == encoding_rs::UTF_16LE || *encoding == encoding_rs::UTF_16BE
+    }
+
+    fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding> {
+        encoding_rs::Encoding::for_label(ascii_label)
+    }
+}
+
+fn decode_stylesheet_bytes<'a>(
+    css: &'a [u8],
+    protocol_encoding_label: Option<&str>,
+    environment_encoding: Option<&'static encoding_rs::Encoding>,
+) -> Cow<'a, str> {
+    let fallback_encoding = stylesheet_encoding::<EncodingRs>(
+        css,
+        protocol_encoding_label.map(str::as_bytes),
+        environment_encoding,
+    );
+    let (result, _used_encoding, _) = fallback_encoding.decode(&css);
+    // FIXME record used encoding for environment encoding of @import
+    result
+}
+
+impl Stylesheet {
+    /// Parse a stylesheet from a set of bytes, potentially received over the
+    /// network.
+    ///
+    /// Takes care of decoding the network bytes and forwards the resulting
+    /// string to `Stylesheet::from_str`.
+    pub fn from_bytes(
+        bytes: &[u8],
+        url_data: UrlExtraData,
+        protocol_encoding_label: Option<&str>,
+        environment_encoding: Option<&'static encoding_rs::Encoding>,
+        origin: Origin,
+        media: Arc<Locked<MediaList>>,
+        shared_lock: SharedRwLock,
+        stylesheet_loader: Option<&dyn StylesheetLoader>,
+        error_reporter: Option<&dyn ParseErrorReporter>,
+        quirks_mode: QuirksMode,
+    ) -> Stylesheet {
+        let string = decode_stylesheet_bytes(bytes, protocol_encoding_label, environment_encoding);
+        Stylesheet::from_str(
+            &string,
+            url_data,
+            origin,
+            media,
+            shared_lock,
+            stylesheet_loader,
+            error_reporter,
+            quirks_mode,
+            AllowImportRules::Yes,
+        )
+    }
+}

package/vendor/stylo/servo/media_features.rs

@@ -0,0 +1,254 @@
+/* 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/. */
+
+//! Servo's media feature list and evaluator.
+
+use crate::derives::*;
+use crate::queries::feature::{AllowsRanges, Evaluator, FeatureFlags, QueryFeatureDescription};
+use crate::queries::values::{Orientation, PrefersColorScheme};
+use crate::values::computed::{CSSPixelLength, Context, Ratio, Resolution};
+use std::fmt::Debug;
+
+/// https://drafts.csswg.org/mediaqueries-4/#width
+fn eval_width(context: &Context) -> CSSPixelLength {
+    CSSPixelLength::new(context.device().au_viewport_size().width.to_f32_px())
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#height
+fn eval_height(context: &Context) -> CSSPixelLength {
+    CSSPixelLength::new(context.device().au_viewport_size().height.to_f32_px())
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#device-width
+fn eval_device_width(context: &Context) -> CSSPixelLength {
+    let device = context.device();
+    let scaled = device.device_size() / device.device_pixel_ratio();
+    CSSPixelLength::new(scaled.width)
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#device-height
+fn eval_device_height(context: &Context) -> CSSPixelLength {
+    let device = context.device();
+    let scaled = device.device_size() / device.device_pixel_ratio();
+    CSSPixelLength::new(scaled.height)
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#orientation
+fn eval_orientation(context: &Context, value: Option<Orientation>) -> bool {
+    Orientation::eval(context.device().au_viewport_size(), value)
+}
+
+#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]
+#[repr(u8)]
+enum Scan {
+    Progressive,
+    Interlace,
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#scan
+fn eval_scan(_: &Context, _: Option<Scan>) -> bool {
+    // Since we doesn't support the 'tv' media type, the 'scan' feature never
+    // matches.
+    false
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#resolution
+fn eval_resolution(context: &Context) -> Resolution {
+    Resolution::from_dppx(context.device().device_pixel_ratio().0)
+}
+
+/// https://compat.spec.whatwg.org/#css-media-queries-webkit-device-pixel-ratio
+fn eval_device_pixel_ratio(context: &Context) -> f32 {
+    eval_resolution(context).dppx()
+}
+
+fn eval_prefers_color_scheme(context: &Context, query_value: Option<PrefersColorScheme>) -> bool {
+    match query_value {
+        Some(v) => context.device().color_scheme() == v,
+        None => true,
+    }
+}
+
+bitflags! {
+    /// https://drafts.csswg.org/mediaqueries-4/#mf-interaction
+    #[derive(Debug, Clone, Copy)]
+    pub struct PointerCapabilities: u8 {
+        /// The input mechanism includes a pointing device of limited accuracy, such as a finger on a touchscreen.
+        const COARSE = 0b001;
+        /// The input mechanism includes an accurate pointing device, such as a mouse.
+        const FINE = 0b010;
+        /// The input mechanism can conveniently hover over elements.
+        const HOVER = 0b100;
+    }
+}
+
+impl Default for PointerCapabilities {
+    #[cfg(any(target_os = "ios", target_os = "android", target_env = "ohos"))]
+    fn default() -> Self {
+        PointerCapabilities::COARSE
+    }
+    #[cfg(not(any(target_os = "ios", target_os = "android", target_env = "ohos")))]
+    fn default() -> Self {
+        PointerCapabilities::FINE | PointerCapabilities::HOVER
+    }
+}
+
+#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]
+#[repr(u8)]
+enum Pointer {
+    None,
+    Coarse,
+    Fine,
+}
+
+fn eval_pointer_capabilities(
+    query_value: Option<Pointer>,
+    pointer_capabilities: PointerCapabilities,
+) -> bool {
+    match query_value {
+        None => !pointer_capabilities.is_empty(),
+        Some(Pointer::None) => pointer_capabilities.is_empty(),
+        Some(Pointer::Coarse) => pointer_capabilities.intersects(PointerCapabilities::COARSE),
+        Some(Pointer::Fine) => pointer_capabilities.intersects(PointerCapabilities::FINE),
+    }
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#pointer
+fn eval_pointer(context: &Context, query_value: Option<Pointer>) -> bool {
+    eval_pointer_capabilities(query_value, context.device().primary_pointer_capabilities())
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#descdef-media-any-pointer
+fn eval_any_pointer(context: &Context, query_value: Option<Pointer>) -> bool {
+    eval_pointer_capabilities(query_value, context.device().all_pointer_capabilities())
+}
+
+#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]
+#[repr(u8)]
+enum Hover {
+    None,
+    Hover,
+}
+
+fn eval_hover_capabilities(
+    query_value: Option<Hover>,
+    pointer_capabilities: PointerCapabilities,
+) -> bool {
+    let can_hover = pointer_capabilities.intersects(PointerCapabilities::HOVER);
+    match query_value {
+        Some(Hover::None) => !can_hover,
+        Some(Hover::Hover) => can_hover,
+        None => return can_hover,
+    }
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#hover
+fn eval_hover(context: &Context, query_value: Option<Hover>) -> bool {
+    eval_hover_capabilities(query_value, context.device().primary_pointer_capabilities())
+}
+
+/// https://drafts.csswg.org/mediaqueries-4/#descdef-media-any-hover
+fn eval_any_hover(context: &Context, query_value: Option<Hover>) -> bool {
+    eval_hover_capabilities(query_value, context.device().all_pointer_capabilities())
+}
+
+/// <https://drafts.csswg.org/mediaqueries-4/#aspect-ratio>
+fn eval_aspect_ratio(context: &Context) -> Ratio {
+    let size = context.device().au_viewport_size();
+    Ratio::new(size.width.0 as f32, size.height.0 as f32)
+}
+
+/// A list with all the media features that Servo supports.
+pub static MEDIA_FEATURES: [QueryFeatureDescription; 15] = [
+    feature!(
+        atom!("width"),
+        AllowsRanges::Yes,
+        Evaluator::Length(eval_width),
+        FeatureFlags::VIEWPORT_DEPENDENT,
+    ),
+    feature!(
+        atom!("height"),
+        AllowsRanges::Yes,
+        Evaluator::Length(eval_height),
+        FeatureFlags::VIEWPORT_DEPENDENT,
+    ),
+    feature!(
+        atom!("orientation"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_orientation, Orientation),
+        FeatureFlags::VIEWPORT_DEPENDENT,
+    ),
+    feature!(
+        atom!("pointer"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_pointer, Pointer),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("any-pointer"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_any_pointer, Pointer),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("hover"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_hover, Hover),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("any-hover"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_any_hover, Hover),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("aspect-ratio"),
+        AllowsRanges::Yes,
+        Evaluator::NumberRatio(eval_aspect_ratio),
+        FeatureFlags::VIEWPORT_DEPENDENT,
+    ),
+    feature!(
+        atom!("device-width"),
+        AllowsRanges::Yes,
+        Evaluator::Length(eval_device_width),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("device-height"),
+        AllowsRanges::Yes,
+        Evaluator::Length(eval_device_height),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("scan"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_scan, Scan),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("resolution"),
+        AllowsRanges::Yes,
+        Evaluator::Resolution(eval_resolution),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("device-pixel-ratio"),
+        AllowsRanges::Yes,
+        Evaluator::Float(eval_device_pixel_ratio),
+        FeatureFlags::WEBKIT_PREFIX,
+    ),
+    feature!(
+        atom!("-moz-device-pixel-ratio"),
+        AllowsRanges::Yes,
+        Evaluator::Float(eval_device_pixel_ratio),
+        FeatureFlags::empty(),
+    ),
+    feature!(
+        atom!("prefers-color-scheme"),
+        AllowsRanges::No,
+        keyword_evaluator!(eval_prefers_color_scheme, PrefersColorScheme),
+        FeatureFlags::empty(),
+    ),
+];

package/vendor/stylo/servo/mod.rs

@@ -0,0 +1,16 @@
+/* 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/. */
+
+//! Servo-specific bits of the style system.
+//!
+//! These get compiled out on a Gecko build.
+
+pub mod animation;
+#[allow(missing_docs)] // TODO.
+pub mod attr;
+mod encoding_support;
+pub mod media_features;
+pub mod restyle_damage;
+pub mod selector_parser;
+mod shadow_parts;

package/vendor/stylo/servo/restyle_damage.rs

@@ -0,0 +1,215 @@
+/* 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/. */
+
+//! The restyle damage is a hint that tells layout which kind of operations may
+//! be needed in presence of incremental style changes.
+
+use bitflags::Flags;
+
+use crate::computed_values::isolation::T as Isolation;
+use crate::computed_values::mix_blend_mode::T as MixBlendMode;
+use crate::computed_values::transform_style::T as TransformStyle;
+use crate::dom::TElement;
+use crate::matching::{StyleChange, StyleDifference};
+use crate::properties::{
+    restyle_damage_rebuild_box, restyle_damage_rebuild_stacking_context,
+    restyle_damage_recalculate_overflow, restyle_damage_repaint, style_structs, ComputedValues,
+};
+use crate::values::computed::basic_shape::ClipPath;
+use crate::values::computed::Perspective;
+use crate::values::generics::transform::{GenericRotate, GenericScale, GenericTranslate};
+use std::fmt;
+
+bitflags! {
+    /// Major phases of layout that need to be run due to the damage to a node during restyling. In
+    /// addition to the 4 bytes used for that, the rest of the `u16` is exposed as an extension point
+    /// for users of the crate to add their own custom types of damage that correspond to the
+    /// layout system they are implementing.
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    pub struct ServoRestyleDamage: u16 {
+        /// Repaint the node itself.
+        ///
+        /// Propagates both up and down the flow tree.
+        const REPAINT = 0b0001;
+
+        /// Rebuilds the stacking contexts.
+        ///
+        /// Propagates both up and down the flow tree.
+        const REBUILD_STACKING_CONTEXT = 0b0011;
+
+        /// Recalculates the scrollable overflow.
+        ///
+        /// Propagates both up and down the flow tree.
+        const RECALCULATE_OVERFLOW = 0b0111;
+
+        /// Any other type of damage, which requires running layout again.
+        ///
+        /// Propagates both up and down the flow tree.
+        const RELAYOUT = 0b1111;
+    }
+}
+
+malloc_size_of::malloc_size_of_is_0!(ServoRestyleDamage);
+
+impl ServoRestyleDamage {
+    /// Compute the `StyleDifference` (including the appropriate restyle damage)
+    /// for a given style change between `old` and `new`.
+    pub fn compute_style_difference<E: TElement>(
+        old: &ComputedValues,
+        new: &ComputedValues,
+    ) -> StyleDifference {
+        if std::ptr::eq(old, new) {
+            return StyleDifference {
+                damage: ServoRestyleDamage::empty(),
+                change: StyleChange::Unchanged,
+            };
+        }
+
+        let mut damage = compute_damage(old, new);
+        if damage.contains(ServoRestyleDamage::RELAYOUT) {
+            damage |= E::compute_layout_damage(old, new);
+        }
+
+        let mut any_style_changed = !damage.is_empty();
+        // FIXME(emilio): Differentiate between reset and inherited
+        // properties here, and set `reset_only` appropriately so the
+        // optimization to skip the cascade in those cases applies.
+        let mut reset_only = !any_style_changed;
+
+        let old_custom_props = old.custom_properties();
+        let new_custom_props = new.custom_properties();
+        let mut custom_properties_changed = false;
+        if old_custom_props.inherited != new_custom_props.inherited {
+            any_style_changed = true;
+            custom_properties_changed = true;
+            reset_only = false;
+        } else if old_custom_props.non_inherited != new_custom_props.non_inherited {
+            any_style_changed = true;
+            custom_properties_changed = true;
+        };
+        if custom_properties_changed {
+            // Paint worklets may depend on custom properties, so if they have changed we should repaint.
+            damage.insert(ServoRestyleDamage::REPAINT);
+        }
+
+        let change = if any_style_changed {
+            StyleChange::Changed {
+                reset_only,
+                custom_properties_changed,
+            }
+        } else {
+            StyleChange::Unchanged
+        };
+
+        StyleDifference { damage, change }
+    }
+
+    /// Returns a bitmask indicating that the frame needs to be reconstructed.
+    pub fn reconstruct() -> ServoRestyleDamage {
+        // There's no way of knowing what kind of damage system the embedder will use, but part of
+        // this interface is that a fully saturated restyle damage means to rebuild everything.
+        ServoRestyleDamage::from_bits_retain(<ServoRestyleDamage as Flags>::Bits::MAX)
+    }
+}
+
+impl Default for ServoRestyleDamage {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl fmt::Display for ServoRestyleDamage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        let mut first_elem = true;
+
+        let to_iter = [
+            (ServoRestyleDamage::REPAINT, "Repaint"),
+            (
+                ServoRestyleDamage::REBUILD_STACKING_CONTEXT,
+                "Rebuild stacking context",
+            ),
+            (
+                ServoRestyleDamage::RECALCULATE_OVERFLOW,
+                "Recalculate overflow",
+            ),
+            (ServoRestyleDamage::RELAYOUT, "Relayout"),
+        ];
+
+        for &(damage, damage_str) in &to_iter {
+            if self.contains(damage) {
+                if !first_elem {
+                    write!(f, " | ")?;
+                }
+                write!(f, "{}", damage_str)?;
+                first_elem = false;
+            }
+        }
+
+        if first_elem {
+            write!(f, "NoDamage")?;
+        }
+
+        Ok(())
+    }
+}
+
+fn augmented_restyle_damage_rebuild_box(old: &ComputedValues, new: &ComputedValues) -> bool {
+    let old_box = old.get_box();
+    let new_box = new.get_box();
+    restyle_damage_rebuild_box(old, new)
+        || old_box.original_display != new_box.original_display
+        || old_box.has_transform_or_perspective() != new_box.has_transform_or_perspective()
+        || old.get_effects().filter.0.is_empty() != new.get_effects().filter.0.is_empty()
+}
+
+fn augmented_restyle_damage_rebuild_stacking_context(
+    old: &ComputedValues,
+    new: &ComputedValues,
+) -> bool {
+    restyle_damage_rebuild_stacking_context(old, new)
+        || old.guarantees_stacking_context() != new.guarantees_stacking_context()
+}
+
+fn compute_damage(old: &ComputedValues, new: &ComputedValues) -> ServoRestyleDamage {
+    // Damage flags higher up the if-else chain imply damage flags lower down the if-else chain,
+    // so we can skip the diffing process for later flags if an earlier flag is true
+    if augmented_restyle_damage_rebuild_box(old, new) {
+        ServoRestyleDamage::RELAYOUT
+    } else if restyle_damage_recalculate_overflow(old, new) {
+        ServoRestyleDamage::RECALCULATE_OVERFLOW
+    } else if augmented_restyle_damage_rebuild_stacking_context(old, new) {
+        ServoRestyleDamage::REBUILD_STACKING_CONTEXT
+    } else if restyle_damage_repaint(old, new) {
+        ServoRestyleDamage::REPAINT
+    } else {
+        ServoRestyleDamage::empty()
+    }
+}
+
+impl ComputedValues {
+    /// Some properties establish a stacking context when they are set to a non-initial value.
+    /// In that case, the damage is only set to `ServoRestyleDamage::REPAINT` because we don't
+    /// need to rebuild stacking contexts when the style changes between different non-initial
+    /// values. This function checks whether any of these properties is set to a value that
+    /// guarantees a stacking context, so that we only do the work when this changes.
+    /// Note that it's still possible to establish a stacking context when this returns false.
+    pub fn guarantees_stacking_context(&self) -> bool {
+        self.get_effects().opacity != 1.0
+            || self.get_effects().mix_blend_mode != MixBlendMode::Normal
+            || self.get_svg().clip_path != ClipPath::None
+            || self.get_box().isolation == Isolation::Isolate
+    }
+}
+
+impl style_structs::Box {
+    /// Whether there is a non-default transform or perspective style set
+    pub fn has_transform_or_perspective(&self) -> bool {
+        !self.transform.0.is_empty()
+            || self.scale != GenericScale::None
+            || self.rotate != GenericRotate::None
+            || self.translate != GenericTranslate::None
+            || self.perspective != Perspective::None
+            || self.transform_style == TransformStyle::Preserve3d
+    }
+}