Skip to main content

lgui_assets/
cache.rs

1#[cfg(any(test, feature = "backend-winit"))]
2use std::io::Cursor;
3use std::{cell::RefCell, sync::Arc};
4
5#[cfg(any(test, feature = "backend-winit"))]
6use std::{
7    collections::HashMap,
8    fs,
9    sync::{
10        atomic::{AtomicUsize, Ordering},
11        Mutex,
12    },
13    time::{Duration, Instant},
14};
15
16#[cfg(feature = "persistent-cache")]
17use std::time::{SystemTime, UNIX_EPOCH};
18
19use super::{AssetBytes, ImageSource, ImageStatus};
20#[cfg(any(test, feature = "backend-winit"))]
21use super::{AssetError, RemoteImageLoaderHandle};
22#[cfg(any(
23    test,
24    feature = "persistent-cache",
25    all(feature = "backend-winit", feature = "images")
26))]
27use crate::core::ImageCachePolicy;
28#[cfg(any(test, feature = "backend-winit"))]
29use crate::core::ImageDecodePolicy;
30use crate::core::ImageRequest;
31
32/// Safety ceiling for a single encoded image (bytes on the wire/disk).
33#[cfg(any(test, feature = "backend-winit"))]
34const MAX_ENCODED_RESOURCE_BYTES: usize = 32 * 1024 * 1024;
35/// Safety ceiling for a single decoded image (RGBA pixel buffer).
36#[cfg(any(test, feature = "backend-winit"))]
37const MAX_DECODED_RESOURCE_BYTES: usize = 128 * 1024 * 1024;
38
39#[derive(Clone)]
40pub struct ImageCacheHandle {
41    request: Arc<dyn Fn(&ImageRequest) -> ImageStatus + Send + Sync>,
42    #[cfg(any(test, feature = "renderer-skia"))]
43    bytes: Arc<dyn Fn(&ImageRequest) -> Option<AssetBytes> + Send + Sync>,
44    stats: Arc<dyn Fn() -> ImageCacheStats + Send + Sync>,
45    trim: Arc<dyn Fn(usize) -> usize + Send + Sync>,
46    set_budget: Arc<dyn Fn(usize) + Send + Sync>,
47    reachability: Arc<dyn Fn(crate::memory::DomainInstanceId, &[ImageRequest]) + Send + Sync>,
48}
49
50#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
51pub struct ImageCacheStats {
52    pub entries: usize,
53    pub resident_bytes: usize,
54    pub pinned_bytes: usize,
55    pub budget_bytes: usize,
56    pub hits: u64,
57    pub misses: u64,
58    pub evictions: u64,
59    pub largest_entry_bytes: usize,
60    pub in_flight: usize,
61}
62
63impl ImageCacheHandle {
64    pub fn new(
65        request: impl Fn(&ImageRequest) -> ImageStatus + Send + Sync + 'static,
66        bytes: impl Fn(&ImageRequest) -> Option<AssetBytes> + Send + Sync + 'static,
67    ) -> Self {
68        Self::new_managed(
69            request,
70            bytes,
71            ImageCacheStats::default,
72            |_| 0,
73            |_| {},
74            |_, _| {},
75        )
76    }
77
78    #[doc(hidden)]
79    pub fn new_managed(
80        request: impl Fn(&ImageRequest) -> ImageStatus + Send + Sync + 'static,
81        bytes: impl Fn(&ImageRequest) -> Option<AssetBytes> + Send + Sync + 'static,
82        stats: impl Fn() -> ImageCacheStats + Send + Sync + 'static,
83        trim: impl Fn(usize) -> usize + Send + Sync + 'static,
84        set_budget: impl Fn(usize) + Send + Sync + 'static,
85        reachability: impl Fn(crate::memory::DomainInstanceId, &[ImageRequest]) + Send + Sync + 'static,
86    ) -> Self {
87        #[cfg(not(any(test, feature = "renderer-skia")))]
88        let _ = bytes;
89        Self {
90            request: Arc::new(request),
91            #[cfg(any(test, feature = "renderer-skia"))]
92            bytes: Arc::new(bytes),
93            stats: Arc::new(stats),
94            trim: Arc::new(trim),
95            set_budget: Arc::new(set_budget),
96            reachability: Arc::new(reachability),
97        }
98    }
99
100    pub(super) fn request(&self, request: &ImageRequest) -> ImageStatus {
101        (self.request)(request)
102    }
103
104    pub fn stats(&self) -> ImageCacheStats {
105        (self.stats)()
106    }
107
108    pub fn trim_to(&self, target_bytes: usize) -> usize {
109        (self.trim)(target_bytes)
110    }
111
112    pub fn set_budget(&self, budget_bytes: usize) {
113        (self.set_budget)(budget_bytes);
114    }
115
116    pub fn update_reachability(
117        &self,
118        owner: crate::memory::DomainInstanceId,
119        requests: &[ImageRequest],
120    ) {
121        (self.reachability)(owner, requests);
122    }
123
124    #[cfg(any(test, feature = "renderer-skia"))]
125    pub(super) fn bytes(&self, request: &ImageRequest) -> Option<AssetBytes> {
126        (self.bytes)(request)
127    }
128}
129
130thread_local! {
131    static IMAGE_CACHE_HANDLE: RefCell<Option<ImageCacheHandle>> = const { RefCell::new(None) };
132}
133
134pub(crate) struct ImageCacheGuard {
135    previous: Option<ImageCacheHandle>,
136}
137
138impl Drop for ImageCacheGuard {
139    fn drop(&mut self) {
140        IMAGE_CACHE_HANDLE.with(|current| {
141            *current.borrow_mut() = self.previous.take();
142        });
143    }
144}
145
146pub(crate) fn install_image_cache(handle: ImageCacheHandle) -> ImageCacheGuard {
147    let previous = IMAGE_CACHE_HANDLE.with(|current| current.borrow_mut().replace(handle));
148    ImageCacheGuard { previous }
149}
150
151/// Starts loading an image and returns its current cache status.
152pub fn request_image(request: &ImageRequest) -> ImageStatus {
153    IMAGE_CACHE_HANDLE.with(|current| {
154        current.borrow().as_ref().map_or_else(
155            || match request.source() {
156                ImageSource::Static(_) | ImageSource::Bytes { .. } => ImageStatus::Ready,
157                ImageSource::File(_) | ImageSource::Url(_) => ImageStatus::Failed,
158            },
159            |cache| cache.request(request),
160        )
161    })
162}
163
164pub(crate) fn update_image_reachability(
165    owner: crate::memory::DomainInstanceId,
166    requests: &[ImageRequest],
167) {
168    IMAGE_CACHE_HANDLE.with(|current| {
169        if let Some(cache) = current.borrow().as_ref() {
170            cache.update_reachability(owner, requests);
171        }
172    });
173}
174
175#[cfg(feature = "renderer-skia")]
176pub(crate) fn cached_image_bytes(request: &ImageRequest) -> Option<AssetBytes> {
177    IMAGE_CACHE_HANDLE.with(|current| {
178        current
179            .borrow()
180            .as_ref()
181            .and_then(|cache| cache.bytes(request))
182    })
183}
184
185#[cfg(any(test, feature = "backend-winit"))]
186struct AsyncImageEntry {
187    status: ImageStatus,
188    bytes: Option<AssetBytes>,
189    resident_bytes: usize,
190    used: u64,
191    retry_at: Option<Instant>,
192    policy: ImageCachePolicy,
193    priority: crate::memory::CachePriority,
194    reachable: bool,
195}
196
197#[cfg(any(test, feature = "backend-winit"))]
198struct AsyncImageState {
199    entries: HashMap<String, AsyncImageEntry>,
200    reachable_by_owner: HashMap<crate::memory::DomainInstanceId, std::collections::HashSet<String>>,
201    epoch: u64,
202    generation: u64,
203    resident_bytes: usize,
204    hits: u64,
205    misses: u64,
206    evictions: u64,
207}
208
209#[cfg(any(test, feature = "backend-winit"))]
210impl AsyncImageState {
211    fn new() -> Self {
212        Self {
213            entries: HashMap::new(),
214            reachable_by_owner: HashMap::new(),
215            epoch: 0,
216            generation: 0,
217            resident_bytes: 0,
218            hits: 0,
219            misses: 0,
220            evictions: 0,
221        }
222    }
223}
224
225#[cfg(any(test, feature = "backend-winit"))]
226pub(crate) fn async_image_cache(
227    loader: RemoteImageLoaderHandle,
228    wake: impl Fn() + Send + Sync + 'static,
229    budget_bytes: usize,
230    governor: crate::memory::MemoryGovernor,
231) -> ImageCacheHandle {
232    let state = Arc::new(Mutex::new(AsyncImageState::new()));
233    let budget = Arc::new(AtomicUsize::new(budget_bytes));
234    let wake: Arc<dyn Fn() + Send + Sync> = Arc::new(wake);
235    let request_state = Arc::clone(&state);
236    let request_loader = loader.clone();
237    let request_wake = Arc::clone(&wake);
238    let request_budget = Arc::clone(&budget);
239    let request_governor = governor.clone();
240    let request = move |request: &ImageRequest| match request.source() {
241        ImageSource::Static(_) | ImageSource::Bytes { .. } => ImageStatus::Ready,
242        ImageSource::File(_) | ImageSource::Url(_) => request_async_image(
243            Arc::clone(&request_state),
244            request_loader.clone(),
245            Arc::clone(&request_wake),
246            request.clone(),
247            Arc::clone(&request_budget),
248            request_governor.clone(),
249        ),
250    };
251    let bytes_state = Arc::clone(&state);
252    let bytes_governor = governor.clone();
253    let bytes = move |request: &ImageRequest| {
254        let key = request.cache_key();
255        let mut state = bytes_state.lock().expect("async image cache poisoned");
256        state.generation = state.generation.wrapping_add(1);
257        let generation = state.generation;
258        let entry = state.entries.get_mut(&key)?;
259        entry.used = generation;
260        entry.reachable = true;
261        let bytes = entry.bytes.clone()?;
262        let remove_after_read = entry.policy == ImageCachePolicy::NoStore;
263        if remove_after_read {
264            if let Some(entry) = state.entries.remove(&key) {
265                state.resident_bytes = state.resident_bytes.saturating_sub(entry.resident_bytes);
266                state.evictions = state.evictions.saturating_add(1);
267            }
268        }
269        drop(state);
270        let _reservation = bytes_governor.try_reserve_task(MAX_DECODED_RESOURCE_BYTES)?;
271        prepare_image_bytes(bytes, request).ok()
272    };
273    let stats_state = Arc::clone(&state);
274    let stats_budget = Arc::clone(&budget);
275    let stats = move || {
276        let state = stats_state.lock().expect("async image cache poisoned");
277        ImageCacheStats {
278            entries: state.entries.len(),
279            resident_bytes: state.resident_bytes,
280            pinned_bytes: state
281                .entries
282                .values()
283                .filter(|entry| entry.reachable)
284                .map(|entry| entry.resident_bytes)
285                .sum(),
286            budget_bytes: stats_budget.load(Ordering::Acquire),
287            hits: state.hits,
288            misses: state.misses,
289            evictions: state.evictions,
290            largest_entry_bytes: state
291                .entries
292                .values()
293                .map(|entry| entry.resident_bytes)
294                .max()
295                .unwrap_or(0),
296            in_flight: state
297                .entries
298                .values()
299                .filter(|entry| entry.status == ImageStatus::Loading)
300                .count(),
301        }
302    };
303    let trim_state = Arc::clone(&state);
304    let trim = move |target_bytes| {
305        let mut state = trim_state.lock().expect("async image cache poisoned");
306        let before = state.resident_bytes;
307        if target_bytes == 0 {
308            state.epoch = state.epoch.wrapping_add(1);
309            state.reachable_by_owner.clear();
310        }
311        evict_async_images(&mut state, target_bytes, 0, target_bytes != 0);
312        before.saturating_sub(state.resident_bytes)
313    };
314    let set_state = Arc::clone(&state);
315    let set_budget_value = Arc::clone(&budget);
316    let set_budget = move |value: usize| {
317        set_budget_value.store(value, Ordering::Release);
318        let mut state = set_state.lock().expect("async image cache poisoned");
319        evict_async_images(&mut state, value, 4096, true);
320    };
321    let reachability_state = Arc::clone(&state);
322    let reachability_governor = governor.clone();
323    let reachability_budget = Arc::clone(&budget);
324    let reachability = move |owner, requests: &[ImageRequest]| {
325        let mut state = reachability_state
326            .lock()
327            .expect("async image cache poisoned");
328        if requests.is_empty() {
329            state.reachable_by_owner.remove(&owner);
330        } else {
331            state.reachable_by_owner.insert(
332                owner,
333                requests.iter().map(ImageRequest::cache_key).collect(),
334            );
335        }
336        let reachable = state
337            .reachable_by_owner
338            .values()
339            .flatten()
340            .cloned()
341            .collect::<std::collections::HashSet<_>>();
342        for entry in state.entries.values_mut() {
343            entry.reachable = false;
344        }
345        for request in requests {
346            if let Some(entry) = state.entries.get_mut(&request.cache_key()) {
347                entry.policy = request
348                    .cache_policy_value(reachability_governor.options().default_image_cache_policy);
349                entry.priority = request.priority_value();
350            }
351        }
352        for (key, entry) in &mut state.entries {
353            entry.reachable = reachable.contains(key);
354        }
355        evict_unreachable_visible_images(&mut state);
356        evict_async_images(
357            &mut state,
358            reachability_budget.load(Ordering::Acquire),
359            4096,
360            true,
361        );
362    };
363    ImageCacheHandle::new_managed(request, bytes, stats, trim, set_budget, reachability)
364}
365
366#[cfg(any(test, feature = "backend-winit"))]
367fn request_async_image(
368    state: Arc<Mutex<AsyncImageState>>,
369    loader: RemoteImageLoaderHandle,
370    wake: Arc<dyn Fn() + Send + Sync>,
371    request: ImageRequest,
372    budget_bytes: Arc<AtomicUsize>,
373    governor: crate::memory::MemoryGovernor,
374) -> ImageStatus {
375    let key = request.cache_key();
376    let epoch = {
377        let mut state = state.lock().expect("async image cache poisoned");
378        state.generation = state.generation.wrapping_add(1);
379        let generation = state.generation;
380        if let Some(entry) = state.entries.get_mut(&key) {
381            if entry.status == ImageStatus::Failed
382                && entry
383                    .retry_at
384                    .is_some_and(|retry_at| Instant::now() >= retry_at)
385            {
386                state.entries.remove(&key);
387            } else {
388                entry.used = generation;
389                let status = entry.status;
390                let _ = entry;
391                state.hits = state.hits.saturating_add(1);
392                return status;
393            }
394        }
395        state.misses = state.misses.saturating_add(1);
396        let epoch = state.epoch;
397        state.entries.insert(
398            key.clone(),
399            AsyncImageEntry {
400                status: ImageStatus::Loading,
401                bytes: None,
402                resident_bytes: 0,
403                used: generation,
404                retry_at: None,
405                policy: request.cache_policy_value(governor.options().default_image_cache_policy),
406                priority: request.priority_value(),
407                reachable: true,
408            },
409        );
410        epoch
411    };
412    let Some(task_reservation) = governor.try_reserve_task(MAX_ENCODED_RESOURCE_BYTES) else {
413        finish_async_image(
414            &state,
415            &key,
416            epoch,
417            Err(AssetError::Unsupported(
418                "image load deferred by memory pressure".to_owned(),
419            )),
420            budget_bytes.load(Ordering::Acquire),
421        );
422        return ImageStatus::Failed;
423    };
424    let failure_state = Arc::clone(&state);
425    let failure_key = key.clone();
426    let worker_budget = Arc::clone(&budget_bytes);
427    if std::thread::Builder::new()
428        .name("lgui-image-loader".to_owned())
429        .spawn(move || {
430            let _task_reservation = task_reservation;
431            let result = match request.source() {
432                ImageSource::File(path) => fs::read(path)
433                    .map(Arc::<[u8]>::from)
434                    .map_err(|error| AssetError::NotFound(error.to_string())),
435                ImageSource::Url(url) => load_url_image(&loader, &governor, &request, url),
436                ImageSource::Static(_) | ImageSource::Bytes { .. } => unreachable!(),
437            };
438            finish_async_image(
439                &state,
440                &key,
441                epoch,
442                result,
443                worker_budget.load(Ordering::Acquire),
444            );
445            wake();
446        })
447        .is_err()
448    {
449        finish_async_image(
450            &failure_state,
451            &failure_key,
452            epoch,
453            Err(AssetError::Unsupported(
454                "could not start image loading thread".to_owned(),
455            )),
456            budget_bytes.load(Ordering::Acquire),
457        );
458    }
459    ImageStatus::Loading
460}
461
462#[cfg(any(test, feature = "backend-winit"))]
463fn finish_async_image(
464    state: &Mutex<AsyncImageState>,
465    key: &str,
466    epoch: u64,
467    result: Result<AssetBytes, AssetError>,
468    budget_bytes: usize,
469) {
470    let mut state = state.lock().expect("async image cache poisoned");
471    if state.epoch != epoch {
472        return;
473    }
474    let (status, bytes, resident_bytes, retry_at) = match result {
475        Ok(bytes) => (ImageStatus::Ready, Some(bytes.clone()), bytes.len(), None),
476        Err(_) => (
477            ImageStatus::Failed,
478            None,
479            0,
480            Some(Instant::now() + Duration::from_secs(5)),
481        ),
482    };
483    let used = state.generation;
484    let (policy, priority, reachable) = state.entries.get(key).map_or(
485        (
486            ImageCachePolicy::NoStore,
487            crate::memory::CachePriority::Normal,
488            true,
489        ),
490        |entry| (entry.policy, entry.priority, entry.reachable),
491    );
492    if let Some(previous) = state.entries.remove(key) {
493        state.resident_bytes = state.resident_bytes.saturating_sub(previous.resident_bytes);
494    }
495    state.resident_bytes = state.resident_bytes.saturating_add(resident_bytes);
496    state.entries.insert(
497        key.to_owned(),
498        AsyncImageEntry {
499            status,
500            bytes,
501            resident_bytes,
502            used,
503            retry_at,
504            policy,
505            priority,
506            reachable,
507        },
508    );
509    evict_async_images(&mut state, budget_bytes, 4096, true);
510}
511
512#[doc(hidden)]
513#[cfg(any(test, feature = "backend-winit"))]
514pub fn load_url_image(
515    loader: &RemoteImageLoaderHandle,
516    governor: &crate::memory::MemoryGovernor,
517    request: &ImageRequest,
518    url: &str,
519) -> Result<AssetBytes, AssetError> {
520    #[cfg(not(feature = "persistent-cache"))]
521    let _ = request;
522    #[cfg(not(feature = "persistent-cache"))]
523    let _ = governor;
524    let limit = MAX_ENCODED_RESOURCE_BYTES;
525    #[cfg(feature = "persistent-cache")]
526    if let ImageCachePolicy::Persistent {
527        max_age,
528        revalidate,
529    } = request.cache_policy_value(governor.options().default_image_cache_policy)
530    {
531        if let Some(store) = governor.persistent_cache() {
532            let key = crate::memory::PersistentCacheKey::new(
533                request.namespace_value(),
534                url,
535                request.version_value(),
536            );
537            let stale = store.get_stale(&key).ok().flatten();
538            if let Some(entry) = stale.as_ref().filter(|entry| !entry.is_expired()) {
539                return validate_encoded_bytes(Arc::from(entry.bytes.clone()), limit);
540            }
541            let response = loader.load_response(
542                url,
543                revalidate
544                    .then(|| stale.as_ref()?.etag.as_deref())
545                    .flatten(),
546                revalidate
547                    .then(|| stale.as_ref()?.last_modified.as_deref())
548                    .flatten(),
549            );
550            let response = match response {
551                Ok(response) => response,
552                Err(error) => {
553                    if let Some(entry) = stale {
554                        return validate_encoded_bytes(Arc::from(entry.bytes), limit);
555                    }
556                    return Err(error);
557                }
558            };
559            let bytes = if response.not_modified {
560                stale
561                    .as_ref()
562                    .map(|entry| Arc::<[u8]>::from(entry.bytes.clone()))
563                    .ok_or_else(|| {
564                        AssetError::InvalidData(
565                            "image server returned 304 without a cached response".to_owned(),
566                        )
567                    })?
568            } else {
569                response.bytes.clone().ok_or_else(|| {
570                    AssetError::InvalidData("image response had no body".to_owned())
571                })?
572            };
573            let bytes = validate_encoded_bytes(bytes, limit)?;
574            if !request.is_sensitive()
575                && response
576                    .mime
577                    .as_deref()
578                    .is_none_or(|mime| mime.starts_with("image/"))
579            {
580                let mut entry = crate::memory::PersistentEntry::new(key, bytes.to_vec());
581                entry.mime = response
582                    .mime
583                    .or_else(|| stale.as_ref().and_then(|entry| entry.mime.clone()));
584                entry.etag = response
585                    .etag
586                    .or_else(|| stale.as_ref().and_then(|entry| entry.etag.clone()));
587                entry.last_modified = response
588                    .last_modified
589                    .or_else(|| stale.as_ref().and_then(|entry| entry.last_modified.clone()));
590                entry.expires_unix_seconds = Some(
591                    SystemTime::now()
592                        .duration_since(UNIX_EPOCH)
593                        .unwrap_or_default()
594                        .as_secs()
595                        .saturating_add(max_age.as_secs()),
596                );
597                let _ = store.put(entry);
598                let _ = store.trim_to(governor.options().budget.persistent_bytes);
599            }
600            return Ok(bytes);
601        }
602    }
603    validate_encoded_bytes(loader.load(url)?, limit)
604}
605
606#[doc(hidden)]
607#[cfg(any(test, feature = "backend-winit"))]
608pub fn validate_encoded_bytes(bytes: AssetBytes, limit: usize) -> Result<AssetBytes, AssetError> {
609    if bytes.len() > limit {
610        return Err(AssetError::InvalidData(format!(
611            "encoded image exceeds the {} byte limit",
612            limit
613        )));
614    }
615    Ok(bytes)
616}
617
618#[doc(hidden)]
619#[cfg(any(test, feature = "backend-winit"))]
620pub fn prepare_image_bytes(
621    bytes: AssetBytes,
622    request: &ImageRequest,
623) -> Result<AssetBytes, AssetError> {
624    let bytes = validate_encoded_bytes(bytes, MAX_ENCODED_RESOURCE_BYTES)?;
625    let reader = image::ImageReader::new(Cursor::new(bytes.as_ref()))
626        .with_guessed_format()
627        .map_err(|error| AssetError::InvalidData(error.to_string()))?;
628    let (width, height) = reader
629        .into_dimensions()
630        .map_err(|error| AssetError::InvalidData(error.to_string()))?;
631    validate_decoded_dimensions(width, height, MAX_DECODED_RESOURCE_BYTES)?;
632
633    let ImageDecodePolicy::FitTarget(target) = request.decode_policy_value() else {
634        return Ok(bytes);
635    };
636    let target_width = u32::try_from(target.width).ok().filter(|value| *value > 0);
637    let target_height = u32::try_from(target.height).ok().filter(|value| *value > 0);
638    let (Some(target_width), Some(target_height)) = (target_width, target_height) else {
639        return Err(AssetError::InvalidData(
640            "image decode target must be positive".to_owned(),
641        ));
642    };
643    validate_decoded_dimensions(
644        target_width,
645        target_height,
646        MAX_DECODED_RESOURCE_BYTES,
647    )?;
648    if width <= target_width && height <= target_height {
649        return Ok(bytes);
650    }
651
652    let decoded = image::load_from_memory(bytes.as_ref())
653        .map_err(|error| AssetError::InvalidData(error.to_string()))?;
654    let resized = decoded.thumbnail(target_width, target_height);
655    let mut encoded = Cursor::new(Vec::new());
656    resized
657        .write_to(&mut encoded, image::ImageFormat::Png)
658        .map_err(|error| AssetError::InvalidData(error.to_string()))?;
659    validate_encoded_bytes(
660        Arc::from(encoded.into_inner()),
661        MAX_ENCODED_RESOURCE_BYTES,
662    )
663}
664
665#[cfg(any(test, feature = "backend-winit"))]
666fn validate_decoded_dimensions(
667    width: u32,
668    height: u32,
669    max_bytes: usize,
670) -> Result<(), AssetError> {
671    let bytes = (width as usize)
672        .checked_mul(height as usize)
673        .and_then(|pixels| pixels.checked_mul(4))
674        .ok_or_else(|| AssetError::InvalidData("decoded image dimensions overflow".to_owned()))?;
675    if width == 0 || height == 0 || bytes > max_bytes {
676        return Err(AssetError::InvalidData(format!(
677            "decoded image {}x{} exceeds the {} byte limit",
678            width, height, max_bytes
679        )));
680    }
681    Ok(())
682}
683
684#[cfg(any(test, feature = "backend-winit"))]
685fn evict_async_images(
686    state: &mut AsyncImageState,
687    budget_bytes: usize,
688    max_entries: usize,
689    preserve_reachable: bool,
690) {
691    while state.resident_bytes > budget_bytes || state.entries.len() > max_entries {
692        let Some(evict) = state
693            .entries
694            .iter()
695            .filter(|(_, entry)| {
696                entry.status != ImageStatus::Loading && (!preserve_reachable || !entry.reachable)
697            })
698            .min_by_key(|(_, entry)| (entry.reachable, entry.priority, entry.used))
699            .map(|(key, _)| key.clone())
700        else {
701            break;
702        };
703        if let Some(entry) = state.entries.remove(&evict) {
704            state.resident_bytes = state.resident_bytes.saturating_sub(entry.resident_bytes);
705            state.evictions = state.evictions.saturating_add(1);
706        }
707    }
708}
709
710#[cfg(any(test, feature = "backend-winit"))]
711fn evict_unreachable_visible_images(state: &mut AsyncImageState) {
712    let evict = state
713        .entries
714        .iter()
715        .filter_map(|(key, entry)| {
716            (!entry.reachable
717                && entry.status != ImageStatus::Loading
718                && matches!(
719                    entry.policy,
720                    ImageCachePolicy::NoStore | ImageCachePolicy::WhileVisible
721                ))
722            .then(|| key.clone())
723        })
724        .collect::<Vec<_>>();
725    for key in evict {
726        if let Some(entry) = state.entries.remove(&key) {
727            state.resident_bytes = state.resident_bytes.saturating_sub(entry.resident_bytes);
728            state.evictions = state.evictions.saturating_add(1);
729        }
730    }
731}