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#[cfg(any(test, feature = "backend-winit"))]
34const MAX_ENCODED_RESOURCE_BYTES: usize = 32 * 1024 * 1024;
35#[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
151pub 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}