mirror of
https://github.com/servo/servo.git
synced 2025-10-04 10:39:16 +01:00
d8aef7208e
* Simpler image cache API for clients to use. * Significantly fewer threads. * One thread for image cache task (multiplexes commands, decoder threads and async resource requests). * 4 threads for decoder worker tasks. * Removed ReflowEvent hacks in script and layout tasks. * Image elements pass a Trusted<T> to image cache, which is used to dirty nodes via script task. Previous use of Untrusted addresses was unsafe. * Image requests such as background-image on layout / paint threads trigger repaint only rather than full reflow. * Add reflow batching for when multiple images load quickly. * Reduces the number of paints loading wikipedia from ~95 to ~35. * Reasonably simple to add proper prefetch support in a follow up PR. * Async loaded images always construct Image fragments now, instead of generic. * Image fragments support the image not being present. * Simpler implementation of synchronous image loading for reftests. * Removed image holder. * image.onload support. * image NaturalWidth and NaturalHeight support. * Updated WPT expectations.
94 lines
3.1 KiB
Rust
94 lines
3.1 KiB
Rust
/* 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 http://mozilla.org/MPL/2.0/. */
|
|
|
|
use image::base::Image;
|
|
use url::Url;
|
|
use std::sync::Arc;
|
|
use std::sync::mpsc::{channel, Sender};
|
|
|
|
/// This is optionally passed to the image cache when requesting
|
|
/// and image, and returned to the specified event loop when the
|
|
/// image load completes. It is typically used to trigger a reflow
|
|
/// and/or repaint.
|
|
pub trait ImageResponder : Send {
|
|
fn respond(&self, Option<Arc<Image>>);
|
|
}
|
|
|
|
/// The current state of an image in the cache.
|
|
#[derive(PartialEq, Copy)]
|
|
pub enum ImageState {
|
|
Pending,
|
|
LoadError,
|
|
NotRequested,
|
|
}
|
|
|
|
/// Channel for sending commands to the image cache.
|
|
#[derive(Clone)]
|
|
pub struct ImageCacheChan(pub Sender<ImageCacheResult>);
|
|
|
|
/// The result of an image cache command that is returned to the
|
|
/// caller.
|
|
pub struct ImageCacheResult {
|
|
pub responder: Option<Box<ImageResponder>>,
|
|
pub image: Option<Arc<Image>>,
|
|
}
|
|
|
|
/// Commands that the image cache understands.
|
|
pub enum ImageCacheCommand {
|
|
/// Request an image asynchronously from the cache. Supply a channel
|
|
/// to receive the result, and optionally an image responder
|
|
/// that is passed to the result channel.
|
|
RequestImage(Url, ImageCacheChan, Option<Box<ImageResponder>>),
|
|
|
|
/// Synchronously check the state of an image in the cache.
|
|
/// TODO(gw): Profile this on some real world sites and see
|
|
/// if it's worth caching the results of this locally in each
|
|
/// layout / paint task.
|
|
GetImageIfAvailable(Url, Sender<Result<Arc<Image>, ImageState>>),
|
|
|
|
/// Clients must wait for a response before shutting down the ResourceTask
|
|
Exit(Sender<()>),
|
|
}
|
|
|
|
/// The client side of the image cache task. This can be safely cloned
|
|
/// and passed to different tasks.
|
|
#[derive(Clone)]
|
|
pub struct ImageCacheTask {
|
|
chan: Sender<ImageCacheCommand>,
|
|
}
|
|
|
|
/// The public API for the image cache task.
|
|
impl ImageCacheTask {
|
|
|
|
/// Construct a new image cache
|
|
pub fn new(chan: Sender<ImageCacheCommand>) -> ImageCacheTask {
|
|
ImageCacheTask {
|
|
chan: chan,
|
|
}
|
|
}
|
|
|
|
/// Asynchronously request and image. See ImageCacheCommand::RequestImage.
|
|
pub fn request_image(&self,
|
|
url: Url,
|
|
result_chan: ImageCacheChan,
|
|
responder: Option<Box<ImageResponder>>) {
|
|
let msg = ImageCacheCommand::RequestImage(url, result_chan, responder);
|
|
self.chan.send(msg).unwrap();
|
|
}
|
|
|
|
/// Get the current state of an image. See ImageCacheCommand::GetImageIfAvailable.
|
|
pub fn get_image_if_available(&self, url: Url) -> Result<Arc<Image>, ImageState> {
|
|
let (sender, receiver) = channel();
|
|
let msg = ImageCacheCommand::GetImageIfAvailable(url, sender);
|
|
self.chan.send(msg).unwrap();
|
|
receiver.recv().unwrap()
|
|
}
|
|
|
|
/// Shutdown the image cache task.
|
|
pub fn exit(&self) {
|
|
let (response_chan, response_port) = channel();
|
|
self.chan.send(ImageCacheCommand::Exit(response_chan)).unwrap();
|
|
response_port.recv().unwrap();
|
|
}
|
|
}
|