blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/global_style_data.rs

@@ -0,0 +1,224 @@
+/* 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/. */
+
+//! Global style data
+
+use crate::context::StyleSystemOptions;
+#[cfg(feature = "gecko")]
+use crate::gecko_bindings::bindings;
+use crate::parallel::STYLE_THREAD_STACK_SIZE_KB;
+use crate::shared_lock::SharedRwLock;
+use crate::thread_state;
+use parking_lot::{Mutex, RwLock, RwLockReadGuard};
+#[cfg(all(unix, not(target_arch = "wasm32")))]
+use std::os::unix::thread::{JoinHandleExt, RawPthread};
+#[cfg(windows)]
+use std::os::windows::{io::AsRawHandle, prelude::RawHandle};
+use std::{io, sync::LazyLock, thread};
+use thin_vec::ThinVec;
+
+/// Platform-specific handle to a thread.
+#[cfg(all(unix, not(target_arch = "wasm32")))]
+pub type PlatformThreadHandle = RawPthread;
+/// Platform-specific handle to a thread.
+#[cfg(windows)]
+pub type PlatformThreadHandle = RawHandle;
+
+/// A noop thread join handle for wasm
+/// The usize field is a dummy field to make this type non-zero sized so as not to confuse FFI
+#[cfg(all(target_arch = "wasm32", not(feature = "gecko")))]
+pub struct DummyThreadHandle;
+#[cfg(all(target_arch = "wasm32", not(feature = "gecko")))]
+impl DummyThreadHandle {
+    /// A noop thread join method for wasm
+    pub fn join(&self) {
+        // Do nothing
+    }
+}
+#[cfg(all(target_arch = "wasm32", not(feature = "gecko")))]
+/// Platform-specific handle to a thread.
+pub type PlatformThreadHandle = DummyThreadHandle;
+
+/// Global style data
+pub struct GlobalStyleData {
+    /// Shared RWLock for CSSOM objects
+    pub shared_lock: SharedRwLock,
+
+    /// Global style system options determined by env vars.
+    pub options: StyleSystemOptions,
+}
+
+/// Global thread pool.
+pub struct StyleThreadPool {
+    /// How many threads parallel styling can use. If not using a thread pool, this is set to `None`.
+    pub num_threads: Option<usize>,
+
+    /// The parallel styling thread pool.
+    ///
+    /// For leak-checking purposes, we want to terminate the thread-pool, which
+    /// waits for all the async jobs to complete. Thus the RwLock.
+    style_thread_pool: RwLock<Option<rayon::ThreadPool>>,
+}
+
+fn thread_name(index: usize) -> String {
+    format!("StyleThread#{}", index)
+}
+
+/// JoinHandles for spawned style threads. These will be joined during
+/// StyleThreadPool::shutdown() after exiting the thread pool.
+///
+/// This would be quite inefficient if rayon destroyed and re-created
+/// threads regularly during threadpool operation in response to demand,
+/// however rayon actually never destroys its threads until the entire
+/// thread pool is shut-down, so the size of this list is bounded.
+static STYLE_THREAD_JOIN_HANDLES: Mutex<Vec<thread::JoinHandle<()>>> = Mutex::new(Vec::new());
+
+fn thread_spawn(options: rayon::ThreadBuilder) -> io::Result<()> {
+    let mut b = thread::Builder::new();
+    if let Some(name) = options.name() {
+        b = b.name(name.to_owned());
+    }
+    if let Some(stack_size) = options.stack_size() {
+        b = b.stack_size(stack_size);
+    }
+    let join_handle = b.spawn(|| options.run())?;
+    STYLE_THREAD_JOIN_HANDLES.lock().push(join_handle);
+    Ok(())
+}
+
+fn thread_startup(_index: usize) {
+    thread_state::initialize_layout_worker_thread();
+    #[cfg(feature = "gecko")]
+    unsafe {
+        bindings::Gecko_SetJemallocThreadLocalArena(true);
+        let name = thread_name(_index);
+        gecko_profiler::register_thread(&name);
+    }
+}
+
+fn thread_shutdown(_: usize) {
+    #[cfg(feature = "gecko")]
+    unsafe {
+        gecko_profiler::unregister_thread();
+        bindings::Gecko_SetJemallocThreadLocalArena(false);
+    }
+}
+
+impl StyleThreadPool {
+    /// Shuts down the thread pool, waiting for all work to complete.
+    pub fn shutdown() {
+        if STYLE_THREAD_JOIN_HANDLES.lock().is_empty() {
+            return;
+        }
+        {
+            // Drop the pool.
+            let _ = STYLE_THREAD_POOL.style_thread_pool.write().take();
+        }
+
+        // Join spawned threads until all of the threads have been joined. This
+        // will usually be pretty fast, as on shutdown there should be basically
+        // no threads left running.
+        while let Some(join_handle) = STYLE_THREAD_JOIN_HANDLES.lock().pop() {
+            let _ = join_handle.join();
+        }
+    }
+
+    /// Returns a reference to the thread pool.
+    ///
+    /// We only really want to give read-only access to the pool, except
+    /// for shutdown().
+    pub fn pool(&self) -> RwLockReadGuard<'_, Option<rayon::ThreadPool>> {
+        self.style_thread_pool.read()
+    }
+
+    /// Returns a list of the pool's platform-specific thread handles.
+    pub fn get_thread_handles(handles: &mut ThinVec<PlatformThreadHandle>) {
+        // Force the lazy initialization of STYLE_THREAD_POOL so that the threads get spawned and
+        // their join handles are added to STYLE_THREAD_JOIN_HANDLES.
+        LazyLock::force(&STYLE_THREAD_POOL);
+
+        for join_handle in STYLE_THREAD_JOIN_HANDLES.lock().iter() {
+            #[cfg(all(unix, not(target_arch = "wasm32")))]
+            let handle = join_handle.as_pthread_t();
+            #[cfg(windows)]
+            let handle = join_handle.as_raw_handle();
+            #[cfg(all(target_arch = "wasm32", not(feature = "gecko")))]
+            let handle = {
+                let _ = join_handle;
+                DummyThreadHandle
+            };
+
+            handles.push(handle);
+        }
+    }
+}
+
+#[cfg(feature = "servo")]
+fn stylo_threads_pref() -> i32 {
+    crate::pref!("layout.threads")
+}
+
+#[cfg(feature = "gecko")]
+fn stylo_threads_pref() -> i32 {
+    crate::pref!("layout.css.stylo-threads")
+}
+
+/// The performance benefit of additional threads seems to level off at around six, so we cap it
+/// there on many-core machines (see bug 1431285 comment 14).
+pub(crate) const STYLO_MAX_THREADS: usize = 6;
+
+/// Global thread pool
+pub static STYLE_THREAD_POOL: LazyLock<StyleThreadPool> = LazyLock::new(|| {
+    use std::cmp;
+    // We always set this pref on startup, before layout or script have had a chance of
+    // accessing (and thus creating) the thread-pool.
+    let threads_pref: i32 = stylo_threads_pref();
+    let num_threads = if threads_pref >= 0 {
+        threads_pref as usize
+    } else {
+        // Gecko may wish to override the default number of threads, for example on
+        // systems with heterogeneous CPUs.
+        #[cfg(feature = "gecko")]
+        let num_threads = unsafe { bindings::Gecko_GetNumStyleThreads() };
+        #[cfg(not(feature = "gecko"))]
+        let num_threads = -1;
+
+        if num_threads >= 0 {
+            num_threads as usize
+        } else {
+            // The default heuristic is num_virtual_cores * .75. This gives us three threads on a
+            // hyper-threaded dual core, and six threads on a hyper-threaded quad core.
+            cmp::max(num_cpus::get() * 3 / 4, 1)
+        }
+    };
+
+    let num_threads = cmp::min(num_threads, STYLO_MAX_THREADS);
+    // Since the main-thread is also part of the pool, having one thread or less doesn't make
+    // sense.
+    let (pool, num_threads) = if num_threads <= 1 {
+        (None, None)
+    } else {
+        let workers = rayon::ThreadPoolBuilder::new()
+            .spawn_handler(thread_spawn)
+            .use_current_thread()
+            .num_threads(num_threads)
+            .thread_name(thread_name)
+            .start_handler(thread_startup)
+            .exit_handler(thread_shutdown)
+            .stack_size(STYLE_THREAD_STACK_SIZE_KB * 1024)
+            .build();
+        (workers.ok(), Some(num_threads))
+    };
+
+    StyleThreadPool {
+        num_threads,
+        style_thread_pool: RwLock::new(pool),
+    }
+});
+
+/// Global style data
+pub static GLOBAL_STYLE_DATA: LazyLock<GlobalStyleData> = LazyLock::new(|| GlobalStyleData {
+    shared_lock: SharedRwLock::new_leaked(),
+    options: StyleSystemOptions::default(),
+});

package/vendor/stylo/invalidation/element/document_state.rs

@@ -0,0 +1,156 @@
+/* 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/. */
+
+//! An invalidation processor for style changes due to document state changes.
+
+use crate::dom::TElement;
+use crate::invalidation::element::invalidation_map::Dependency;
+use crate::invalidation::element::invalidator::{
+    DescendantInvalidationLists, InvalidationVector, SiblingTraversalMap,
+};
+use crate::invalidation::element::invalidator::{Invalidation, InvalidationProcessor};
+use crate::invalidation::element::state_and_attributes;
+use crate::stylist::CascadeData;
+use dom::DocumentState;
+use selectors::matching::{
+    MatchingContext, MatchingForInvalidation, MatchingMode, NeedsSelectorFlags, QuirksMode,
+    SelectorCaches, VisitedHandlingMode,
+};
+use selectors::OpaqueElement;
+
+/// A struct holding the members necessary to invalidate document state
+/// selectors.
+#[derive(Debug)]
+pub struct InvalidationMatchingData {
+    /// The document state that has changed, which makes it always match.
+    pub document_state: DocumentState,
+}
+
+impl Default for InvalidationMatchingData {
+    #[inline(always)]
+    fn default() -> Self {
+        Self {
+            document_state: DocumentState::empty(),
+        }
+    }
+}
+
+/// An invalidation processor for style changes due to state and attribute
+/// changes.
+pub struct DocumentStateInvalidationProcessor<'a, 'b, E: TElement, I> {
+    rules: I,
+    matching_context: MatchingContext<'a, E::Impl>,
+    traversal_map: SiblingTraversalMap<E>,
+    document_states_changed: DocumentState,
+    _marker: std::marker::PhantomData<&'b ()>,
+}
+
+impl<'a, 'b, E: TElement, I> DocumentStateInvalidationProcessor<'a, 'b, E, I> {
+    /// Creates a new DocumentStateInvalidationProcessor.
+    #[inline]
+    pub fn new(
+        rules: I,
+        document_states_changed: DocumentState,
+        selector_caches: &'a mut SelectorCaches,
+        quirks_mode: QuirksMode,
+    ) -> Self {
+        let mut matching_context = MatchingContext::<'a, E::Impl>::new_for_visited(
+            MatchingMode::Normal,
+            None,
+            selector_caches,
+            VisitedHandlingMode::AllLinksVisitedAndUnvisited,
+            quirks_mode,
+            NeedsSelectorFlags::No,
+            MatchingForInvalidation::No,
+        );
+
+        matching_context.extra_data.invalidation_data.document_state = document_states_changed;
+
+        Self {
+            rules,
+            document_states_changed,
+            matching_context,
+            traversal_map: SiblingTraversalMap::default(),
+            _marker: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, 'b, E, I> InvalidationProcessor<'b, 'a, E>
+    for DocumentStateInvalidationProcessor<'a, 'b, E, I>
+where
+    E: TElement,
+    I: Iterator<Item = &'b CascadeData>,
+{
+    fn check_outer_dependency(&mut self, _: &Dependency, _: E, _: Option<OpaqueElement>) -> bool {
+        debug_assert!(
+            false,
+            "how, we should only have parent-less dependencies here!"
+        );
+        true
+    }
+
+    fn collect_invalidations(
+        &mut self,
+        _element: E,
+        self_invalidations: &mut InvalidationVector<'b>,
+        _descendant_invalidations: &mut DescendantInvalidationLists<'b>,
+        _sibling_invalidations: &mut InvalidationVector<'b>,
+    ) -> bool {
+        for cascade_data in &mut self.rules {
+            let map = cascade_data.invalidation_map();
+            for dependency in &map.document_state_selectors {
+                if !dependency.state.intersects(self.document_states_changed) {
+                    continue;
+                }
+
+                // We pass `None` as a scope, as document state selectors aren't
+                // affected by the current scope.
+                //
+                // FIXME(emilio): We should really pass the relevant host for
+                // self.rules, so that we invalidate correctly if the selector
+                // happens to have something like :host(:-moz-window-inactive)
+                // for example.
+                self_invalidations.push(Invalidation::new(
+                    &dependency.dependency,
+                    /* host = */ None,
+                    /* scope = */ None,
+                ));
+            }
+        }
+
+        false
+    }
+
+    fn matching_context(&mut self) -> &mut MatchingContext<'a, E::Impl> {
+        &mut self.matching_context
+    }
+
+    fn sibling_traversal_map(&self) -> &SiblingTraversalMap<E> {
+        &self.traversal_map
+    }
+
+    fn recursion_limit_exceeded(&mut self, _: E) {
+        unreachable!("We don't run document state invalidation with stack limits")
+    }
+
+    fn should_process_descendants(&mut self, element: E) -> bool {
+        match element.borrow_data() {
+            Some(d) => state_and_attributes::should_process_descendants(&d),
+            None => false,
+        }
+    }
+
+    fn invalidated_descendants(&mut self, element: E, child: E) {
+        state_and_attributes::invalidated_descendants(element, child)
+    }
+
+    fn invalidated_self(&mut self, element: E) {
+        state_and_attributes::invalidated_self(element);
+    }
+
+    fn invalidated_sibling(&mut self, sibling: E, of: E) {
+        state_and_attributes::invalidated_sibling(sibling, of);
+    }
+}