Copy image-fetching code from Layout 2013

components/layout_2020/Cargo.toml

@@ -18,12 +18,14 @@ atomic_refcell = "0.1"
 cssparser = "0.27"
 embedder_traits = {path = "../embedder_traits"}
 euclid = "0.20"
+fnv = "1.0"
 gfx = {path = "../gfx"}
 gfx_traits = {path = "../gfx_traits"}
 ipc-channel = "0.12"
 libc = "0.2"
 msg = {path = "../msg"}
 net_traits = {path = "../net_traits"}
+parking_lot = "0.9"
 range = {path = "../range"}
 rayon = "1"
 rayon_croissant = "0.2.0"
@@ -32,6 +34,7 @@ script_traits = {path = "../script_traits"}
 serde = "1.0"
 servo_arc = { path = "../servo_arc" }
 servo_geometry = {path = "../geometry"}
+servo_url = {path = "../url"}
 style = {path = "../style", features = ["servo", "servo-layout-2020"]}
 style_traits = {path = "../style_traits"}
 unicode-script = {version = "0.3", features = ["harfbuzz"]}

components/layout_2020/context.rs

@@ -2,18 +2,51 @@
  * 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 crate::display_list::WebRenderImageInfo;
+use fnv::FnvHashMap;
 use gfx::font_cache_thread::FontCacheThread;
 use gfx::font_context::FontContext;
 use msg::constellation_msg::PipelineId;
+use net_traits::image_cache::{CanRequestImages, ImageCache, ImageState};
+use net_traits::image_cache::{ImageOrMetadataAvailable, UsePlaceholder};
+use parking_lot::RwLock;
+use script_layout_interface::{PendingImage, PendingImageState};
+use servo_url::{ImmutableOrigin, ServoUrl};
 use std::cell::RefCell;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 use style::context::SharedStyleContext;
+use style::dom::OpaqueNode;
 
 pub struct LayoutContext<'a> {
     pub id: PipelineId,
     pub use_rayon: bool,
+    pub origin: ImmutableOrigin,
+
+    /// Bits shared by the layout and style system.
     pub style_context: SharedStyleContext<'a>,
+
+    /// Interface to the font cache thread.
     pub font_cache_thread: Mutex<FontCacheThread>,
+
+    /// Reference to the script thread image cache.
+    pub image_cache: Arc<dyn ImageCache>,
+
+    /// A list of in-progress image loads to be shared with the script thread.
+    /// A None value means that this layout was not initiated by the script thread.
+    pub pending_images: Option<Mutex<Vec<PendingImage>>>,
+
+    pub webrender_image_cache:
+        Arc<RwLock<FnvHashMap<(ServoUrl, UsePlaceholder), WebRenderImageInfo>>>,
+}
+
+impl<'a> Drop for LayoutContext<'a> {
+    fn drop(&mut self) {
+        if !std::thread::panicking() {
+            if let Some(ref pending_images) = self.pending_images {
+                assert!(pending_images.lock().unwrap().is_empty());
+            }
+        }
+    }
 }
 
 impl<'a> LayoutContext<'a> {
@@ -21,6 +54,100 @@ impl<'a> LayoutContext<'a> {
     pub fn shared_context(&self) -> &SharedStyleContext {
         &self.style_context
     }
+
+    pub fn get_or_request_image_or_meta(
+        &self,
+        node: OpaqueNode,
+        url: ServoUrl,
+        use_placeholder: UsePlaceholder,
+    ) -> Option<ImageOrMetadataAvailable> {
+        //XXXjdm For cases where we do not request an image, we still need to
+        //       ensure the node gets another script-initiated reflow or it
+        //       won't be requested at all.
+        let can_request = if self.pending_images.is_some() {
+            CanRequestImages::Yes
+        } else {
+            CanRequestImages::No
+        };
+
+        // See if the image is already available
+        let result = self.image_cache.find_image_or_metadata(
+            url.clone(),
+            self.origin.clone(),
+            None,
+            use_placeholder,
+            can_request,
+        );
+        match result {
+            Ok(image_or_metadata) => Some(image_or_metadata),
+            // Image failed to load, so just return nothing
+            Err(ImageState::LoadError) => None,
+            // Not yet requested - request image or metadata from the cache
+            Err(ImageState::NotRequested(id)) => {
+                let image = PendingImage {
+                    state: PendingImageState::Unrequested(url),
+                    node: node.into(),
+                    id: id,
+                };
+                self.pending_images
+                    .as_ref()
+                    .unwrap()
+                    .lock()
+                    .unwrap()
+                    .push(image);
+                None
+            },
+            // Image has been requested, is still pending. Return no image for this paint loop.
+            // When the image loads it will trigger a reflow and/or repaint.
+            Err(ImageState::Pending(id)) => {
+                //XXXjdm if self.pending_images is not available, we should make sure that
+                //       this node gets marked dirty again so it gets a script-initiated
+                //       reflow that deals with this properly.
+                if let Some(ref pending_images) = self.pending_images {
+                    let image = PendingImage {
+                        state: PendingImageState::PendingResponse,
+                        node: node.into(),
+                        id: id,
+                    };
+                    pending_images.lock().unwrap().push(image);
+                }
+                None
+            },
+        }
+    }
+
+    pub fn get_webrender_image_for_url(
+        &self,
+        node: OpaqueNode,
+        url: ServoUrl,
+        use_placeholder: UsePlaceholder,
+    ) -> Option<WebRenderImageInfo> {
+        if let Some(existing_webrender_image) = self
+            .webrender_image_cache
+            .read()
+            .get(&(url.clone(), use_placeholder))
+        {
+            return Some((*existing_webrender_image).clone());
+        }
+
+        match self.get_or_request_image_or_meta(node, url.clone(), use_placeholder) {
+            Some(ImageOrMetadataAvailable::ImageAvailable(image, _)) => {
+                let image_info = WebRenderImageInfo {
+                    width: image.width,
+                    height: image.height,
+                    key: image.id,
+                };
+                if image_info.key.is_none() {
+                    Some(image_info)
+                } else {
+                    let mut webrender_image_cache = self.webrender_image_cache.write();
+                    webrender_image_cache.insert((url, use_placeholder), image_info);
+                    Some(image_info)
+                }
+            },
+            None | Some(ImageOrMetadataAvailable::MetadataAvailable(_)) => None,
+        }
+    }
 }
 
 pub(crate) type LayoutFontContext = FontContext<FontCacheThread>;

components/layout_2020/display_list.rs

@@ -14,6 +14,13 @@ use style::values::computed::{BorderStyle, Length, LengthPercentage};
 use style::values::specified::ui::CursorKind;
 use webrender_api::{self as wr, units};
 
+#[derive(Clone, Copy)]
+pub struct WebRenderImageInfo {
+    pub width: u32,
+    pub height: u32,
+    pub key: Option<wr::ImageKey>,
+}
+
 // `webrender_api::display_item::ItemTag` is private
 type ItemTag = (u64, u16);
 type HitInfo = Option<ItemTag>;