fix cache layer api

Author: mukilan

components/layout/context.rs

@@ -212,10 +212,7 @@ impl LayoutContext<'_> {
         size: DeviceIntSize,
         node: OpaqueNode,
     ) -> Option<RasterImage> {
-        let pipeline_id = self.id;
-        let result = self
-            .image_cache
-            .rasterize_vector_image(pipeline_id, image_id, size);
+        let result = self.image_cache.rasterize_vector_image(image_id, size);
         if result.is_none() {
             self.pending_rasterization_images
                 .lock()

components/net/image_cache.rs

@@ -53,7 +53,7 @@ const FALLBACK_RIPPY: &[u8] = include_bytes!("../../resources/rippy.png");
 
 fn parse_svg_document_in_memory(bytes: &[u8]) -> Result<usvg::Tree, &'static str> {
     let image_string_href_resolver = Box::new(move |_: &str, _: &usvg::Options| {
-        // Do not try to load `href` string in <image> as local file path.
+        // Do not try to load `href` in <image> as local file path.
         None
     });
 
@@ -326,7 +326,7 @@ impl LoadKeyGenerator {
 
 #[derive(Debug)]
 enum LoadResult {
-    LoadedPixelImage(RasterImage),
+    LoadedRasterImage(RasterImage),
     LoadedVectorImage(VectorImageData),
     PlaceholderLoaded(Arc<RasterImage>),
     None,
@@ -365,7 +365,7 @@ struct PendingLoad {
     /// The URL of the final response that contains a body.
     final_url: Option<ServoUrl>,
 
-    /// The value of the `Content-type` header from the HTTP request.
+    /// The value of the `Content-type` header in the HTTP response.
     content_type: Option<Mime>,
 }
 
@@ -396,10 +396,8 @@ impl PendingLoad {
 
 #[derive(MallocSizeOf)]
 struct RasterizationTask {
-    pipeline_id: PipelineId,
     image_id: PendingImageId,
-    size: DeviceIntSize,
-    listeners: Vec<IpcSender<ImageCacheMessage>>,
+    listeners: Vec<(PipelineId, IpcSender<ImageCacheMessage>)>,
     result: Option<RasterImage>,
 }
 
@@ -414,8 +412,14 @@ struct ImageCacheStore {
     // Images that have finished loading (successful or not)
     completed_loads: HashMap<ImageKey, CompletedLoad>,
 
+    // Vector (e.g. SVG) images that have been sucessfully loaded and parsed
+    // but are yet to be rasterized. Since the same SVG data can be used for
+    // rasterizing at different sizes, we use this hasmap to share the data.
     vector_images: HashMap<PendingImageId, VectorImageData>,
 
+    // Vector images for which rasterization at a particular size has started
+    // or completed. If completed, the `result` member of `RasterizationTask`
+    // contains the rasterized image.
     rasterized_vector_images: HashMap<(PendingImageId, DeviceIntSize), RasterizationTask>,
 
     // The placeholder image used when an image fails to load
@@ -440,7 +444,7 @@ impl ImageCacheStore {
         };
 
         match load_result {
-            LoadResult::LoadedPixelImage(ref mut image) => {
+            LoadResult::LoadedRasterImage(ref mut image) => {
                 set_webrender_image_key(&self.compositor_api, image)
             },
             LoadResult::LoadedVectorImage(ref vector_image) => {
@@ -451,7 +455,7 @@ impl ImageCacheStore {
 
         let url = pending_load.final_url.clone();
         let image_response = match load_result {
-            LoadResult::LoadedPixelImage(image) => {
+            LoadResult::LoadedRasterImage(image) => {
                 ImageResponse::Loaded(Image::Raster(Arc::new(image)), url.unwrap())
             },
             LoadResult::LoadedVectorImage(vector_image) => {
@@ -518,7 +522,7 @@ impl ImageCacheStore {
     fn handle_decoder(&mut self, msg: DecoderMsg) {
         let image = match msg.image {
             None => LoadResult::None,
-            Some(DecodedImage::Raster(image)) => LoadResult::LoadedPixelImage(image),
+            Some(DecodedImage::Raster(image)) => LoadResult::LoadedRasterImage(image),
             Some(DecodedImage::Vector(tree)) => LoadResult::LoadedVectorImage(tree),
         };
         self.complete_load(msg.key, image);
@@ -694,7 +698,7 @@ impl ImageCache for ImageCacheImpl {
                         size,
                     ));
                 } else {
-                    task.listeners.push(sender);
+                    task.listeners.push((pipeline_id, sender));
                 }
             },
             Vacant(_) => {
@@ -705,7 +709,6 @@ impl ImageCache for ImageCacheImpl {
 
     fn rasterize_vector_image(
         &self,
-        pipeline_id: PipelineId,
         image_id: PendingImageId,
         size: DeviceIntSize,
     ) -> Option<RasterImage> {
@@ -717,13 +720,10 @@ impl ImageCache for ImageCacheImpl {
 
         match store.rasterized_vector_images.entry((image_id, size)) {
             Occupied(occupied_entry) => {
-                let task = occupied_entry.get();
-                return task.result.clone();
+                return occupied_entry.get().result.clone();
             },
             Vacant(entry) => entry.insert(RasterizationTask {
-                pipeline_id,
                 image_id,
-                size,
                 listeners: vec![],
                 result: None,
             }),
@@ -741,7 +741,6 @@ impl ImageCache for ImageCacheImpl {
                 requested_size.width() as f32 / natural_size.width() as f32,
                 requested_size.height() as f32 / natural_size.height() as f32,
             );
-            println!("Rasterizing at {requested_size:?}");
             let mut pixmap =
                 tiny_skia::Pixmap::new(requested_size.width(), requested_size.height()).unwrap();
             resvg::render(&vector_image.svg_tree, transform, &mut pixmap.as_mut());
@@ -766,13 +765,12 @@ impl ImageCache for ImageCacheImpl {
             set_webrender_image_key(&store.compositor_api, &mut rasterized_image);
             if let Some(task) = store.rasterized_vector_images.get_mut(&(image_id, size)) {
                 task.result = Some(rasterized_image);
-                let response = ImageCacheMessage::VectorImageRasterizationCompleted(
-                    pipeline_id,
-                    image_id,
-                    size,
-                );
-                for listener in task.listeners.drain(..) {
-                    let _ = listener.send(response.clone());
+                for (pipeline_id, sender) in task.listeners.drain(..) {
+                    let _ = sender.send(ImageCacheMessage::VectorImageRasterizationCompleted(
+                        pipeline_id,
+                        image_id,
+                        size,
+                    ));
                 }
             }
         });

components/shared/net/image_cache.rs

@@ -189,7 +189,6 @@ pub trait ImageCache: Sync + Send {
 
     fn rasterize_vector_image(
         &self,
-        pipeline_id: PipelineId,
         image_id: VectorImageId,
         size: DeviceIntSize,
     ) -> Option<RasterImage>;