Refactor ImageCache::find_image_or_metadata API.

1 files changed, 28 insertions, 26 deletions

diff --git a/components/layout_2020/context.rs b/components/layout_2020/context.rs
index dc894e65766..117a02e0940 100644
--- a/components/layout_2020/context.rs
+++ b/components/layout_2020/context.rs
@@ -3,11 +3,12 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use crate::display_list::WebRenderImageInfo;
+use crate::opaque_node::OpaqueNodeMethods;
 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::{CanRequestImages, ImageCache, ImageCacheResult};
 use net_traits::image_cache::{ImageOrMetadataAvailable, UsePlaceholder};
 use parking_lot::RwLock;
 use script_layout_interface::{PendingImage, PendingImageState};
@@ -70,51 +71,52 @@ impl<'a> LayoutContext<'a> {
             CanRequestImages::No
         };
 
-        // See if the image is already available
-        let result = self.image_cache.find_image_or_metadata(
+        // Check for available image or start tracking.
+        let cache_result = self.image_cache.get_cached_image_status(
             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,
-                    origin: self.origin.clone(),
-                };
-                self.pending_images
-                    .as_ref()
-                    .unwrap()
-                    .lock()
-                    .unwrap()
-                    .push(image);
-                None
-            },
+
+        match cache_result {
+            ImageCacheResult::Available(img_or_meta) => Some(img_or_meta),
             // 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)) => {
+            ImageCacheResult::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,
+                        node: node.to_untrusted_node_address(),
+                        id,
                         origin: self.origin.clone(),
                     };
                     pending_images.lock().unwrap().push(image);
                 }
                 None
             },
+            // Not yet requested - request image or metadata from the cache
+            ImageCacheResult::ReadyForRequest(id) => {
+                let image = PendingImage {
+                    state: PendingImageState::Unrequested(url),
+                    node: node.to_untrusted_node_address(),
+                    id,
+                    origin: self.origin.clone(),
+                };
+                self.pending_images
+                    .as_ref()
+                    .unwrap()
+                    .lock()
+                    .unwrap()
+                    .push(image);
+                None
+            },
+            // Image failed to load, so just return nothing
+            ImageCacheResult::LoadError => None,
         }
     }