Struct style::sharing::StyleSharingCache

pub struct StyleSharingCache<E: TElement> {
    cache_typeless: AtomicRefMut<'static, SharingCacheBase<FakeCandidate>>,
    marker: PhantomData<SendElement<E>>,
    dom_depth: usize,
}

An LRU cache of the last few nodes seen, so that we can aggressively try to reuse their styles.

Note that this cache is flushed every time we steal work from the queue, so storing nodes here temporarily is safe.

Fields

cache_typeless: AtomicRefMut<'static, SharingCacheBase<FakeCandidate>>

The LRU cache, with the type cast away to allow persisting the allocation.

marker: PhantomData<SendElement<E>>

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

dom_depth: usize

The DOM depth we’re currently at. This is used as an optimization to clear the cache when we change depths, since we know at that point nothing in the cache will match.

Implementations

impl<E: TElement> StyleSharingCache<E>

fn cache(&self) -> &SharingCacheBase<StyleSharingCandidate<E>>

fn cache_mut(&mut self) -> &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.

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, rules: &StrongRuleNode, visited_rules: Option<&StrongRuleNode>, target: E, ) -> 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> Drop for StyleSharingCache<E>

fn drop(&mut self)

Executes the destructor for this type.