working cached impl

mukilan · mukilan · commit dbe17a6f4b14 · 2025-07-18T17:05:24.000+05:30
diff --git a/components/layout/context.rs b/components/layout/context.rs
@@ -4,8 +4,10 @@
 
 use std::sync::Arc;
 
+use embedder_traits::UntrustedNodeAddress;
 use euclid::Size2D;
 use fnv::FnvHashMap;
+use style::dom::TNode;
 use fonts::FontContext;
 use fxhash::FxHashMap;
 use layout_api::{
@@ -86,6 +88,7 @@ pub(crate) struct ImageResolver {
     /// size determined by layout. This will be shared with the script thread.
     pub pending_rasterization_images: Mutex<Vec<PendingRasterizationImage>>,
 
+    pub pending_svg_element_for_serialization: Mutex<Vec<UntrustedNodeAddress>>,
     /// A shared reference to script's map of DOM nodes with animated images. This is used
     /// to manage image animations in script and inform the script about newly animating
     /// nodes.
@@ -104,7 +107,8 @@ impl Drop for ImageResolver {
     fn drop(&mut self) {
         if !std::thread::panicking() {
             assert!(self.pending_images.lock().is_empty());
-            assert!(self.pending_rasterization_images.lock().is_empty());
+            assert!(self.pending_images.lock().is_empty());
+            assert!(self.pending_svg_element_for_serialization.lock().is_empty());
         }
     }
 }
@@ -174,7 +178,7 @@ impl ImageResolver {
         }
     }
 
-    fn get_cached_image_for_url(
+    pub(crate) fn get_cached_image_for_url(
         &self,
         node: OpaqueNode,
         url: ServoUrl,
@@ -234,6 +238,15 @@ impl ImageResolver {
         result
     }
 
+    pub(crate) fn queue_svg_element_for_serialization(
+        &self,
+        element: script::layout_dom::ServoLayoutNode<'_>,
+    ) {
+        self.pending_svg_element_for_serialization
+            .lock()
+            .push(element.opaque().into())
+    }
+
     pub(crate) fn resolve_image<'a>(
         &self,
         node: Option<OpaqueNode>,
diff --git a/components/layout/dom.rs b/components/layout/dom.rs
@@ -7,13 +7,14 @@ use std::marker::PhantomData;
 
 use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
 use base::id::{BrowsingContextId, PipelineId};
-use html5ever::{local_name, ns};
 use html5ever::serialize::Serializer;
+use html5ever::{local_name, ns};
 use layout_api::wrapper_traits::{
     LayoutDataTrait, LayoutNode, ThreadSafeLayoutElement, ThreadSafeLayoutNode,
 };
 use layout_api::{
-    GenericLayoutDataTrait, LayoutDamage, LayoutElementType, LayoutNodeType as ScriptLayoutNodeType, SVGSVGData,
+    GenericLayoutDataTrait, LayoutDamage, LayoutElementType,
+    LayoutNodeType as ScriptLayoutNodeType, SVGSVGData,
 };
 use malloc_size_of_derive::MallocSizeOf;
 use net_traits::image_cache::Image;
@@ -279,8 +280,8 @@ impl<'dom> NodeExt<'dom> for ServoLayoutNode<'dom> {
         let node = self.to_threadsafe();
         let svg_data = node.svg_data()?;
         let width = svg_data.width as f64;
-        let height= svg_data.height as f64;
-        println!("SVG Source {:?}", svg_data.source);
+        let height = svg_data.height as f64;
+        //println!("SVG Source {:?}", svg_data.source);
         Some((svg_data, PhysicalSize::new(width, height)))
     }
 
diff --git a/components/layout/layout_impl.rs b/components/layout/layout_impl.rs
@@ -660,6 +660,7 @@ impl LayoutThread {
             resolved_images_cache: self.resolved_images_cache.clone(),
             pending_images: Mutex::default(),
             pending_rasterization_images: Mutex::default(),
+            pending_svg_element_for_serialization: Mutex::default(),
             node_to_animating_image_map: reflow_request.node_to_animating_image_map.clone(),
             animation_timeline_value: reflow_request.animation_timeline_value,
         });
@@ -682,11 +683,14 @@ impl LayoutThread {
         let pending_images = std::mem::take(&mut *image_resolver.pending_images.lock());
         let pending_rasterization_images =
             std::mem::take(&mut *image_resolver.pending_rasterization_images.lock());
+        let pending_svg_element_for_serialization =
+            std::mem::take(&mut *image_resolver.pending_svg_element_for_serialization.lock());
 
         Some(ReflowResult {
             built_display_list,
             pending_images,
             pending_rasterization_images,
+            pending_svg_element_for_serialization,
             iframe_sizes,
         })
     }
diff --git a/components/layout/replaced.rs b/components/layout/replaced.rs
@@ -12,6 +12,7 @@ use malloc_size_of_derive::MallocSizeOf;
 use net_traits::image_cache::{Image, ImageOrMetadataAvailable, UsePlaceholder};
 use script::layout_dom::ServoLayoutNode;
 use servo_arc::Arc as ServoArc;
+use servo_url::ServoUrl;
 use style::Zero;
 use style::computed_values::object_fit::T as ObjectFit;
 use style::dom::TNode;
@@ -115,7 +116,7 @@ pub(crate) enum ReplacedContentKind {
     IFrame(IFrameInfo),
     Canvas(CanvasInfo),
     Video(Option<VideoInfo>),
-    SVGElement,
+    SVGElement(Image),
 }
 
 impl ReplacedContents {
@@ -154,8 +155,20 @@ impl ReplacedContents {
                     ReplacedContentKind::Video(image_key.map(|key| VideoInfo { image_key: key })),
                     natural_size_in_dots,
                 )
-            } else if let Some(_) = element.as_svg() {
-                (ReplacedContentKind::SVGElement, None)
+            } else if let Some((svg_data, _)) = element.as_svg() {
+                let Some(svg_source) = svg_data.source else {
+                    context.image_resolver.queue_svg_element_for_serialization(element);
+                    return None;
+                };
+                let result = context
+                    .image_resolver
+                    .get_cached_image_for_url(element.opaque(), svg_source, UsePlaceholder::Yes)
+                    .ok()?;
+                let size = result.metadata();
+                (
+                    ReplacedContentKind::SVGElement(result),
+                    Some(PhysicalSize::new(size.width as f64, size.height as f64)),
+                )
             } else {
                 return None;
             }
@@ -393,10 +406,36 @@ impl ReplacedContents {
                     image_key: Some(image_key),
                 }))]
             },
-            ReplacedContentKind::SVGElement => {
+            ReplacedContentKind::SVGElement(image) => {
                 println!("ReplacedContentKind::SVG Encountered");
-                vec![]
-            }
+                let id = match image {
+                    Image::Raster(raster_image) => {
+                        unreachable!("SVG Element can't contain a raster")
+                    },
+                    Image::Vector(vector_image) => {
+                        let scale = layout_context.style_context.device_pixel_ratio();
+                        let width = object_fit_size.width.scale_by(scale.0).to_px();
+                        let height = object_fit_size.height.scale_by(scale.0).to_px();
+                        let size = Size2D::new(width, height);
+                        let tag = self.base_fragment_info.tag.unwrap();
+                        layout_context
+                            .image_resolver
+                            .rasterize_vector_image(vector_image.id, size, tag.node)
+                            .and_then(|i| i.id)
+                    },
+                };
+                id.map(|image_key| {
+                    Fragment::Image(ArcRefCell::new(ImageFragment {
+                        base: self.base_fragment_info.into(),
+                        style: style.clone(),
+                        rect,
+                        clip,
+                        image_key: Some(image_key),
+                    }))
+                })
+                .into_iter()
+                .collect()
+            },
         }
     }
 
diff --git a/components/script/dom/svgsvgelement.rs b/components/script/dom/svgsvgelement.rs
@@ -2,11 +2,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+use std::cell::RefCell;
+
+use base64::Engine as _;
 use dom_struct::dom_struct;
 use html5ever::{LocalName, Prefix, local_name, ns};
 use js::rust::HandleObject;
 use layout_api::SVGSVGData;
+use servo_url::ServoUrl;
 use style::attr::AttrValue;
+use xml5ever::serialize::TraversalScope;
 
 use crate::dom::attr::Attr;
 use crate::dom::bindings::inheritance::Castable;
@@ -25,6 +30,8 @@ const DEFAULT_HEIGHT: u32 = 150;
 #[dom_struct]
 pub(crate) struct SVGSVGElement {
     svggraphicselement: SVGGraphicsElement,
+    #[no_trace]
+    cached_serialized_data: RefCell<Option<ServoUrl>>,
 }
 
 impl SVGSVGElement {
@@ -35,6 +42,7 @@ impl SVGSVGElement {
     ) -> SVGSVGElement {
         SVGSVGElement {
             svggraphicselement: SVGGraphicsElement::new_inherited(local_name, prefix, document),
+            cached_serialized_data: Default::default(),
         }
     }
 
@@ -53,6 +61,19 @@ impl SVGSVGElement {
             can_gc,
         )
     }
+
+    pub(crate) fn cache_serialized_data(&self) {
+        println!("XXX cache_serialized_data");
+        let source: String = self
+            .upcast::<Node>()
+            .xml_serialize(TraversalScope::IncludeNode)
+            .into();
+        let base64 = base64::engine::general_purpose::STANDARD.encode(source);
+        let source = format!("data:image/svg+xml;base64,{}", base64);
+        if let Ok(url) = ServoUrl::parse(&source) {
+            *self.cached_serialized_data.borrow_mut() = Some(url);
+        }
+    }
 }
 
 pub(crate) trait LayoutSVGSVGElementHelpers {
@@ -70,7 +91,7 @@ impl LayoutSVGSVGElementHelpers for LayoutDom<'_, SVGSVGElement> {
         SVGSVGData {
             width: width_attr.map_or(DEFAULT_WIDTH, |val| val.as_uint()),
             height: height_attr.map_or(DEFAULT_HEIGHT, |val| val.as_uint()),
-            source: self.upcast::<Element>().serialize_as_xml().into()
+            source: self.unsafe_get().cached_serialized_data.borrow().clone(),
         }
     }
 }
@@ -84,6 +105,7 @@ impl VirtualMethods for SVGSVGElement {
         self.super_type()
             .unwrap()
             .attribute_mutated(attr, mutation, can_gc);
+        *self.cached_serialized_data.borrow_mut() = None;
     }
 
     fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
@@ -96,4 +118,17 @@ impl VirtualMethods for SVGSVGElement {
                 .parse_plain_attribute(name, value),
         }
     }
+
+    // fn children_changed(&self, mutation: &super::node::ChildrenMutation) {
+    //     self.super_type()
+    //         .map(|parent| parent.children_changed(mutation));
+    //     println!("XXX children_changed");
+    //     let source: String = self
+    //         .upcast::<Node>()
+    //         .html_serialize(TraversalScope::IncludeNode, false, vec![], CanGc::note())
+    //         .into();
+    //     let base64 = base64::engine::general_purpose::STANDARD.encode(source);
+    //     let source = format!("data:image/svg+xml;base64,{}", base64);
+    //     *self.serialized_data_url.borrow_mut() = source;
+    // }
 }
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
@@ -32,9 +32,7 @@ use devtools_traits::{ScriptToDevtoolsControlMsg, TimelineMarker, TimelineMarker
 use dom_struct::dom_struct;
 use embedder_traits::user_content_manager::{UserContentManager, UserScript};
 use embedder_traits::{
-    AlertResponse, ConfirmResponse, EmbedderMsg, GamepadEvent, GamepadSupportedHapticEffects,
-    GamepadUpdateType, PromptResponse, SimpleDialog, Theme, ViewportDetails, WebDriverJSError,
-    WebDriverJSResult,
+    AlertResponse, ConfirmResponse, EmbedderMsg, GamepadEvent, GamepadSupportedHapticEffects, GamepadUpdateType, PromptResponse, SimpleDialog, Theme, UntrustedNodeAddress, ViewportDetails, WebDriverJSError, WebDriverJSResult
 };
 use euclid::default::{Point2D as UntypedPoint2D, Rect as UntypedRect, Size2D as UntypedSize2D};
 use euclid::{Point2D, Scale, Size2D, Vector2D};
@@ -92,6 +90,7 @@ use webrender_api::units::{DeviceIntSize, DevicePixel, LayoutPixel};
 
 use super::bindings::codegen::Bindings::MessagePortBinding::StructuredSerializeOptions;
 use super::bindings::trace::HashMapTracedValues;
+use super::types::SVGSVGElement;
 use crate::dom::bindings::cell::{DomRefCell, Ref};
 use crate::dom::bindings::codegen::Bindings::DocumentBinding::{
     DocumentMethods, DocumentReadyState, NamedPropertyValue,
@@ -2258,6 +2257,7 @@ impl Window {
         self.handle_pending_images_post_reflow(
             results.pending_images,
             results.pending_rasterization_images,
+            results.pending_svg_element_for_serialization
         );
         document
             .iframes_mut()
@@ -2989,6 +2989,7 @@ impl Window {
         &self,
         pending_images: Vec<PendingImage>,
         pending_rasterization_images: Vec<PendingRasterizationImage>,
+        pending_svg_element_for_serialization: Vec<UntrustedNodeAddress>,
     ) {
         let pipeline_id = self.pipeline_id();
         for image in pending_images {
@@ -3037,6 +3038,13 @@ impl Window {
                 nodes.push(Dom::from_ref(&*node));
             }
         }
+
+        for node in pending_svg_element_for_serialization.into_iter() {
+            let node = unsafe { from_untrusted_node_address(node) };
+            let svg = node.downcast::<SVGSVGElement>().unwrap();
+            svg.cache_serialized_data();
+            node.dirty(NodeDamage::Other);
+        }
     }
 }
 
diff --git a/components/shared/layout/lib.rs b/components/shared/layout/lib.rs
@@ -132,7 +132,7 @@ pub struct HTMLCanvasData {
 pub struct SVGSVGData {
     pub width: u32,
     pub height: u32,
-    pub source: String
+    pub source: Option<ServoUrl>
 }
 
 /// The address of a node known to be valid. These are sent from script to layout.
@@ -390,6 +390,7 @@ pub struct ReflowResult {
     pub pending_images: Vec<PendingImage>,
     /// The list of vector images that were encountered that still need to be rasterized.
     pub pending_rasterization_images: Vec<PendingRasterizationImage>,
+    pub pending_svg_element_for_serialization: Vec<UntrustedNodeAddress>,
     /// The list of iframes in this layout and their sizes, used in order
     /// to communicate them with the Constellation and also the `Window`
     /// element of their content pages.
