blitz-pdf 0.0.0-stage → 0.1.1

package/vendor/stylo/gecko/anon_boxes.toml

@@ -0,0 +1,113 @@
+# 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 http://mozilla.org/MPL/2.0/.
+
+# This file contains the list of anonymous boxes and some flags, much like
+# longhands.toml and pseudo_elements.toml.
+#
+# Each anon box has its own section, with the following keys:
+#   inherits - whether the anon box inherits from its parent or not. Defaults to true.
+#   wrapper - whether the anon box is a wrapper around other frames during
+#             frame tree fix-up (e.g. table anonymous boxes, ruby anonymous boxes, anonymous
+#             flex item blocks, etc). Defaults to false.
+#
+# When adding an anon box, you also need to add the relevant atom to
+# StaticAtoms.py, with the camel-case name of the anon box, in the same order as
+# this file.
+
+[-moz-oof-placeholder]
+inherits = false
+# Framesets
+[-moz-hframeset-border]
+inherits = false
+[-moz-vframeset-border]
+inherits = false
+[-moz-frameset-blank]
+inherits = false
+
+# Table
+[-moz-table-column-group]
+inherits = false
+[-moz-table-column]
+inherits = false
+
+[-moz-page]
+inherits = false
+[-moz-page-break]
+inherits = false
+[-moz-page-content]
+inherits = false
+[-moz-printed-sheet]
+inherits = false
+
+# Applies to blocks that wrap contiguous runs of "column-span: all" elements in
+# multi-column subtrees, or the wrappers themselves, all the way up to the
+# column set wrappers.
+[-moz-column-span-wrapper]
+inherits = false
+
+# ::-moz-text, ::-moz-oof-placeholder, and ::-moz-first-letter-continuation are
+# non-elements which no rule will match.
+[-moz-text]
+# nsFirstLetterFrames for content outside the ::first-letter.
+[-moz-first-letter-continuation]
+
+[-moz-block-inside-inline-wrapper]
+[-moz-mathml-anonymous-block]
+wrapper = true
+[-moz-line-frame]
+
+[-moz-cell-content]
+[-moz-fieldset-content]
+[-moz-html-canvas-content]
+
+[-moz-inline-table]
+wrapper = true
+[-moz-table]
+wrapper = true
+[-moz-table-cell]
+wrapper = true
+[-moz-table-wrapper]
+[-moz-table-row-group]
+wrapper = true
+[-moz-table-row]
+wrapper = true
+
+[-moz-canvas]
+inherits = false
+[-moz-page-sequence]
+[-moz-scrolled-content]
+
+# A column set is a set of columns inside of ColumnSetWrapperFrame, which
+# applies to nsColumnSetFrame. It doesn't contain any column-span elements.
+[-moz-column-set]
+[-moz-column-content]
+
+# The root (viewport) frame
+[-moz-viewport]
+inherits = false
+# The root scrollframe.
+[-moz-viewport-scroll]
+inherits = false
+
+# Inside a flex/grid/-moz-box container, a contiguous run of text gets wrapped
+# in an anonymous block, which is then treated as a flex item.
+[-moz-anonymous-item]
+wrapper = true
+
+[-moz-block-ruby-content]
+[-moz-ruby]
+wrapper = true
+[-moz-ruby-base]
+wrapper = true
+[-moz-ruby-base-container]
+wrapper = true
+[-moz-ruby-text]
+wrapper = true
+[-moz-ruby-text-container]
+wrapper = true
+
+[-moz-svg-marker-anon-child]
+[-moz-svg-outer-svg-anon-child]
+[-moz-svg-foreign-content]
+[-moz-svg-text]

package/vendor/stylo/gecko/arc_types.rs

@@ -0,0 +1,211 @@
+/* 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/. */
+
+//! This file lists all arc FFI types and defines corresponding addref and release functions. This
+//! list loosely corresponds to ServoLockedArcTypeList.inc file in Gecko.
+
+#![allow(non_snake_case, missing_docs)]
+
+use crate::media_queries::MediaList;
+use crate::properties::animated_properties::AnimationValue;
+use crate::properties::{ComputedValues, PropertyDeclarationBlock};
+use crate::shared_lock::Locked;
+use crate::stylesheets::keyframes_rule::Keyframe;
+use crate::stylesheets::{
+    AppearanceBaseRule, ContainerRule, CssRules, CustomMediaRule, DocumentRule,
+    FontFeatureValuesRule, FontPaletteValuesRule, LayerBlockRule, LayerStatementRule, MarginRule,
+    MediaRule, NamespaceRule, PropertyRule, ScopeRule, StartingStyleRule, StylesheetContents,
+    SupportsRule, ViewTransitionRule,
+};
+pub use crate::stylesheets::{
+    LockedCounterStyleRule, LockedFontFaceRule, LockedImportRule, LockedKeyframesRule,
+    LockedNestedDeclarationsRule, LockedPageRule, LockedPositionTryRule, LockedStyleRule,
+};
+use crate::url::gecko::CssUrlData;
+use servo_arc::Arc;
+
+macro_rules! impl_simple_arc_ffi {
+    ($ty:ty, $addref:ident, $release:ident) => {
+        #[unsafe(no_mangle)]
+        pub unsafe extern "C" fn $addref(obj: *const $ty) {
+            unsafe {
+                std::mem::forget(Arc::from_raw_addrefed(obj));
+            }
+        }
+
+        #[unsafe(no_mangle)]
+        pub unsafe extern "C" fn $release(obj: *const $ty) {
+            unsafe {
+                let _ = Arc::from_raw(obj);
+            }
+        }
+    };
+}
+
+macro_rules! impl_locked_arc_ffi {
+    ($servo_type:ty, $alias:ident, $addref:ident, $release:ident) => {
+        /// A simple alias for a locked type.
+        pub type $alias = Locked<$servo_type>;
+        impl_simple_arc_ffi!($alias, $addref, $release);
+    };
+}
+
+impl_locked_arc_ffi!(
+    CssRules,
+    LockedCssRules,
+    Servo_CssRules_AddRef,
+    Servo_CssRules_Release
+);
+impl_locked_arc_ffi!(
+    PropertyDeclarationBlock,
+    LockedDeclarationBlock,
+    Servo_DeclarationBlock_AddRef,
+    Servo_DeclarationBlock_Release
+);
+impl_simple_arc_ffi!(
+    LockedStyleRule,
+    Servo_StyleRule_AddRef,
+    Servo_StyleRule_Release
+);
+impl_simple_arc_ffi!(
+    LockedImportRule,
+    Servo_ImportRule_AddRef,
+    Servo_ImportRule_Release
+);
+impl_locked_arc_ffi!(
+    Keyframe,
+    LockedKeyframe,
+    Servo_Keyframe_AddRef,
+    Servo_Keyframe_Release
+);
+impl_simple_arc_ffi!(
+    LockedKeyframesRule,
+    Servo_KeyframesRule_AddRef,
+    Servo_KeyframesRule_Release
+);
+impl_simple_arc_ffi!(
+    LayerBlockRule,
+    Servo_LayerBlockRule_AddRef,
+    Servo_LayerBlockRule_Release
+);
+impl_simple_arc_ffi!(
+    LayerStatementRule,
+    Servo_LayerStatementRule_AddRef,
+    Servo_LayerStatementRule_Release
+);
+impl_locked_arc_ffi!(
+    MediaList,
+    LockedMediaList,
+    Servo_MediaList_AddRef,
+    Servo_MediaList_Release
+);
+impl_simple_arc_ffi!(MediaRule, Servo_MediaRule_AddRef, Servo_MediaRule_Release);
+impl_simple_arc_ffi!(
+    CustomMediaRule,
+    Servo_CustomMediaRule_AddRef,
+    Servo_CustomMediaRule_Release
+);
+impl_simple_arc_ffi!(
+    NamespaceRule,
+    Servo_NamespaceRule_AddRef,
+    Servo_NamespaceRule_Release
+);
+impl_simple_arc_ffi!(
+    MarginRule,
+    Servo_MarginRule_AddRef,
+    Servo_MarginRule_Release
+);
+impl_simple_arc_ffi!(
+    LockedPageRule,
+    Servo_PageRule_AddRef,
+    Servo_PageRule_Release
+);
+impl_simple_arc_ffi!(
+    PropertyRule,
+    Servo_PropertyRule_AddRef,
+    Servo_PropertyRule_Release
+);
+impl_simple_arc_ffi!(
+    SupportsRule,
+    Servo_SupportsRule_AddRef,
+    Servo_SupportsRule_Release
+);
+impl_simple_arc_ffi!(
+    ContainerRule,
+    Servo_ContainerRule_AddRef,
+    Servo_ContainerRule_Release
+);
+impl_simple_arc_ffi!(
+    DocumentRule,
+    Servo_DocumentRule_AddRef,
+    Servo_DocumentRule_Release
+);
+impl_simple_arc_ffi!(
+    FontFeatureValuesRule,
+    Servo_FontFeatureValuesRule_AddRef,
+    Servo_FontFeatureValuesRule_Release
+);
+impl_simple_arc_ffi!(
+    FontPaletteValuesRule,
+    Servo_FontPaletteValuesRule_AddRef,
+    Servo_FontPaletteValuesRule_Release
+);
+impl_simple_arc_ffi!(
+    LockedFontFaceRule,
+    Servo_FontFaceRule_AddRef,
+    Servo_FontFaceRule_Release
+);
+impl_simple_arc_ffi!(
+    LockedCounterStyleRule,
+    Servo_CounterStyleRule_AddRef,
+    Servo_CounterStyleRule_Release
+);
+
+impl_simple_arc_ffi!(
+    StylesheetContents,
+    Servo_StyleSheetContents_AddRef,
+    Servo_StyleSheetContents_Release
+);
+impl_simple_arc_ffi!(
+    CssUrlData,
+    Servo_CssUrlData_AddRef,
+    Servo_CssUrlData_Release
+);
+impl_simple_arc_ffi!(
+    ComputedValues,
+    Servo_ComputedStyle_AddRef,
+    Servo_ComputedStyle_Release
+);
+impl_simple_arc_ffi!(
+    AnimationValue,
+    Servo_AnimationValue_AddRef,
+    Servo_AnimationValue_Release
+);
+impl_simple_arc_ffi!(ScopeRule, Servo_ScopeRule_AddRef, Servo_ScopeRule_Release);
+impl_simple_arc_ffi!(
+    StartingStyleRule,
+    Servo_StartingStyleRule_AddRef,
+    Servo_StartingStyleRule_Release
+);
+impl_simple_arc_ffi!(
+    AppearanceBaseRule,
+    Servo_AppearanceBaseRule_AddRef,
+    Servo_AppearanceBaseRule_Release
+);
+
+impl_simple_arc_ffi!(
+    LockedPositionTryRule,
+    Servo_PositionTryRule_AddRef,
+    Servo_PositionTryRule_Release
+);
+impl_simple_arc_ffi!(
+    LockedNestedDeclarationsRule,
+    Servo_NestedDeclarationsRule_AddRef,
+    Servo_NestedDeclarationsRule_Release
+);
+impl_simple_arc_ffi!(
+    ViewTransitionRule,
+    Servo_ViewTransitionRule_AddRef,
+    Servo_ViewTransitionRule_Release
+);

package/vendor/stylo/gecko/conversions.rs

@@ -0,0 +1,59 @@
+/* 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/. */
+
+//! This module contains conversion helpers between Servo and Gecko types
+//! Ideally, it would be in geckolib itself, but coherence
+//! forces us to keep the traits and implementations here
+//!
+//! FIXME(emilio): This file should generally just die.
+
+#![allow(unsafe_code)]
+
+use crate::gecko_bindings::structs::{nsresult, Matrix4x4Components};
+use crate::stylesheets::RulesMutateError;
+use crate::values::computed::transform::Matrix3D;
+
+impl From<RulesMutateError> for nsresult {
+    fn from(other: RulesMutateError) -> Self {
+        match other {
+            RulesMutateError::Syntax => nsresult::NS_ERROR_DOM_SYNTAX_ERR,
+            RulesMutateError::IndexSize => nsresult::NS_ERROR_DOM_INDEX_SIZE_ERR,
+            RulesMutateError::HierarchyRequest => nsresult::NS_ERROR_DOM_HIERARCHY_REQUEST_ERR,
+            RulesMutateError::InvalidState => nsresult::NS_ERROR_DOM_INVALID_STATE_ERR,
+        }
+    }
+}
+
+impl<'a> From<&'a Matrix4x4Components> for Matrix3D {
+    fn from(m: &'a Matrix4x4Components) -> Matrix3D {
+        Matrix3D {
+            m11: m[0],
+            m12: m[1],
+            m13: m[2],
+            m14: m[3],
+            m21: m[4],
+            m22: m[5],
+            m23: m[6],
+            m24: m[7],
+            m31: m[8],
+            m32: m[9],
+            m33: m[10],
+            m34: m[11],
+            m41: m[12],
+            m42: m[13],
+            m43: m[14],
+            m44: m[15],
+        }
+    }
+}
+
+impl From<Matrix3D> for Matrix4x4Components {
+    fn from(matrix: Matrix3D) -> Self {
+        [
+            matrix.m11, matrix.m12, matrix.m13, matrix.m14, matrix.m21, matrix.m22, matrix.m23,
+            matrix.m24, matrix.m31, matrix.m32, matrix.m33, matrix.m34, matrix.m41, matrix.m42,
+            matrix.m43, matrix.m44,
+        ]
+    }
+}

package/vendor/stylo/gecko/data.rs

@@ -0,0 +1,222 @@
+/* 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/. */
+
+//! Data needed to style a Gecko document.
+
+use crate::derives::*;
+use crate::device::Device;
+use crate::gecko_bindings::bindings;
+use crate::gecko_bindings::structs::{
+    self, ServoStyleSetSizes, StyleSheet as DomStyleSheet, StyleSheetInfo,
+};
+use crate::invalidation::stylesheets::StylesheetInvalidationSet;
+use crate::media_queries::MediaList;
+use crate::properties::ComputedValues;
+use crate::shared_lock::{SharedRwLockReadGuard, StylesheetGuards};
+use crate::stylesheets::scope_rule::ImplicitScopeRoot;
+use crate::stylesheets::{StylesheetContents, StylesheetInDocument};
+use crate::stylist::Stylist;
+use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
+use malloc_size_of::MallocSizeOfOps;
+use selectors::Element;
+use servo_arc::Arc;
+use std::fmt;
+
+use super::wrapper::GeckoElement;
+
+/// Little wrapper to a Gecko style sheet.
+#[derive(Eq, PartialEq)]
+pub struct GeckoStyleSheet(*const DomStyleSheet);
+
+// NOTE(emilio): These are kind of a lie. We allow to make these Send + Sync so that other data
+// structures can also be Send and Sync, but Gecko's stylesheets are main-thread-reference-counted.
+//
+// We assert that we reference-count in the right thread (in the Addref/Release implementations).
+// Sending these to a different thread can't really happen (it could theoretically really happen if
+// we allowed @import rules inside a nested style rule, but that can't happen per spec and would be
+// a parser bug, caught by the asserts).
+unsafe impl Send for GeckoStyleSheet {}
+unsafe impl Sync for GeckoStyleSheet {}
+
+impl fmt::Debug for GeckoStyleSheet {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let contents = self.raw_contents();
+        formatter
+            .debug_struct("GeckoStyleSheet")
+            .field("origin", &contents.origin)
+            .field("url_data", &contents.url_data)
+            .finish()
+    }
+}
+
+impl GeckoStyleSheet {
+    /// Create a `GeckoStyleSheet` from a raw `DomStyleSheet` pointer.
+    #[inline]
+    pub unsafe fn new(s: *const DomStyleSheet) -> Self {
+        unsafe {
+            debug_assert!(!s.is_null());
+            bindings::Gecko_StyleSheet_AddRef(s);
+            Self::from_addrefed(s)
+        }
+    }
+
+    /// Create a `GeckoStyleSheet` from a raw `DomStyleSheet` pointer that
+    /// already holds a strong reference.
+    #[inline]
+    pub unsafe fn from_addrefed(s: *const DomStyleSheet) -> Self {
+        assert!(!s.is_null());
+        GeckoStyleSheet(s)
+    }
+
+    /// HACK(emilio): This is so that we can avoid crashing release due to
+    /// bug 1719963 and can hopefully get a useful report from fuzzers.
+    #[inline]
+    pub fn hack_is_null(&self) -> bool {
+        self.0.is_null()
+    }
+
+    /// Get the raw `StyleSheet` that we're wrapping.
+    pub fn raw(&self) -> &DomStyleSheet {
+        unsafe { &*self.0 }
+    }
+
+    fn inner(&self) -> &StyleSheetInfo {
+        unsafe { &*(self.raw().mInner as *const StyleSheetInfo) }
+    }
+
+    fn raw_contents(&self) -> &StylesheetContents {
+        debug_assert!(!self.inner().mContents.mRawPtr.is_null());
+        unsafe { &*self.inner().mContents.mRawPtr }
+    }
+}
+
+impl Drop for GeckoStyleSheet {
+    fn drop(&mut self) {
+        unsafe { bindings::Gecko_StyleSheet_Release(self.0) };
+    }
+}
+
+impl Clone for GeckoStyleSheet {
+    fn clone(&self) -> Self {
+        unsafe { bindings::Gecko_StyleSheet_AddRef(self.0) };
+        GeckoStyleSheet(self.0)
+    }
+}
+
+impl StylesheetInDocument for GeckoStyleSheet {
+    fn media<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> Option<&'a MediaList> {
+        use crate::gecko_bindings::structs::mozilla::dom::MediaList as DomMediaList;
+        unsafe {
+            let dom_media_list = self.raw().mMedia.mRawPtr as *const DomMediaList;
+            if dom_media_list.is_null() {
+                return None;
+            }
+            let list = &*(*dom_media_list).mRawList.mRawPtr;
+            Some(list.read_with(guard))
+        }
+    }
+
+    // All the stylesheets Servo knows about are enabled, because that state is
+    // handled externally by Gecko.
+    #[inline]
+    fn enabled(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn contents<'a>(&'a self, _: &'a SharedRwLockReadGuard) -> &'a StylesheetContents {
+        self.raw_contents()
+    }
+
+    fn implicit_scope_root(&self) -> Option<ImplicitScopeRoot> {
+        unsafe {
+            let result = bindings::Gecko_StyleSheet_ImplicitScopeRoot(self.0);
+            if result.mRoot.is_null() {
+                return if result.mConstructed {
+                    Some(ImplicitScopeRoot::Constructed)
+                } else {
+                    // Could be genuinely not attached, like user stylesheet.
+                    None
+                };
+            }
+
+            let root = GeckoElement(result.mRoot.as_ref().unwrap()).opaque();
+            Some(if !result.mHost.is_null() {
+                let host = GeckoElement(result.mHost.as_ref().unwrap()).opaque();
+                if host == root {
+                    ImplicitScopeRoot::ShadowHost(root)
+                } else {
+                    ImplicitScopeRoot::InShadowTree(root)
+                }
+            } else {
+                ImplicitScopeRoot::InLightTree(root)
+            })
+        }
+    }
+}
+
+/// The container for data that a Servo-backed Gecko document needs to style
+/// itself.
+pub struct PerDocumentStyleDataImpl {
+    /// Rule processor.
+    pub stylist: Stylist,
+
+    /// A cache from element to resolved style.
+    pub undisplayed_style_cache: crate::traversal::UndisplayedStyleCache,
+
+    /// The generation for which our cache is valid.
+    pub undisplayed_style_cache_generation: u64,
+}
+
+/// The data itself is an `AtomicRefCell`, which guarantees the proper semantics
+/// and unexpected races while trying to mutate it.
+#[derive(Deref)]
+pub struct PerDocumentStyleData(AtomicRefCell<PerDocumentStyleDataImpl>);
+
+impl PerDocumentStyleData {
+    /// Create a `PerDocumentStyleData`.
+    pub fn new(document: *const structs::Document) -> Self {
+        let device = Device::new(document);
+        let quirks_mode = device.document().mCompatMode;
+
+        PerDocumentStyleData(AtomicRefCell::new(PerDocumentStyleDataImpl {
+            stylist: Stylist::new(device, quirks_mode.into()),
+            undisplayed_style_cache: Default::default(),
+            undisplayed_style_cache_generation: 0,
+        }))
+    }
+
+    /// Get an immutable reference to this style data.
+    pub fn borrow(&self) -> AtomicRef<'_, PerDocumentStyleDataImpl> {
+        self.0.borrow()
+    }
+
+    /// Get an mutable reference to this style data.
+    pub fn borrow_mut(&self) -> AtomicRefMut<'_, PerDocumentStyleDataImpl> {
+        self.0.borrow_mut()
+    }
+}
+
+impl PerDocumentStyleDataImpl {
+    /// Recreate the style data if the stylesheets have changed.
+    pub fn flush_stylesheets(
+        &mut self,
+        guard: &SharedRwLockReadGuard,
+    ) -> StylesheetInvalidationSet {
+        self.stylist.flush(&StylesheetGuards::same(guard))
+    }
+
+    /// Get the default computed values for this document.
+    pub fn default_computed_values(&self) -> &Arc<ComputedValues> {
+        self.stylist.device().default_computed_values_arc()
+    }
+
+    /// Measure heap usage.
+    pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
+        self.stylist.add_size_of(ops, sizes);
+    }
+}
+
+/// The gecko-specific AuthorStyles instantiation.
+pub type AuthorStyles = crate::author_styles::AuthorStyles<GeckoStyleSheet>;