Struct StyleSharingCache 

pub struct StyleSharingCache<E: TElement> {
    cache_typeless: AtomicRefMut<'static, [SharingCacheBase<StyleSharingCandidate<usize>>; 8]>,
    marker: PhantomData<SendElement<E>>,
}

A set of LRU caches of the last few nodes seen, one per DOM depth, so that we can try to aggressively try to share their styles.

We key the candidates by DOM depth, because sharing requires an identical inheritance parent (see test_candidate), which in practice means the candidates worth testing are the ones at the target’s own depth.

Note that these caches only live for the duration of one traversal so storing nodes here temporarily is safe.

Fields

cache_typeless: AtomicRefMut<'static, [SharingCacheBase<StyleSharingCandidate<usize>>; 8]>

The per-depth LRU caches, with the type cast away to allow persisting the allocation across traversals.

marker: PhantomData<SendElement<E>>

Bind this structure to the lifetime of E, since that’s what we effectively store.

Implementations

impl<E: TElement> StyleSharingCache<E>

fn cache_mut_at( &mut self, index: usize, ) -> &mut SharingCacheBase<StyleSharingCandidate<E>>

pub fn new() -> Self

Create a new style sharing candidate cache.

pub fn insert_if_possible( &mut self, element: &E, style: &PrimaryStyle, validation_data_holder: Option<&mut StyleSharingTarget<E>>, dom_depth: usize, shared_context: &SharedStyleContext<'_>, )

Tries to insert an element in the style sharing cache.

Fails if we know it should never be in the cache.

NB: We pass a source for the validation data, rather than the data itself, to avoid memmoving at each function call. See rust issue #42763.

pub fn clear(&mut self)

Clear the style sharing candidate cache (all depths).

fn share_style_if_possible( &mut self, shared_context: &SharedStyleContext<'_>, bloom_filter: &StyleBloom<E>, selector_caches: &mut SelectorCaches, target: &mut StyleSharingTarget<E>, ) -> Option<ResolvedElementStyles>

Attempts to share a style with another node.

fn test_candidate( target: &mut StyleSharingTarget<E>, candidate: &mut StyleSharingCandidate<E>, shared: &SharedStyleContext<'_>, bloom: &StyleBloom<E>, selector_caches: &mut SelectorCaches, shared_context: &SharedStyleContext<'_>, ) -> Option<ResolvedElementStyles>

pub fn lookup_by_rules( &mut self, shared_context: &SharedStyleContext<'_>, inherited: &ComputedValues, inputs: &CascadeInputs, target: E, dom_depth: usize, ) -> Option<PrimaryStyle>

Attempts to find an element in the cache with the given primary rule node and parent.

FIXME(emilio): re-measure this optimization, and remove if it’s not very useful… It’s probably not worth the complexity / obscure bugs.

Trait Implementations

impl<E: TElement> Default for StyleSharingCache<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: TElement> Drop for StyleSharingCache<E>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.