blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/servo/shadow_parts.rs

@@ -0,0 +1,207 @@
+/* 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/. */
+
+use crate::derives::*;
+use crate::values::AtomIdent;
+use crate::Atom;
+
+type Mapping<'a> = (&'a str, &'a str);
+
+#[derive(Clone, Debug, MallocSizeOf)]
+pub struct ShadowParts {
+    // FIXME: Consider a smarter data structure for this.
+    // Gecko uses a hashtable in both directions:
+    // https://searchfox.org/mozilla-central/rev/5d4178378f84c7130ccb8ac1723d33e380d7f7d7/layout/style/ShadowParts.h
+    mappings: Vec<(Atom, Atom)>,
+}
+
+/// <https://drafts.csswg.org/css-shadow-parts/#parsing-mapping>
+///
+/// Returns `None` in the failure case.
+pub fn parse_part_mapping(input: &str) -> Option<Mapping<'_>> {
+    // Step 1. Let input be the string being parsed.
+    // Step 2. Let position be a pointer into input, initially pointing at the start of the string.
+    // NOTE: We don't need an explicit position, we just drop stuff from the input
+
+    // Step 3. Collect a sequence of code points that are space characters
+    let input = input.trim_start_matches(|c| c == ' ');
+
+    // Step 4. Collect a sequence of code points that are not space characters or U+003A COLON characters,
+    // and let first token be the result.
+    let space_or_colon_position = input
+        .char_indices()
+        .find(|(_, c)| matches!(c, ' ' | ':'))
+        .map(|(index, _)| index)
+        .unwrap_or(input.len());
+    let (first_token, input) = input.split_at(space_or_colon_position);
+
+    // Step 5. If first token is empty then return error.
+    if first_token.is_empty() {
+        return None;
+    }
+
+    // Step 6. Collect a sequence of code points that are space characters.
+    let input = input.trim_start_matches(|c| c == ' ');
+
+    // Step 7. If the end of the input has been reached, return the tuple (first token, first token)
+    if input.is_empty() {
+        return Some((first_token, first_token));
+    }
+
+    // Step 8. If character at position is not a U+003A COLON character, return error.
+    // Step 9. Consume the U+003A COLON character.
+    let Some(input) = input.strip_prefix(':') else {
+        return None;
+    };
+
+    // Step 10. Collect a sequence of code points that are space characters.
+    let input = input.trim_start_matches(|c| c == ' ');
+
+    // Step 11. Collect a sequence of code points that are not space characters or U+003A COLON characters.
+    // and let second token be the result.
+    let space_or_colon_position = input
+        .char_indices()
+        .find(|(_, c)| matches!(c, ' ' | ':'))
+        .map(|(index, _)| index)
+        .unwrap_or(input.len());
+    let (second_token, input) = input.split_at(space_or_colon_position);
+
+    // Step 12. If second token is empty then return error.
+    if second_token.is_empty() {
+        return None;
+    }
+
+    // Step 13. Collect a sequence of code points that are space characters.
+    let input = input.trim_start_matches(|c| c == ' ');
+
+    // Step 14. If position is not past the end of input then return error.
+    if !input.is_empty() {
+        return None;
+    }
+
+    // Step 14. Return the tuple (first token, second token).
+    Some((first_token, second_token))
+}
+
+/// <https://drafts.csswg.org/css-shadow-parts/#parsing-mapping-list>
+fn parse_mapping_list(input: &str) -> impl Iterator<Item = Mapping<'_>> {
+    // Step 1. Let input be the string being parsed.
+    // Step 2. Split the string input on commas. Let unparsed mappings be the resulting list of strings.
+    let unparsed_mappings = input.split(',');
+
+    // Step 3. Let mappings be an initially empty list of tuples of tokens.
+    // This list will be the result of this algorithm.
+    // NOTE: We return an iterator here - it is up to the caller to turn it into a list
+
+    // Step 4. For each string unparsed mapping in unparsed mappings, run the following substeps:
+    unparsed_mappings.filter_map(|unparsed_mapping| {
+        // Step 4.1 If unparsed mapping is empty or contains only space characters,
+        // continue to the next iteration of the loop.
+        if unparsed_mapping.chars().all(|c| c == ' ') {
+            return None;
+        }
+
+        // Step 4.2 Let mapping be the result of parsing unparsed mapping using the rules for parsing part mappings.
+        // Step 4.3 If mapping is an error then continue to the next iteration of the loop.
+        // This allows clients to skip over new syntax that is not understood.
+        // Step 4.4 Append mapping to mappings.
+        parse_part_mapping(unparsed_mapping)
+    })
+}
+
+impl ShadowParts {
+    pub fn parse(input: &str) -> Self {
+        Self {
+            mappings: parse_mapping_list(input)
+                .map(|(first, second)| (first.into(), second.into()))
+                .collect(),
+        }
+    }
+
+    /// Call the provided callback for each exported part with the given name.
+    pub fn for_each_exported_part<F>(&self, name: &Atom, mut callback: F)
+    where
+        F: FnMut(&AtomIdent),
+    {
+        for (from, to) in &self.mappings {
+            if from == name {
+                callback(AtomIdent::cast(to));
+            }
+        }
+    }
+
+    pub fn imported_part(&self, name: &Atom) -> Option<&Atom> {
+        self.mappings
+            .iter()
+            .find(|(_, to)| to == name)
+            .map(|(from, _)| from)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_valid_mapping() {
+        assert_eq!(
+            parse_part_mapping("foo"),
+            Some(("foo", "foo")),
+            "Single token"
+        );
+        assert_eq!(
+            parse_part_mapping("  foo"),
+            Some(("foo", "foo")),
+            "Single token with leading whitespace"
+        );
+        assert_eq!(
+            parse_part_mapping("foo "),
+            Some(("foo", "foo")),
+            "Single token with trailing whitespace"
+        );
+        assert_eq!(
+            parse_part_mapping("foo:bar"),
+            Some(("foo", "bar")),
+            "Two tokens"
+        );
+        assert_eq!(
+            parse_part_mapping("foo:bar "),
+            Some(("foo", "bar")),
+            "Two tokens with trailing whitespace"
+        );
+        assert_eq!(
+            parse_part_mapping("🦀:🚀"),
+            Some(("🦀", "🚀")),
+            "Two tokens consisting of non-ascii characters"
+        );
+    }
+
+    #[test]
+    fn reject_invalid_mapping() {
+        assert!(parse_part_mapping("").is_none(), "Empty input");
+        assert!(parse_part_mapping("    ").is_none(), "Only whitespace");
+        assert!(parse_part_mapping("foo bar").is_none(), "Missing colon");
+        assert!(parse_part_mapping(":bar").is_none(), "Empty first token");
+        assert!(parse_part_mapping("foo:").is_none(), "Empty second token");
+        assert!(
+            parse_part_mapping("foo:bar baz").is_none(),
+            "Trailing input"
+        );
+    }
+
+    #[test]
+    fn parse_valid_mapping_list() {
+        let mut mappings = parse_mapping_list("foo: bar, totally-invalid-mapping:,,");
+
+        // "foo: bar" is a valid mapping
+        assert_eq!(
+            mappings.next(),
+            Some(("foo", "bar")),
+            "First mapping should be in the list"
+        );
+        // "totally-invalid-mapping" is not a valid mapping and should be ignored
+        // "" is not valid (and consists of nothing but whitespace), so it should be ignored
+        assert_eq!(mappings.next(), None, "No more mappings should exist");
+    }
+}

package/vendor/stylo/shared_lock.rs

@@ -0,0 +1,271 @@
+/* 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/. */
+
+//! Different objects protected by the same lock
+
+use crate::derives::MallocSizeOf;
+use crate::stylesheets::Origin;
+use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
+use servo_arc::Arc;
+use std::cell::UnsafeCell;
+use std::fmt;
+use std::ptr;
+use style_traits::{CssString, CssStringWriter};
+use to_shmem::{SharedMemoryBuilder, ToShmem};
+
+/// A shared read/write lock that can protect multiple objects.
+///
+/// We don't need the blocking behavior, just the safety. As such we implement
+/// this with an AtomicRefCell, which is ~2x as fast as an RwLock, and panics
+/// (rather than deadlocking) when things go wrong (which is much easier to
+/// debug on CI).
+///
+/// Gecko also needs the ability to have "read only" SharedRwLocks, which are
+/// used for objects stored in (read only) shared memory. Attempting to acquire
+/// write access to objects protected by a read only SharedRwLock will panic.
+#[derive(Clone)]
+pub struct SharedRwLock {
+    cell: Option<Arc<AtomicRefCell<SomethingZeroSizedButTyped>>>,
+}
+
+#[cfg(feature = "servo")]
+malloc_size_of::malloc_size_of_is_0!(SharedRwLock);
+
+#[derive(MallocSizeOf)]
+struct SomethingZeroSizedButTyped;
+
+impl fmt::Debug for SharedRwLock {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("SharedRwLock")
+    }
+}
+
+impl Default for SharedRwLock {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SharedRwLock {
+    /// Create a new shared lock.
+    pub fn new() -> Self {
+        SharedRwLock {
+            cell: Some(Arc::new(AtomicRefCell::new(SomethingZeroSizedButTyped))),
+        }
+    }
+
+    /// Create a new global shared lock.
+    pub fn new_leaked() -> Self {
+        SharedRwLock {
+            cell: Some(Arc::new_leaked(AtomicRefCell::new(
+                SomethingZeroSizedButTyped,
+            ))),
+        }
+    }
+
+    /// Create a new read-only shared lock.
+    pub fn read_only() -> Self {
+        SharedRwLock { cell: None }
+    }
+
+    #[inline]
+    fn ptr(&self) -> *const SomethingZeroSizedButTyped {
+        self.cell
+            .as_ref()
+            .map(|cell| cell.as_ptr() as *const _)
+            .unwrap_or(ptr::null())
+    }
+
+    /// Wrap the given data to make its access protected by this lock.
+    pub fn wrap<T>(&self, data: T) -> Locked<T> {
+        Locked {
+            shared_lock: self.clone(),
+            data: UnsafeCell::new(data),
+        }
+    }
+
+    /// Obtain the lock for reading.
+    pub fn read(&self) -> SharedRwLockReadGuard<'_> {
+        SharedRwLockReadGuard(self.cell.as_ref().map(|cell| cell.borrow()))
+    }
+
+    /// Obtain the lock for writing.
+    pub fn write(&self) -> SharedRwLockWriteGuard<'_> {
+        SharedRwLockWriteGuard(self.cell.as_ref().unwrap().borrow_mut())
+    }
+}
+
+/// Proof that a shared lock was obtained for reading.
+pub struct SharedRwLockReadGuard<'a>(Option<AtomicRef<'a, SomethingZeroSizedButTyped>>);
+
+impl<'a> SharedRwLockReadGuard<'a> {
+    #[inline]
+    fn ptr(&self) -> *const SomethingZeroSizedButTyped {
+        self.0
+            .as_ref()
+            .map(|r| &**r as *const _)
+            .unwrap_or(ptr::null())
+    }
+}
+
+/// Proof that a shared lock was obtained for writing.
+pub struct SharedRwLockWriteGuard<'a>(AtomicRefMut<'a, SomethingZeroSizedButTyped>);
+
+/// Data protect by a shared lock.
+pub struct Locked<T> {
+    shared_lock: SharedRwLock,
+    data: UnsafeCell<T>,
+}
+
+// Unsafe: the data inside `UnsafeCell` is only accessed in `read_with` and `write_with`,
+// where guards ensure synchronization.
+unsafe impl<T: Send> Send for Locked<T> {}
+unsafe impl<T: Send + Sync> Sync for Locked<T> {}
+
+impl<T: fmt::Debug> fmt::Debug for Locked<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let guard = self.shared_lock.read();
+        self.read_with(&guard).fmt(f)
+    }
+}
+
+impl<T> Locked<T> {
+    #[inline]
+    fn is_read_only_lock(&self) -> bool {
+        self.shared_lock.cell.is_none()
+    }
+
+    fn same_lock_as(&self, ptr: *const SomethingZeroSizedButTyped) -> bool {
+        ptr::eq(self.shared_lock.ptr(), ptr)
+    }
+
+    /// Access the data for reading.
+    pub fn read_with<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> &'a T {
+        assert!(
+            self.is_read_only_lock() || self.same_lock_as(guard.ptr()),
+            "Locked::read_with called with a guard from an unrelated SharedRwLock: {:?} vs. {:?}",
+            self.shared_lock.ptr(),
+            guard.ptr(),
+        );
+
+        let ptr = self.data.get();
+
+        // Unsafe:
+        //
+        // * The guard guarantees that the lock is taken for reading,
+        //   and we’ve checked that it’s the correct lock.
+        // * The returned reference borrows *both* the data and the guard,
+        //   so that it can outlive neither.
+        unsafe { &*ptr }
+    }
+
+    /// Access the data for reading without verifying the lock. Use with caution.
+    pub unsafe fn read_unchecked(&self) -> &T {
+        unsafe {
+            let ptr = self.data.get();
+            &*ptr
+        }
+    }
+
+    /// Access the data for writing.
+    pub fn write_with<'a>(&'a self, guard: &'a mut SharedRwLockWriteGuard) -> &'a mut T {
+        assert!(
+            !self.is_read_only_lock() && self.same_lock_as(&*guard.0),
+            "Locked::write_with called with a guard from a read only or unrelated SharedRwLock"
+        );
+
+        let ptr = self.data.get();
+
+        // Unsafe:
+        //
+        // * The guard guarantees that the lock is taken for writing,
+        //   and we’ve checked that it’s the correct lock.
+        // * The returned reference borrows *both* the data and the guard,
+        //   so that it can outlive neither.
+        // * We require a mutable borrow of the guard,
+        //   so that one write guard can only be used once at a time.
+        unsafe { &mut *ptr }
+    }
+}
+
+impl<T: ToShmem> ToShmem for Locked<T> {
+    fn to_shmem(&self, builder: &mut SharedMemoryBuilder) -> to_shmem::Result<Self> {
+        use std::mem::ManuallyDrop;
+
+        let guard = self.shared_lock.read();
+        Ok(ManuallyDrop::new(Locked {
+            shared_lock: SharedRwLock::read_only(),
+            data: UnsafeCell::new(ManuallyDrop::into_inner(
+                self.read_with(&guard).to_shmem(builder)?,
+            )),
+        }))
+    }
+}
+
+#[allow(dead_code)]
+mod compile_time_assert {
+    use super::{SharedRwLockReadGuard, SharedRwLockWriteGuard};
+
+    trait Marker1 {}
+    impl<T: Clone> Marker1 for T {}
+    impl<'a> Marker1 for SharedRwLockReadGuard<'a> {} // Assert SharedRwLockReadGuard: !Clone
+    impl<'a> Marker1 for SharedRwLockWriteGuard<'a> {} // Assert SharedRwLockWriteGuard: !Clone
+
+    trait Marker2 {}
+    impl<T: Copy> Marker2 for T {}
+    impl<'a> Marker2 for SharedRwLockReadGuard<'a> {} // Assert SharedRwLockReadGuard: !Copy
+    impl<'a> Marker2 for SharedRwLockWriteGuard<'a> {} // Assert SharedRwLockWriteGuard: !Copy
+}
+
+/// Like ToCss, but with a lock guard given by the caller, and with the writer specified
+/// concretely rather than with a parameter.
+pub trait ToCssWithGuard {
+    /// Serialize `self` in CSS syntax, writing to `dest`, using the given lock guard.
+    fn to_css(&self, guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result;
+
+    /// Serialize `self` in CSS syntax using the given lock guard and return a string.
+    ///
+    /// (This is a convenience wrapper for `to_css` and probably should not be overridden.)
+    #[inline]
+    fn to_css_string(&self, guard: &SharedRwLockReadGuard) -> CssString {
+        let mut s = CssString::new();
+        self.to_css(guard, &mut s).unwrap();
+        s
+    }
+}
+
+/// A trait to do a deep clone of a given CSS type. Gets a lock and a read
+/// guard, in order to be able to read and clone nested structures.
+pub trait DeepCloneWithLock: Sized {
+    /// Deep clones this object.
+    fn deep_clone_with_lock(&self, lock: &SharedRwLock, guard: &SharedRwLockReadGuard) -> Self;
+}
+
+/// Guards for a document
+#[derive(Clone)]
+pub struct StylesheetGuards<'a> {
+    /// For author-origin stylesheets.
+    pub author: &'a SharedRwLockReadGuard<'a>,
+
+    /// For user-agent-origin and user-origin stylesheets
+    pub ua_or_user: &'a SharedRwLockReadGuard<'a>,
+}
+
+impl<'a> StylesheetGuards<'a> {
+    /// Get the guard for a given stylesheet origin.
+    pub fn for_origin(&self, origin: Origin) -> &SharedRwLockReadGuard<'a> {
+        match origin {
+            Origin::Author => self.author,
+            _ => self.ua_or_user,
+        }
+    }
+
+    /// Same guard for all origins
+    pub fn same(guard: &'a SharedRwLockReadGuard<'a>) -> Self {
+        StylesheetGuards {
+            author: guard,
+            ua_or_user: guard,
+        }
+    }
+}