blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/media_queries/media_list.rs

@@ -0,0 +1,168 @@
+/* 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 media query list:
+//!
+//! https://drafts.csswg.org/mediaqueries/#typedef-media-query-list
+
+use super::{MediaQuery, Qualifier};
+use crate::context::QuirksMode;
+use crate::derives::*;
+use crate::device::Device;
+use crate::dom::AttributeTracker;
+use crate::error_reporting::ContextualParseError;
+use crate::parser::ParserContext;
+use crate::stylesheets::CustomMediaEvaluator;
+use crate::values::computed;
+use cssparser::Token;
+use cssparser::{Delimiter, Parser};
+use selectors::kleene_value::KleeneValue;
+use style_traits::ParsingMode;
+
+/// A type that encapsulates a media query list.
+#[derive(Clone, MallocSizeOf, ToCss, ToShmem)]
+#[css(comma, derive_debug)]
+pub struct MediaList {
+    /// The list of media queries.
+    #[css(iterable)]
+    pub media_queries: Vec<MediaQuery>,
+}
+
+impl MediaList {
+    /// Parse a media query list from CSS.
+    ///
+    /// Always returns a media query list. If any invalid media query is
+    /// found, the media query list is only filled with the equivalent of
+    /// "not all", see:
+    ///
+    /// <https://drafts.csswg.org/mediaqueries/#error-handling>
+    pub fn parse(context: &mut ParserContext, input: &mut Parser) -> Self {
+        context.with_parsing_mode(ParsingMode::MEDIA_QUERY_CONDITION, |context| {
+            if input.is_exhausted() {
+                return Self::empty();
+            }
+
+            let mut media_queries = vec![];
+            loop {
+                let start_position = input.position();
+                let start_location = input.current_source_location();
+                match input.parse_until_before(Delimiter::Comma, |i| MediaQuery::parse(context, i))
+                {
+                    Ok(mq) => {
+                        media_queries.push(mq);
+                    },
+                    Err(err) => {
+                        media_queries.push(MediaQuery::never_matching());
+                        let error = ContextualParseError::InvalidMediaRule(
+                            input.slice_from(start_position),
+                            err,
+                        );
+                        context.log_css_error(start_location, error);
+                    },
+                }
+
+                match input.next() {
+                    Ok(&Token::Comma) => {},
+                    Ok(_) => unreachable!(),
+                    Err(_) => break,
+                }
+            }
+
+            MediaList { media_queries }
+        })
+    }
+
+    /// Create an empty MediaList.
+    pub fn empty() -> Self {
+        MediaList {
+            media_queries: vec![],
+        }
+    }
+
+    /// Evaluate a whole `MediaList` against `Device`.
+    pub fn evaluate(
+        &self,
+        device: &Device,
+        quirks_mode: QuirksMode,
+        custom: &mut CustomMediaEvaluator,
+    ) -> bool {
+        computed::Context::for_media_query_evaluation(device, quirks_mode, |context| {
+            self.matches(context, custom).to_bool(/* unknown = */ false)
+        })
+    }
+
+    /// Evaluate the current `MediaList` with a pre-existing context and custom-media evaluator.
+    pub fn matches(
+        &self,
+        context: &computed::Context,
+        custom: &mut CustomMediaEvaluator,
+    ) -> KleeneValue {
+        // Check if it is an empty media query list or any queries match.
+        // https://drafts.csswg.org/mediaqueries-4/#mq-list
+        if self.media_queries.is_empty() {
+            return KleeneValue::True;
+        }
+        KleeneValue::any(self.media_queries.iter(), |mq| {
+            let mut query_match = if mq.media_type.matches(context.device().media_type()) {
+                mq.condition.as_ref().map_or(KleeneValue::True, |c| {
+                    c.matches(context, custom, &mut AttributeTracker::new_dummy())
+                })
+            } else {
+                KleeneValue::False
+            };
+            // Apply the logical NOT qualifier to the result
+            if matches!(mq.qualifier, Some(Qualifier::Not)) {
+                query_match = !query_match;
+            }
+            query_match
+        })
+    }
+
+    /// Whether this `MediaList` contains no media queries.
+    pub fn is_empty(&self) -> bool {
+        self.media_queries.is_empty()
+    }
+
+    /// Whether this `MediaList` depends on the viewport size.
+    pub fn is_viewport_dependent(&self) -> bool {
+        self.media_queries.iter().any(|q| q.is_viewport_dependent())
+    }
+
+    /// Append a new media query item to the media list.
+    /// <https://drafts.csswg.org/cssom/#dom-medialist-appendmedium>
+    ///
+    /// Returns true if added, false if fail to parse the medium string.
+    pub fn append_medium(&mut self, context: &ParserContext, new_medium: &str) -> bool {
+        let mut parser = Parser::new(new_medium);
+        let new_query = match MediaQuery::parse(context, &mut parser) {
+            Ok(query) => query,
+            Err(_) => {
+                return false;
+            },
+        };
+        // This algorithm doesn't actually matches the current spec,
+        // but it matches the behavior of Gecko and Edge.
+        // See https://github.com/w3c/csswg-drafts/issues/697
+        self.media_queries.retain(|query| query != &new_query);
+        self.media_queries.push(new_query);
+        true
+    }
+
+    /// Delete a media query from the media list.
+    /// <https://drafts.csswg.org/cssom/#dom-medialist-deletemedium>
+    ///
+    /// Returns true if found and deleted, false otherwise.
+    pub fn delete_medium(&mut self, context: &ParserContext, old_medium: &str) -> bool {
+        let mut parser = Parser::new(old_medium);
+        let old_query = match MediaQuery::parse(context, &mut parser) {
+            Ok(query) => query,
+            Err(_) => {
+                return false;
+            },
+        };
+        let old_len = self.media_queries.len();
+        self.media_queries.retain(|query| query != &old_query);
+        old_len != self.media_queries.len()
+    }
+}

package/vendor/stylo/media_queries/media_query.rs

@@ -0,0 +1,190 @@
+/* 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 media query:
+//!
+//! https://drafts.csswg.org/mediaqueries/#typedef-media-query
+
+use crate::derives::*;
+use crate::parser::ParserContext;
+use crate::queries::{FeatureFlags, FeatureType, QueryCondition};
+use crate::str::string_as_ascii_lowercase;
+use crate::values::CustomIdent;
+use crate::Atom;
+use cssparser::{match_ignore_ascii_case, Parser};
+use std::fmt::{self, Write};
+use style_traits::{CssWriter, ParseError, ToCss};
+
+/// <https://drafts.csswg.org/mediaqueries/#mq-prefix>
+#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, Parse, PartialEq, ToCss, ToShmem)]
+pub enum Qualifier {
+    /// Hide a media query from legacy UAs:
+    /// <https://drafts.csswg.org/mediaqueries/#mq-only>
+    Only,
+    /// Negate a media query:
+    /// <https://drafts.csswg.org/mediaqueries/#mq-not>
+    Not,
+}
+
+/// <https://drafts.csswg.org/mediaqueries/#media-types>
+#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]
+pub struct MediaType(pub CustomIdent);
+
+impl MediaType {
+    /// The `screen` media type.
+    pub fn screen() -> Self {
+        MediaType(CustomIdent(atom!("screen")))
+    }
+
+    /// The `print` media type.
+    pub fn print() -> Self {
+        MediaType(CustomIdent(atom!("print")))
+    }
+
+    fn parse(name: &str) -> Result<Self, ()> {
+        // From https://drafts.csswg.org/mediaqueries/#mq-syntax:
+        //
+        //   The <media-type> production does not include the keywords only, not, and, or, and layer.
+        //
+        // Here we also perform the to-ascii-lowercase part of the serialization
+        // algorithm: https://drafts.csswg.org/cssom/#serializing-media-queries
+        match_ignore_ascii_case! { name,
+            "not" | "or" | "and" | "only" | "layer" => Err(()),
+            _ => Ok(MediaType(CustomIdent(Atom::from(string_as_ascii_lowercase(name))))),
+        }
+    }
+}
+
+/// A [media query][mq].
+///
+/// [mq]: https://drafts.csswg.org/mediaqueries/
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]
+pub struct MediaQuery {
+    /// The qualifier for this query.
+    pub qualifier: Option<Qualifier>,
+    /// The media type for this query, that can be known, unknown, or "all".
+    pub media_type: MediaQueryType,
+    /// The condition that this media query contains. This cannot have `or`
+    /// in the first level.
+    pub condition: Option<QueryCondition>,
+}
+
+impl ToCss for MediaQuery {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        if let Some(qual) = self.qualifier {
+            qual.to_css(dest)?;
+            dest.write_char(' ')?;
+        }
+
+        match self.media_type {
+            MediaQueryType::All => {
+                // We need to print "all" if there's a qualifier, or there's
+                // just an empty list of expressions.
+                //
+                // Otherwise, we'd serialize media queries like "(min-width:
+                // 40px)" in "all (min-width: 40px)", which is unexpected.
+                if self.qualifier.is_some() || self.condition.is_none() {
+                    dest.write_str("all")?;
+                }
+            },
+            MediaQueryType::Concrete(MediaType(ref desc)) => desc.to_css(dest)?,
+        }
+
+        let condition = match self.condition {
+            Some(ref c) => c,
+            None => return Ok(()),
+        };
+
+        if self.media_type != MediaQueryType::All || self.qualifier.is_some() {
+            dest.write_str(" and ")?;
+        }
+
+        condition.to_css(dest)
+    }
+}
+
+impl MediaQuery {
+    /// Return a media query that never matches, used for when we fail to parse
+    /// a given media query.
+    pub fn never_matching() -> Self {
+        Self {
+            qualifier: Some(Qualifier::Not),
+            media_type: MediaQueryType::All,
+            condition: None,
+        }
+    }
+
+    /// Returns whether this media query depends on the viewport.
+    pub fn is_viewport_dependent(&self) -> bool {
+        self.condition.as_ref().is_some_and(|c| {
+            c.cumulative_flags()
+                .contains(FeatureFlags::VIEWPORT_DEPENDENT)
+        })
+    }
+
+    /// Parse a media query given css input.
+    ///
+    /// Returns an error if any of the expressions is unknown.
+    pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        let (qualifier, explicit_media_type) = input
+            .try_parse(|input| -> Result<_, ()> {
+                let qualifier = input.try_parse(Qualifier::parse).ok();
+                let ident = input.expect_ident().map_err(|_| ())?;
+                let media_type = MediaQueryType::parse(ident)?;
+                Ok((qualifier, Some(media_type)))
+            })
+            .unwrap_or_default();
+
+        let condition = if explicit_media_type.is_none() {
+            Some(QueryCondition::parse(context, input, FeatureType::Media)?)
+        } else if input.try_parse(|i| i.expect_ident_matching("and")).is_ok() {
+            Some(QueryCondition::parse_disallow_or(
+                context,
+                input,
+                FeatureType::Media,
+            )?)
+        } else {
+            None
+        };
+
+        let media_type = explicit_media_type.unwrap_or(MediaQueryType::All);
+        Ok(Self {
+            qualifier,
+            media_type,
+            condition,
+        })
+    }
+}
+
+/// <http://dev.w3.org/csswg/mediaqueries-3/#media0>
+#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]
+pub enum MediaQueryType {
+    /// A media type that matches every device.
+    All,
+    /// A specific media type.
+    Concrete(MediaType),
+}
+
+impl MediaQueryType {
+    fn parse(ident: &str) -> Result<Self, ()> {
+        match_ignore_ascii_case! { ident,
+            "all" => return Ok(MediaQueryType::All),
+            _ => (),
+        };
+
+        // If parseable, accept this type as a concrete type.
+        MediaType::parse(ident).map(MediaQueryType::Concrete)
+    }
+
+    /// Returns whether this media query type matches a MediaType.
+    pub fn matches(&self, other: MediaType) -> bool {
+        match *self {
+            MediaQueryType::All => true,
+            MediaQueryType::Concrete(ref known_type) => *known_type == other,
+        }
+    }
+}

package/vendor/stylo/media_queries/mod.rs

@@ -0,0 +1,13 @@
+/* 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/. */
+
+//! [Media queries][mq].
+//!
+//! [mq]: https://drafts.csswg.org/mediaqueries/
+
+mod media_list;
+mod media_query;
+
+pub use self::media_list::MediaList;
+pub use self::media_query::{MediaQuery, MediaQueryType, MediaType, Qualifier};

package/vendor/stylo/parallel.rs

@@ -0,0 +1,205 @@
+/* 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/. */
+
+//! Implements parallel traversal over the DOM tree.
+//!
+//! This traversal is based on Rayon, and therefore its safety is largely
+//! verified by the type system.
+//!
+//! The primary trickiness and fine print for the above relates to the
+//! thread safety of the DOM nodes themselves. Accessing a DOM element
+//! concurrently on multiple threads is actually mostly "safe", since all
+//! the mutable state is protected by an AtomicRefCell, and so we'll
+//! generally panic if something goes wrong. Still, we try to to enforce our
+//! thread invariants at compile time whenever possible. As such, TNode and
+//! TElement are not Send, so ordinary style system code cannot accidentally
+//! share them with other threads. In the parallel traversal, we explicitly
+//! invoke |unsafe { SendNode::new(n) }| to put nodes in containers that may
+//! be sent to other threads. This occurs in only a handful of places and is
+//! easy to grep for. At the time of this writing, there is no other unsafe
+//! code in the parallel traversal.
+
+#![deny(missing_docs)]
+
+use crate::context::{StyleContext, ThreadLocalStyleContext};
+use crate::dom::{OpaqueNode, SendNode, TElement};
+use crate::scoped_tls::ScopedTLS;
+use crate::traversal::DomTraversal;
+use std::collections::VecDeque;
+
+/// The minimum stack size for a thread in the styling pool, in kilobytes.
+#[cfg(feature = "gecko")]
+pub const STYLE_THREAD_STACK_SIZE_KB: usize = 256;
+
+/// The minimum stack size for a thread in the styling pool, in kilobytes.
+/// Servo requires a bigger stack in debug builds.
+/// We allow configuring the size, since running with ASAN requires an even larger
+/// stack size.
+#[cfg(feature = "servo")]
+pub const STYLE_THREAD_STACK_SIZE_KB: usize = const {
+    let default_stack_size = 512;
+    if let Some(user_def_size) = option_env!("SERVO_STYLE_THREAD_STACK_SIZE_KB") {
+        if let Ok(user_def_size) = usize::from_str_radix(user_def_size, 10) {
+            user_def_size
+        } else {
+            panic!("SERVO_STYLE_THREAD_STACK_SIZE_KB must be a valid integer")
+        }
+    } else {
+        default_stack_size
+    }
+};
+
+/// The stack margin. If we get this deep in the stack, we will skip recursive
+/// optimizations to ensure that there is sufficient room for non-recursive work.
+///
+/// We allocate large safety margins because certain OS calls can use very large
+/// amounts of stack space [1]. Reserving a larger-than-necessary stack costs us
+/// address space, but if we keep our safety margin big, we will generally avoid
+/// committing those extra pages, and only use them in edge cases that would
+/// otherwise cause crashes.
+///
+/// When measured with 128KB stacks and 40KB margin, we could support 53
+/// levels of recursion before the limiter kicks in, on x86_64-Linux [2]. When
+/// we doubled the stack size, we added it all to the safety margin, so we should
+/// be able to get the same amount of recursion.
+///
+/// [1] https://bugzilla.mozilla.org/show_bug.cgi?id=1395708#c15
+/// [2] See Gecko bug 1376883 for more discussion on the measurements.
+pub const STACK_SAFETY_MARGIN_KB: usize = 168;
+
+/// A callback to create our thread local context.  This needs to be
+/// out of line so we don't allocate stack space for the entire struct
+/// in the caller.
+#[inline(never)]
+pub(crate) fn create_thread_local_context<'scope, E>(slot: &mut Option<ThreadLocalStyleContext<E>>)
+where
+    E: TElement + 'scope,
+{
+    *slot = Some(ThreadLocalStyleContext::new());
+}
+
+// Sends one chunk of work to the thread-pool.
+fn distribute_one_chunk<'a, 'scope, E, D>(
+    items: VecDeque<SendNode<E::ConcreteNode>>,
+    traversal_root: OpaqueNode,
+    work_unit_max: usize,
+    dom_depth: usize,
+    scope: &'a rayon::ScopeFifo<'scope>,
+    traversal: &'scope D,
+    tls: &'scope ScopedTLS<'scope, ThreadLocalStyleContext<E>>,
+) where
+    E: TElement + 'scope,
+    D: DomTraversal<E>,
+{
+    scope.spawn_fifo(move |scope| {
+        #[cfg(feature = "gecko")]
+        gecko_profiler_label!(Layout, StyleComputation);
+        let mut tlc = tls.ensure(create_thread_local_context);
+        tlc.current_dom_depth = dom_depth;
+        let mut context = StyleContext {
+            shared: traversal.shared_context(),
+            thread_local: &mut *tlc,
+        };
+        style_trees(
+            &mut context,
+            items,
+            traversal_root,
+            work_unit_max,
+            Some(scope),
+            traversal,
+            tls,
+        );
+    })
+}
+
+/// Distributes all items into the thread pool, in `work_unit_max` chunks.
+fn distribute_work<'a, 'scope, E, D>(
+    mut items: impl Iterator<Item = SendNode<E::ConcreteNode>>,
+    traversal_root: OpaqueNode,
+    work_unit_max: usize,
+    dom_depth: usize,
+    scope: &'a rayon::ScopeFifo<'scope>,
+    traversal: &'scope D,
+    tls: &'scope ScopedTLS<'scope, ThreadLocalStyleContext<E>>,
+) where
+    E: TElement + 'scope,
+    D: DomTraversal<E>,
+{
+    use std::iter::FromIterator;
+    loop {
+        let chunk = VecDeque::from_iter(items.by_ref().take(work_unit_max));
+        if chunk.is_empty() {
+            return;
+        }
+        distribute_one_chunk(
+            chunk,
+            traversal_root,
+            work_unit_max,
+            dom_depth,
+            scope,
+            traversal,
+            tls,
+        );
+    }
+}
+
+/// Processes `discovered` items, possibly spawning work in other threads as needed.
+#[inline]
+pub fn style_trees<'a, 'scope, E, D>(
+    context: &mut StyleContext<E>,
+    mut discovered: VecDeque<SendNode<E::ConcreteNode>>,
+    traversal_root: OpaqueNode,
+    work_unit_max: usize,
+    scope: Option<&'a rayon::ScopeFifo<'scope>>,
+    traversal: &'scope D,
+    tls: &'scope ScopedTLS<'scope, ThreadLocalStyleContext<E>>,
+) where
+    E: TElement + 'scope,
+    D: DomTraversal<E>,
+{
+    let local_queue_size = if tls.current_thread_index() == 0 {
+        crate::pref!("layout.css.stylo-local-work-queue.in-main-thread")
+    } else {
+        crate::pref!("layout.css.stylo-local-work-queue.in-worker")
+    } as usize;
+
+    let mut nodes_remaining_at_current_depth = discovered.len();
+    while let Some(node) = discovered.pop_front() {
+        let mut children_to_process = 0isize;
+        traversal.process_preorder(context, *node, |n| {
+            children_to_process += 1;
+            discovered.push_back(unsafe { SendNode::new(n) });
+        });
+
+        traversal.handle_postorder_traversal(context, traversal_root, *node, children_to_process);
+
+        nodes_remaining_at_current_depth -= 1;
+
+        // If we have enough children at the next depth in the DOM, spawn them to a different job
+        // relatively soon, while keeping always at least `local_queue_size` worth of work for
+        // ourselves.
+        let discovered_children = discovered.len() - nodes_remaining_at_current_depth;
+        if discovered_children >= work_unit_max
+            && discovered.len() >= local_queue_size + work_unit_max
+            && scope.is_some()
+        {
+            let kept_work = std::cmp::max(nodes_remaining_at_current_depth, local_queue_size);
+            distribute_work(
+                discovered.range(kept_work..).cloned(),
+                traversal_root,
+                work_unit_max,
+                context.thread_local.current_dom_depth + 1,
+                scope.unwrap(),
+                traversal,
+                tls,
+            );
+            discovered.truncate(kept_work);
+        }
+
+        if nodes_remaining_at_current_depth == 0 {
+            context.thread_local.current_dom_depth += 1;
+            nodes_remaining_at_current_depth = discovered.len();
+        }
+    }
+}