blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/gecko/snapshot.rs

@@ -0,0 +1,202 @@
+/* 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 gecko snapshot, that stores the element attributes and state before they
+//! change in order to properly calculate restyle hints.
+
+use crate::dom::TElement;
+use crate::gecko::snapshot_helpers;
+use crate::gecko::wrapper::GeckoElement;
+use crate::gecko_bindings::bindings;
+use crate::gecko_bindings::structs::ServoElementSnapshot;
+use crate::gecko_bindings::structs::ServoElementSnapshotFlags as Flags;
+use crate::gecko_bindings::structs::ServoElementSnapshotTable;
+use crate::invalidation::element::element_wrapper::ElementSnapshot;
+use crate::selector_parser::AttrValue;
+use crate::string_cache::{Atom, Namespace};
+use crate::values::{AtomIdent, AtomString};
+use crate::LocalName;
+use crate::WeakAtom;
+use dom::ElementState;
+use selectors::attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint};
+
+/// A snapshot of a Gecko element.
+pub type GeckoElementSnapshot = ServoElementSnapshot;
+
+/// A map from elements to snapshots for Gecko's style back-end.
+pub type SnapshotMap = ServoElementSnapshotTable;
+
+impl SnapshotMap {
+    /// Gets the snapshot for this element, if any.
+    ///
+    /// FIXME(emilio): The transmute() business we do here is kind of nasty, but
+    /// it's a consequence of the map being a OpaqueNode -> Snapshot table in
+    /// Servo and an Element -> Snapshot table in Gecko.
+    ///
+    /// We should be able to make this a more type-safe with type annotations by
+    /// making SnapshotMap a trait and moving the implementations outside, but
+    /// that's a pain because it implies parameterizing SharedStyleContext.
+    pub fn get<E: TElement>(&self, element: &E) -> Option<&GeckoElementSnapshot> {
+        debug_assert!(element.has_snapshot());
+
+        unsafe {
+            let element = ::std::mem::transmute::<&E, &GeckoElement>(element);
+            bindings::Gecko_GetElementSnapshot(self, element.0).as_ref()
+        }
+    }
+}
+
+impl GeckoElementSnapshot {
+    #[inline]
+    fn has_any(&self, flags: Flags) -> bool {
+        (self.mContains as u8 & flags as u8) != 0
+    }
+
+    /// Returns true if the snapshot has stored state for pseudo-classes
+    /// that depend on things other than `ElementState`.
+    #[inline]
+    pub fn has_other_pseudo_class_state(&self) -> bool {
+        self.has_any(Flags::OtherPseudoClassState)
+    }
+
+    /// Returns true if the snapshot recorded an id change.
+    #[inline]
+    pub fn id_changed(&self) -> bool {
+        self.mIdAttributeChanged()
+    }
+
+    /// Returns true if the snapshot recorded a class attribute change.
+    #[inline]
+    pub fn class_changed(&self) -> bool {
+        self.mClassAttributeChanged()
+    }
+
+    /// Executes the callback once for each attribute that changed.
+    #[inline]
+    pub fn each_attr_changed<F>(&self, mut callback: F)
+    where
+        F: FnMut(&AtomIdent),
+    {
+        for attr in self.mChangedAttrNames.iter() {
+            unsafe { AtomIdent::with(attr.mRawPtr, &mut callback) }
+        }
+    }
+
+    /// selectors::Element::attr_matches
+    pub fn attr_matches(
+        &self,
+        ns: &NamespaceConstraint<&Namespace>,
+        local_name: &LocalName,
+        operation: &AttrSelectorOperation<&AttrValue>,
+    ) -> bool {
+        snapshot_helpers::attr_matches(&self.mAttrs, ns, local_name, operation)
+    }
+}
+
+impl ElementSnapshot for GeckoElementSnapshot {
+    fn debug_list_attributes(&self) -> String {
+        use nsstring::nsCString;
+        let mut string = nsCString::new();
+        unsafe {
+            bindings::Gecko_Snapshot_DebugListAttributes(self, &mut string);
+        }
+        String::from_utf8_lossy(&string).into_owned()
+    }
+
+    fn state(&self) -> Option<ElementState> {
+        if self.has_any(Flags::State) {
+            Some(ElementState::from_bits_retain(self.mState))
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn has_attrs(&self) -> bool {
+        self.has_any(Flags::Attributes)
+    }
+
+    #[inline]
+    fn id_attr(&self) -> Option<&WeakAtom> {
+        if !self.has_any(Flags::Id) {
+            return None;
+        }
+
+        snapshot_helpers::get_id(&self.mAttrs)
+    }
+
+    #[inline]
+    fn is_part(&self, name: &AtomIdent) -> bool {
+        let attr = match snapshot_helpers::find_attr(&self.mAttrs, &atom!("part")) {
+            Some(attr) => attr,
+            None => return false,
+        };
+
+        snapshot_helpers::has_class_or_part(name, CaseSensitivity::CaseSensitive, attr)
+    }
+
+    #[inline]
+    fn imported_part(&self, name: &AtomIdent) -> Option<AtomIdent> {
+        snapshot_helpers::imported_part(&self.mAttrs, name)
+    }
+
+    #[inline]
+    fn has_class(&self, name: &AtomIdent, case_sensitivity: CaseSensitivity) -> bool {
+        if !self.has_any(Flags::MaybeClass) {
+            return false;
+        }
+
+        snapshot_helpers::has_class_or_part(name, case_sensitivity, &self.mClass)
+    }
+
+    #[inline]
+    fn each_class<F>(&self, callback: F)
+    where
+        F: FnMut(&AtomIdent),
+    {
+        if !self.has_any(Flags::MaybeClass) {
+            return;
+        }
+
+        snapshot_helpers::each_class_or_part(&self.mClass, callback)
+    }
+
+    #[inline]
+    fn lang_attr(&self) -> Option<AtomString> {
+        let ptr = unsafe { bindings::Gecko_SnapshotLangValue(self) };
+        if ptr.is_null() {
+            None
+        } else {
+            Some(AtomString(unsafe { Atom::from_addrefed(ptr) }))
+        }
+    }
+
+    /// Returns true if the snapshot has stored state for custom states
+    #[inline]
+    fn has_custom_states(&self) -> bool {
+        self.has_any(Flags::CustomState)
+    }
+
+    /// Returns true if the snapshot has a given CustomState
+    #[inline]
+    fn has_custom_state(&self, state: &AtomIdent) -> bool {
+        unsafe {
+            self.mCustomStates
+                .iter()
+                .any(|setstate| AtomIdent::with(setstate.mRawPtr, |setstate| state == setstate))
+        }
+    }
+
+    #[inline]
+    fn each_custom_state<F>(&self, mut callback: F)
+    where
+        F: FnMut(&AtomIdent),
+    {
+        unsafe {
+            for atom in self.mCustomStates.iter() {
+                AtomIdent::with(atom.mRawPtr, &mut callback)
+            }
+        }
+    }
+}

package/vendor/stylo/gecko/snapshot_helpers.rs

@@ -0,0 +1,334 @@
+/* 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/. */
+
+//! Element an snapshot common logic.
+
+use crate::dom::TElement;
+use crate::gecko::wrapper::namespace_id_to_atom;
+use crate::gecko_bindings::bindings;
+use crate::gecko_bindings::structs::{self, nsAtom, AttrAtomArray};
+use crate::invalidation::element::element_wrapper::ElementSnapshot;
+use crate::selector_parser::{AttrValue, SnapshotMap};
+use crate::string_cache::WeakAtom;
+use crate::values::AtomIdent;
+use crate::{Atom, CaseSensitivityExt, LocalName, Namespace};
+use selectors::attr::{
+    AttrSelectorOperation, AttrSelectorOperator, CaseSensitivity, NamespaceConstraint,
+};
+use smallvec::SmallVec;
+
+/// A function that, given an element of type `T`, allows you to get a single
+/// class or a class list.
+enum Class<'a> {
+    None,
+    One(&'a nsAtom),
+    More(&'a AttrAtomArray),
+}
+
+#[inline(always)]
+fn base_type(attr: &structs::nsAttrValue) -> structs::nsAttrValue_ValueBaseType {
+    (attr.mBits & structs::NS_ATTRVALUE_BASETYPE_MASK) as structs::nsAttrValue_ValueBaseType
+}
+
+#[inline(always)]
+unsafe fn ptr<T>(attr: &structs::nsAttrValue) -> *const T {
+    (attr.mBits & !structs::NS_ATTRVALUE_BASETYPE_MASK) as *const T
+}
+
+#[inline(always)]
+unsafe fn get_class_or_part_from_attr(attr: &structs::nsAttrValue) -> Class<'_> {
+    debug_assert!(unsafe { bindings::Gecko_AssertClassAttrValueIsSane(attr) });
+    let base_type = base_type(attr);
+    if base_type == structs::nsAttrValue_ValueBaseType_eAtomBase {
+        return Class::One(unsafe { &*ptr::<nsAtom>(attr) });
+    }
+    if base_type == structs::nsAttrValue_ValueBaseType_eOtherBase {
+        unsafe {
+            let container = ptr::<structs::MiscContainer>(attr);
+            debug_assert_eq!(
+                (*container).mType,
+                structs::nsAttrValue_ValueType_eAtomArray
+            );
+            let atom_array: *const _ = *(*container)
+                .__bindgen_anon_1
+                .mValue
+                .as_ref()
+                .__bindgen_anon_1
+                .mAtomArray
+                .as_ref();
+            return Class::More(&*atom_array);
+        }
+    }
+    debug_assert_eq!(base_type, structs::nsAttrValue_ValueBaseType_eStringBase);
+    Class::None
+}
+
+#[inline(always)]
+unsafe fn get_id_from_attr(attr: &structs::nsAttrValue) -> &WeakAtom {
+    debug_assert_eq!(
+        base_type(attr),
+        structs::nsAttrValue_ValueBaseType_eAtomBase
+    );
+    unsafe { WeakAtom::new(ptr::<nsAtom>(attr)) }
+}
+
+impl structs::nsAttrName {
+    #[inline]
+    fn is_nodeinfo(&self) -> bool {
+        self.mBits & 1 != 0
+    }
+
+    #[inline]
+    unsafe fn as_nodeinfo(&self) -> &structs::NodeInfo {
+        debug_assert!(self.is_nodeinfo());
+        unsafe { &*((self.mBits & !1) as *const structs::NodeInfo) }
+    }
+
+    #[inline]
+    fn namespace_id(&self) -> i32 {
+        if !self.is_nodeinfo() {
+            return structs::kNameSpaceID_None;
+        }
+        unsafe { self.as_nodeinfo() }.mInner.mNamespaceID
+    }
+
+    /// Returns the attribute name as an atom pointer.
+    #[inline]
+    pub fn name(&self) -> *const nsAtom {
+        if self.is_nodeinfo() {
+            unsafe { self.as_nodeinfo() }.mInner.mName
+        } else {
+            self.mBits as *const nsAtom
+        }
+    }
+}
+
+/// Find an attribute value with a given name and no namespace.
+#[inline(always)]
+pub fn find_attr<'a>(
+    attrs: &'a [structs::AttrArray_InternalAttr],
+    name: &Atom,
+) -> Option<&'a structs::nsAttrValue> {
+    attrs
+        .iter()
+        .find(|attr| attr.mName.mBits == name.as_ptr() as usize)
+        .map(|attr| &attr.mValue)
+}
+
+/// Finds the id attribute from a list of attributes.
+#[inline(always)]
+pub fn get_id(attrs: &[structs::AttrArray_InternalAttr]) -> Option<&WeakAtom> {
+    Some(unsafe { get_id_from_attr(find_attr(attrs, &atom!("id"))?) })
+}
+
+#[inline(always)]
+pub(super) fn each_exported_part(
+    attrs: &[structs::AttrArray_InternalAttr],
+    name: &AtomIdent,
+    mut callback: impl FnMut(&AtomIdent),
+) {
+    let attr = match find_attr(attrs, &atom!("exportparts")) {
+        Some(attr) => attr,
+        None => return,
+    };
+    let mut length = 0;
+    let atoms = unsafe { bindings::Gecko_Element_ExportedParts(attr, name.as_ptr(), &mut length) };
+    if atoms.is_null() {
+        return;
+    }
+
+    unsafe {
+        for atom in std::slice::from_raw_parts(atoms, length) {
+            AtomIdent::with(*atom, &mut callback)
+        }
+    }
+}
+
+#[inline(always)]
+pub(super) fn imported_part(
+    attrs: &[structs::AttrArray_InternalAttr],
+    name: &AtomIdent,
+) -> Option<AtomIdent> {
+    let attr = find_attr(attrs, &atom!("exportparts"))?;
+    let atom = unsafe { bindings::Gecko_Element_ImportedPart(attr, name.as_ptr()) };
+    if atom.is_null() {
+        return None;
+    }
+    Some(AtomIdent(unsafe { Atom::from_raw(atom) }))
+}
+
+#[inline(always)]
+fn atom_array_atoms(atom_array: &AttrAtomArray) -> &[structs::RefPtr<nsAtom>] {
+    // NOTE: Bindgen doesn't deal with AutoTArray, so we cast it here...
+    let array = atom_array.mArray.0.as_ptr() as *const structs::nsTArray<structs::RefPtr<nsAtom>>;
+    unsafe { &*array }
+}
+
+#[inline(always)]
+fn atom_array_may_contain(atom_array: &AttrAtomArray, atom: &AtomIdent) -> bool {
+    // NOTE(emilio): Keep in sync with AttrAtomArray::MayContain().
+    let bit = 1 << ((atom.get_hash() >> 27) & 31);
+    atom_array.mBloomFilter & bit != 0
+}
+
+/// Given a class or part name, a case sensitivity, and an array of attributes,
+/// returns whether the attribute has that name.
+#[inline(always)]
+pub fn has_class_or_part(
+    name: &AtomIdent,
+    case_sensitivity: CaseSensitivity,
+    attr: &structs::nsAttrValue,
+) -> bool {
+    match unsafe { get_class_or_part_from_attr(attr) } {
+        Class::None => false,
+        Class::One(atom) => unsafe { case_sensitivity.eq_atom(name, WeakAtom::new(atom)) },
+        Class::More(atom_array) => match case_sensitivity {
+            CaseSensitivity::CaseSensitive => {
+                if !atom_array_may_contain(atom_array, name) {
+                    return false;
+                }
+                let name_ptr = name.as_ptr();
+                atom_array_atoms(atom_array)
+                    .iter()
+                    .any(|atom| atom.mRawPtr == name_ptr)
+            },
+            CaseSensitivity::AsciiCaseInsensitive => unsafe {
+                atom_array_atoms(atom_array)
+                    .iter()
+                    .any(|atom| WeakAtom::new(atom.mRawPtr).eq_ignore_ascii_case(name))
+            },
+        },
+    }
+}
+
+/// Given an item, a callback, and a getter, execute `callback` for each class
+/// or part name this `item` has.
+#[inline(always)]
+pub fn each_class_or_part<F>(attr: &structs::nsAttrValue, mut callback: F)
+where
+    F: FnMut(&AtomIdent),
+{
+    unsafe {
+        match get_class_or_part_from_attr(attr) {
+            Class::None => {},
+            Class::One(atom) => AtomIdent::with(atom, callback),
+            Class::More(atom_array) => {
+                for atom in atom_array_atoms(atom_array) {
+                    AtomIdent::with(atom.mRawPtr, &mut callback)
+                }
+            },
+        }
+    }
+}
+
+/// Returns a list of classes that were either added to or removed from the
+/// element since the snapshot.
+pub fn classes_changed<E: TElement>(element: &E, snapshots: &SnapshotMap) -> SmallVec<[Atom; 8]> {
+    debug_assert!(element.has_snapshot(), "Why bothering?");
+    let snapshot = snapshots.get(element).expect("has_snapshot lied");
+    if !snapshot.class_changed() {
+        return SmallVec::new();
+    }
+
+    let mut classes_changed = SmallVec::<[Atom; 8]>::new();
+    snapshot.each_class(|c| {
+        if !element.has_class(c, CaseSensitivity::CaseSensitive) {
+            classes_changed.push(c.0.clone());
+        }
+    });
+    element.each_class(|c| {
+        if !snapshot.has_class(c, CaseSensitivity::CaseSensitive) {
+            classes_changed.push(c.0.clone());
+        }
+    });
+
+    classes_changed
+}
+
+/// Returns whether a given attribute selector matches given the internal attrs.
+#[inline(always)]
+pub(crate) fn attr_matches(
+    attrs: &[structs::AttrArray_InternalAttr],
+    ns: &NamespaceConstraint<&Namespace>,
+    local_name: &LocalName,
+    operation: &AttrSelectorOperation<&AttrValue>,
+) -> bool {
+    let name_ptr = local_name.as_ptr();
+    for attr in attrs {
+        if attr.mName.name() != name_ptr {
+            continue;
+        }
+
+        if attr_matches_checked_name(attr, ns, operation) {
+            return true;
+        }
+
+        // The name matched but the value or namespace didn't. The only reason to check the other
+        // attributes now would be to find one with the same name but a different namespace.
+        if *ns != NamespaceConstraint::Any {
+            // We don't want to look for other namespaces, so we're done.
+            return false;
+        }
+    }
+    false
+}
+
+/// Returns whether a given attribute selector matches given a single attribute,
+/// for the case where the caller has already found an attribute with the right name.
+fn attr_matches_checked_name(
+    attr: &structs::AttrArray_InternalAttr,
+    ns: &NamespaceConstraint<&Namespace>,
+    operation: &AttrSelectorOperation<&AttrValue>,
+) -> bool {
+    let ns_matches = match *ns {
+        NamespaceConstraint::Any => true,
+        NamespaceConstraint::Specific(ns) => {
+            if *ns == ns!() {
+                !attr.mName.is_nodeinfo()
+            } else {
+                ns.as_ptr() == unsafe { namespace_id_to_atom(attr.mName.namespace_id()) }
+            }
+        },
+    };
+
+    if !ns_matches {
+        return false;
+    }
+
+    let (operator, case_sensitivity, value) = match *operation {
+        AttrSelectorOperation::Exists => return true,
+        AttrSelectorOperation::WithValue {
+            operator,
+            case_sensitivity,
+            value,
+        } => (operator, case_sensitivity, value),
+    };
+    let ignore_case = match case_sensitivity {
+        CaseSensitivity::CaseSensitive => false,
+        CaseSensitivity::AsciiCaseInsensitive => true,
+    };
+    let value = value.as_ptr();
+    unsafe {
+        match operator {
+            AttrSelectorOperator::Equal => {
+                bindings::Gecko_AttrEquals(&attr.mValue, value, ignore_case)
+            },
+            AttrSelectorOperator::Includes => {
+                bindings::Gecko_AttrIncludes(&attr.mValue, value, ignore_case)
+            },
+            AttrSelectorOperator::DashMatch => {
+                bindings::Gecko_AttrDashEquals(&attr.mValue, value, ignore_case)
+            },
+            AttrSelectorOperator::Prefix => {
+                bindings::Gecko_AttrHasPrefix(&attr.mValue, value, ignore_case)
+            },
+            AttrSelectorOperator::Suffix => {
+                bindings::Gecko_AttrHasSuffix(&attr.mValue, value, ignore_case)
+            },
+            AttrSelectorOperator::Substring => {
+                bindings::Gecko_AttrHasSubstring(&attr.mValue, value, ignore_case)
+            },
+        }
+    }
+}

package/vendor/stylo/gecko/traversal.rs

@@ -0,0 +1,52 @@
+/* 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/. */
+
+//! Gecko-specific bits for the styling DOM traversal.
+
+use crate::context::{SharedStyleContext, StyleContext};
+use crate::dom::{TElement, TNode};
+use crate::gecko::wrapper::{GeckoElement, GeckoNode};
+use crate::traversal::{recalc_style_at, DomTraversal};
+
+/// This is the simple struct that Gecko uses to encapsulate a DOM traversal for
+/// styling.
+pub struct RecalcStyleOnly<'a> {
+    shared: SharedStyleContext<'a>,
+}
+
+impl<'a> RecalcStyleOnly<'a> {
+    /// Create a `RecalcStyleOnly` traversal from a `SharedStyleContext`.
+    pub fn new(shared: SharedStyleContext<'a>) -> Self {
+        RecalcStyleOnly { shared }
+    }
+}
+
+impl<'recalc, 'le> DomTraversal<GeckoElement<'le>> for RecalcStyleOnly<'recalc> {
+    fn process_preorder<F>(
+        &self,
+        context: &mut StyleContext<GeckoElement<'le>>,
+        node: GeckoNode<'le>,
+        note_child: F,
+    ) where
+        F: FnMut(GeckoNode<'le>),
+    {
+        if let Some(el) = node.as_element() {
+            let mut data = unsafe { el.ensure_data() };
+            recalc_style_at(self, context, el, &mut data, note_child);
+        }
+    }
+
+    fn process_postorder(&self, _: &mut StyleContext<GeckoElement<'le>>, _: GeckoNode<'le>) {
+        unreachable!();
+    }
+
+    /// We don't use the post-order traversal for anything.
+    fn needs_postorder_traversal() -> bool {
+        false
+    }
+
+    fn shared_context(&self) -> &SharedStyleContext<'recalc> {
+        &self.shared
+    }
+}