blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/stylesheets/font_palette_values_rule.rs

@@ -0,0 +1,304 @@
+/* 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 [`@font-palette-values`][font-palette-values] at-rule.
+//!
+//! [font-palette-values]: https://drafts.csswg.org/css-fonts/#font-palette-values
+
+use crate::derives::*;
+use crate::error_reporting::ContextualParseError;
+#[cfg(feature = "gecko")]
+use crate::gecko_bindings::{
+    bindings::Gecko_AppendPaletteValueHashEntry,
+    bindings::{Gecko_SetFontPaletteBase, Gecko_SetFontPaletteOverride},
+    structs::gfx::FontPaletteValueSet,
+    structs::gfx::FontPaletteValueSet_PaletteValues_kDark,
+    structs::gfx::FontPaletteValueSet_PaletteValues_kLight,
+};
+use crate::parser::{Parse, ParserContext};
+use crate::shared_lock::{SharedRwLockReadGuard, ToCssWithGuard};
+use crate::stylesheets::font_feature_values_rule::parse_family_name_list;
+use crate::values::computed::font::FamilyName;
+use crate::values::specified::Color as SpecifiedColor;
+use crate::values::specified::NonNegativeInteger;
+use crate::values::DashedIdent;
+use cssparser::{
+    match_ignore_ascii_case, AtRuleParser, CowRcStr, DeclarationParser, Parser, ParserState,
+    QualifiedRuleParser, RuleBodyItemParser, RuleBodyParser, SourceLocation,
+};
+use selectors::parser::SelectorParseErrorKind;
+use std::fmt::{self, Write};
+use style_traits::{Comma, OneOrMoreSeparated};
+use style_traits::{CssStringWriter, CssWriter, ParseError, StyleParseErrorKind, ToCss};
+
+#[allow(missing_docs)]
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]
+pub struct FontPaletteOverrideColor {
+    index: NonNegativeInteger,
+    color: SpecifiedColor,
+}
+
+impl Parse for FontPaletteOverrideColor {
+    fn parse(
+        context: &ParserContext,
+        input: &mut Parser,
+    ) -> Result<FontPaletteOverrideColor, ParseError> {
+        let index = NonNegativeInteger::parse(context, input)?;
+        if index.0.resolve().is_none() {
+            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+        }
+
+        let color = SpecifiedColor::parse(context, input)?;
+        // Only absolute colors are accepted here:
+        //   https://drafts.csswg.org/css-fonts/#override-color
+        //   https://drafts.csswg.org/css-color-5/#absolute-color
+        // so check that the specified color can be resolved without a context
+        // or currentColor value.
+        if color.to_computed_color(None).is_ok_and(|c| c.is_absolute()) {
+            // We store the specified color (not the resolved absolute color)
+            // because that is what the rule exposes to authors.
+            return Ok(FontPaletteOverrideColor { index, color });
+        }
+        Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError))
+    }
+}
+
+impl ToCss for FontPaletteOverrideColor {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        self.index.to_css(dest)?;
+        dest.write_char(' ')?;
+        self.color.to_css(dest)
+    }
+}
+
+impl OneOrMoreSeparated for FontPaletteOverrideColor {
+    type S = Comma;
+}
+
+impl OneOrMoreSeparated for FamilyName {
+    type S = Comma;
+}
+
+#[allow(missing_docs)]
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToCss, ToShmem)]
+pub enum FontPaletteBase {
+    Light,
+    Dark,
+    Index(NonNegativeInteger),
+}
+
+impl Parse for FontPaletteBase {
+    #[inline]
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if let Ok(v) = input.try_parse(|input| NonNegativeInteger::parse(context, input)) {
+            if v.0.resolve().is_none() {
+                return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+            }
+            return Ok(FontPaletteBase::Index(v));
+        }
+
+        let ident = input.expect_ident()?;
+        match_ignore_ascii_case! { &ident,
+            "light" => Ok(FontPaletteBase::Light),
+            "dark" => Ok(FontPaletteBase::Dark),
+            _ => Err(ParseError::unexpected_token())
+        }
+    }
+}
+
+/// The [`@font-palette-values`][font-palette-values] at-rule.
+///
+/// [font-palette-values]: https://drafts.csswg.org/css-fonts/#font-palette-values
+#[derive(Clone, Debug, PartialEq, ToShmem)]
+pub struct FontPaletteValuesRule {
+    /// Palette name.
+    pub name: DashedIdent,
+    /// Font family list for @font-palette-values rule.
+    /// Family names cannot contain generic families. FamilyName
+    /// also accepts only non-generic names.
+    pub family_names: Vec<FamilyName>,
+    /// The base palette.
+    pub base_palette: Option<FontPaletteBase>,
+    /// The list of override colors.
+    pub override_colors: Vec<FontPaletteOverrideColor>,
+    /// The line and column of the rule's source code.
+    pub source_location: SourceLocation,
+}
+
+impl FontPaletteValuesRule {
+    /// Creates an empty FontPaletteValuesRule with given location and name.
+    fn new(name: DashedIdent, location: SourceLocation) -> Self {
+        FontPaletteValuesRule {
+            name,
+            family_names: vec![],
+            base_palette: None,
+            override_colors: vec![],
+            source_location: location,
+        }
+    }
+
+    /// Parses a `FontPaletteValuesRule`.
+    pub fn parse(
+        context: &ParserContext,
+        input: &mut Parser,
+        name: DashedIdent,
+        location: SourceLocation,
+    ) -> Self {
+        let mut rule = FontPaletteValuesRule::new(name, location);
+        let mut parser = FontPaletteValuesDeclarationParser {
+            context,
+            rule: &mut rule,
+        };
+        let iter = RuleBodyParser::new(input, &mut parser);
+        for declaration in iter {
+            if let Err((error, slice, location)) = declaration {
+                let error =
+                    ContextualParseError::UnsupportedFontPaletteValuesDescriptor(slice, error);
+                context.log_css_error(location, error);
+            }
+        }
+        rule
+    }
+
+    /// Prints inside of `@font-palette-values` block.
+    fn value_to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        if !self.family_names.is_empty() {
+            dest.write_str("font-family: ")?;
+            self.family_names.to_css(dest)?;
+            dest.write_str("; ")?;
+        }
+        if let Some(base) = &self.base_palette {
+            dest.write_str("base-palette: ")?;
+            base.to_css(dest)?;
+            dest.write_str("; ")?;
+        }
+        if !self.override_colors.is_empty() {
+            dest.write_str("override-colors: ")?;
+            self.override_colors.to_css(dest)?;
+            dest.write_str("; ")?;
+        }
+        Ok(())
+    }
+
+    /// Convert to Gecko FontPaletteValueSet.
+    #[cfg(feature = "gecko")]
+    pub fn to_gecko_palette_value_set(&self, dest: *mut FontPaletteValueSet) {
+        for family in self.family_names.iter() {
+            let family = family.name.to_ascii_lowercase();
+            let palette_values = unsafe {
+                Gecko_AppendPaletteValueHashEntry(dest, family.as_ptr(), self.name.0.as_ptr())
+            };
+            if let Some(base_palette) = &self.base_palette {
+                unsafe {
+                    Gecko_SetFontPaletteBase(
+                        palette_values,
+                        match &base_palette {
+                            FontPaletteBase::Light => FontPaletteValueSet_PaletteValues_kLight,
+                            FontPaletteBase::Dark => FontPaletteValueSet_PaletteValues_kDark,
+                            // We checked at parse time that the index is resolvable.
+                            FontPaletteBase::Index(i) => i.0.resolve().unwrap(),
+                        },
+                    );
+                }
+            }
+            for c in &self.override_colors {
+                // We checked at parse time that the specified color can be resolved
+                // in this way, so the unwrap() here will succeed.
+                let absolute = c
+                    .color
+                    .to_computed_color(None)
+                    .ok()
+                    .and_then(|c| c.as_absolute().copied())
+                    .unwrap();
+                // We checked at parse time that the index is resolvable.
+                let index = c.index.0.resolve().unwrap();
+                unsafe {
+                    Gecko_SetFontPaletteOverride(
+                        palette_values,
+                        index,
+                        (&absolute) as *const _ as *mut _,
+                    );
+                }
+            }
+        }
+    }
+}
+
+impl ToCssWithGuard for FontPaletteValuesRule {
+    fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
+        dest.write_str("@font-palette-values ")?;
+        self.name.to_css(&mut CssWriter::new(dest))?;
+        dest.write_str(" { ")?;
+        self.value_to_css(&mut CssWriter::new(dest))?;
+        dest.write_char('}')
+    }
+}
+
+/// Parser for declarations in `FontPaletteValuesRule`.
+struct FontPaletteValuesDeclarationParser<'a> {
+    context: &'a ParserContext<'a>,
+    rule: &'a mut FontPaletteValuesRule,
+}
+
+impl<'a, 'i> AtRuleParser<'i> for FontPaletteValuesDeclarationParser<'a> {
+    type Prelude = ();
+    type AtRule = ();
+    type Error = StyleParseErrorKind;
+}
+
+impl<'a, 'i> QualifiedRuleParser<'i> for FontPaletteValuesDeclarationParser<'a> {
+    type Prelude = ();
+    type QualifiedRule = ();
+    type Error = StyleParseErrorKind;
+}
+
+fn parse_override_colors(
+    context: &ParserContext,
+    input: &mut Parser,
+) -> Result<Vec<FontPaletteOverrideColor>, ParseError> {
+    input.parse_comma_separated(|i| FontPaletteOverrideColor::parse(context, i))
+}
+
+impl<'a, 'b, 'i> DeclarationParser<'i> for FontPaletteValuesDeclarationParser<'a> {
+    type Declaration = ();
+    type Error = StyleParseErrorKind;
+
+    fn parse_value(
+        &mut self,
+        name: CowRcStr<'i>,
+        input: &mut Parser<'i>,
+        _declaration_start: &ParserState,
+    ) -> Result<(), ParseError> {
+        match_ignore_ascii_case! { &*name,
+            "font-family" => {
+                self.rule.family_names = parse_family_name_list(self.context, input)?
+            },
+            "base-palette" => {
+                self.rule.base_palette = Some(input.parse_entirely(|i| FontPaletteBase::parse(self.context, i))?)
+            },
+            "override-colors" => {
+                self.rule.override_colors = parse_override_colors(self.context, input)?
+            },
+            _ => return Err(ParseError::custom(SelectorParseErrorKind::UnexpectedIdent)),
+        }
+        Ok(())
+    }
+}
+
+impl<'a, 'i> RuleBodyItemParser<'i, (), StyleParseErrorKind>
+    for FontPaletteValuesDeclarationParser<'a>
+{
+    fn parse_declarations(&self) -> bool {
+        true
+    }
+    fn parse_qualified(&self) -> bool {
+        false
+    }
+}

package/vendor/stylo/stylesheets/import_rule.rs

@@ -0,0 +1,259 @@
+/* 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 [`@import`][import] at-rule.
+//!
+//! [import]: https://drafts.csswg.org/css-cascade-3/#at-import
+
+use crate::media_queries::MediaList;
+use crate::parser::{Parse, ParserContext};
+use crate::shared_lock::{DeepCloneWithLock, SharedRwLock, SharedRwLockReadGuard, ToCssWithGuard};
+use crate::stylesheets::{
+    layer_rule::LayerName, supports_rule::SupportsCondition, CssRule, CssRuleType,
+    StylesheetInDocument,
+};
+use crate::values::CssUrl;
+use cssparser::{Parser, SourceLocation};
+use std::fmt::{self, Write};
+use style_traits::{CssStringWriter, CssWriter, ToCss};
+use to_shmem::{SharedMemoryBuilder, ToShmem};
+
+#[cfg(feature = "gecko")]
+type StyleSheet = crate::gecko::data::GeckoStyleSheet;
+#[cfg(feature = "servo")]
+type StyleSheet = ::servo_arc::Arc<crate::stylesheets::Stylesheet>;
+
+/// A sheet that is held from an import rule.
+#[derive(Debug)]
+pub enum ImportSheet {
+    /// A bonafide stylesheet.
+    Sheet(StyleSheet),
+
+    /// An @import created while parsing off-main-thread, whose Gecko sheet has
+    /// yet to be created and attached.
+    Pending,
+
+    /// An @import created with a false <supports-condition>, so will never be fetched.
+    Refused,
+}
+
+impl ImportSheet {
+    /// Creates a new ImportSheet from a stylesheet.
+    pub fn new(sheet: StyleSheet) -> Self {
+        ImportSheet::Sheet(sheet)
+    }
+
+    /// Creates a pending ImportSheet for a load that has not started yet.
+    pub fn new_pending() -> Self {
+        ImportSheet::Pending
+    }
+
+    /// Creates a refused ImportSheet for a load that will not happen.
+    pub fn new_refused() -> Self {
+        ImportSheet::Refused
+    }
+
+    /// Returns a reference to the stylesheet in this ImportSheet, if it exists.
+    pub fn as_sheet(&self) -> Option<&StyleSheet> {
+        match *self {
+            #[cfg(feature = "gecko")]
+            ImportSheet::Sheet(ref s) => {
+                debug_assert!(!s.hack_is_null());
+                if s.hack_is_null() {
+                    return None;
+                }
+                Some(s)
+            },
+            #[cfg(feature = "servo")]
+            ImportSheet::Sheet(ref s) => Some(s),
+            ImportSheet::Refused | ImportSheet::Pending => None,
+        }
+    }
+
+    /// Returns the media list for this import rule.
+    pub fn media<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> Option<&'a MediaList> {
+        self.as_sheet().and_then(|s| s.media(guard))
+    }
+
+    /// Returns the rule list for this import rule.
+    pub fn rules<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> &'a [CssRule] {
+        match self.as_sheet() {
+            Some(s) => s.contents(guard).rules(guard),
+            None => &[],
+        }
+    }
+}
+
+impl DeepCloneWithLock for ImportSheet {
+    fn deep_clone_with_lock(&self, _lock: &SharedRwLock, _guard: &SharedRwLockReadGuard) -> Self {
+        match *self {
+            #[cfg(feature = "gecko")]
+            ImportSheet::Sheet(ref s) => {
+                use crate::gecko_bindings::bindings;
+                let clone = unsafe { bindings::Gecko_StyleSheet_Clone(s.raw() as *const _) };
+                ImportSheet::Sheet(unsafe { StyleSheet::from_addrefed(clone) })
+            },
+            #[cfg(feature = "servo")]
+            ImportSheet::Sheet(ref s) => {
+                use servo_arc::Arc;
+                ImportSheet::Sheet(Arc::new((&**s).clone()))
+            },
+            ImportSheet::Pending => ImportSheet::Pending,
+            ImportSheet::Refused => ImportSheet::Refused,
+        }
+    }
+}
+
+/// The layer specified in an import rule (can be none, anonymous, or named).
+#[derive(Debug, Clone)]
+pub enum ImportLayer {
+    /// No layer specified
+    None,
+
+    /// Anonymous layer (`layer`)
+    Anonymous,
+
+    /// Named layer (`layer(name)`)
+    Named(LayerName),
+}
+
+/// The supports condition in an import rule.
+#[derive(Debug, Clone)]
+pub struct ImportSupportsCondition {
+    /// The supports condition.
+    pub condition: SupportsCondition,
+
+    /// If the import is enabled, from the result of the import condition.
+    pub enabled: bool,
+}
+
+impl ToCss for ImportLayer {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        match *self {
+            ImportLayer::None => Ok(()),
+            ImportLayer::Anonymous => dest.write_str("layer"),
+            ImportLayer::Named(ref name) => {
+                dest.write_str("layer(")?;
+                name.to_css(dest)?;
+                dest.write_char(')')
+            },
+        }
+    }
+}
+
+/// The [`@import`][import] at-rule.
+///
+/// [import]: https://drafts.csswg.org/css-cascade-3/#at-import
+#[derive(Debug)]
+pub struct ImportRule {
+    /// The `<url>` this `@import` rule is loading.
+    pub url: CssUrl,
+
+    /// The stylesheet is always present. However, in the case of gecko async
+    /// parsing, we don't actually have a Gecko sheet at first, and so the
+    /// ImportSheet just has stub behavior until it appears.
+    pub stylesheet: ImportSheet,
+
+    /// A <supports-condition> for the rule.
+    pub supports: Option<ImportSupportsCondition>,
+
+    /// A `layer()` function name.
+    pub layer: ImportLayer,
+
+    /// The line and column of the rule's source code.
+    pub source_location: SourceLocation,
+}
+
+impl ImportRule {
+    /// Parses the layer() / layer / supports() part of the import header, as per
+    /// https://drafts.csswg.org/css-cascade-5/#at-import:
+    ///
+    ///     [ layer | layer(<layer-name>) ]?
+    ///     [ supports([ <supports-condition> | <declaration> ]) ]?
+    ///
+    /// We do this here so that the import preloader can look at this without having to parse the
+    /// whole import rule or parse the media query list or what not.
+    pub fn parse_layer_and_supports(
+        input: &mut Parser,
+        context: &mut ParserContext,
+    ) -> (ImportLayer, Option<ImportSupportsCondition>) {
+        let layer = if input
+            .try_parse(|input| input.expect_ident_matching("layer"))
+            .is_ok()
+        {
+            ImportLayer::Anonymous
+        } else {
+            input
+                .try_parse(|input| {
+                    input.expect_function_matching("layer")?;
+                    input
+                        .parse_nested_block(|input| LayerName::parse(context, input))
+                        .map(ImportLayer::Named)
+                })
+                .ok()
+                .unwrap_or(ImportLayer::None)
+        };
+
+        let supports = input
+            .try_parse(SupportsCondition::parse_for_import)
+            .map(|condition| {
+                let enabled =
+                    context.nest_for_rule(CssRuleType::Style, |context| condition.eval(context));
+                ImportSupportsCondition { condition, enabled }
+            })
+            .ok();
+
+        (layer, supports)
+    }
+}
+
+impl ToShmem for ImportRule {
+    fn to_shmem(&self, _builder: &mut SharedMemoryBuilder) -> to_shmem::Result<Self> {
+        Err(String::from(
+            "ToShmem failed for ImportRule: cannot handle imported style sheets",
+        ))
+    }
+}
+
+impl DeepCloneWithLock for ImportRule {
+    fn deep_clone_with_lock(&self, lock: &SharedRwLock, guard: &SharedRwLockReadGuard) -> Self {
+        ImportRule {
+            url: self.url.clone(),
+            stylesheet: self.stylesheet.deep_clone_with_lock(lock, guard),
+            supports: self.supports.clone(),
+            layer: self.layer.clone(),
+            source_location: self.source_location,
+        }
+    }
+}
+
+impl ToCssWithGuard for ImportRule {
+    fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
+        dest.write_str("@import ")?;
+        self.url.to_css(&mut CssWriter::new(dest))?;
+
+        if !matches!(self.layer, ImportLayer::None) {
+            dest.write_char(' ')?;
+            self.layer.to_css(&mut CssWriter::new(dest))?;
+        }
+
+        if let Some(ref supports) = self.supports {
+            dest.write_str(" supports(")?;
+            supports.condition.to_css(&mut CssWriter::new(dest))?;
+            dest.write_char(')')?;
+        }
+
+        if let Some(media) = self.stylesheet.media(guard) {
+            if !media.is_empty() {
+                dest.write_char(' ')?;
+                media.to_css(&mut CssWriter::new(dest))?;
+            }
+        }
+
+        dest.write_char(';')
+    }
+}