Use the origin of the actual image response when determining if a canvas is origin clean.

components/net/image_cache.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use immeta::load_from_buf;
-use net_traits::{FetchResponseMsg, NetworkError};
+use net_traits::{FetchMetadata, FetchResponseMsg, NetworkError};
 use net_traits::image::base::{Image, ImageMetadata, PixelFormat, load_from_memory};
 use net_traits::image_cache::{CanRequestImages, ImageCache, ImageResponder};
 use net_traits::image_cache::{ImageOrMetadataAvailable, ImageResponse, ImageState};
@@ -15,6 +15,7 @@ use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::fs::File;
 use std::io::{self, Read};
 use std::mem;
+use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 use std::thread;
 use webrender_traits;
@@ -51,10 +52,8 @@ fn decode_bytes_sync(key: LoadKey, bytes: &[u8]) -> DecoderMsg {
     }
 }
 
-fn get_placeholder_image(webrender_api: &webrender_traits::RenderApi) -> io::Result<Arc<Image>> {
-    let mut placeholder_path = try!(resources_dir_path());
-    placeholder_path.push("rippy.png");
-    let mut file = try!(File::open(&placeholder_path));
+fn get_placeholder_image(webrender_api: &webrender_traits::RenderApi, path: &PathBuf) -> io::Result<Arc<Image>> {
+    let mut file = try!(File::open(path));
     let mut image_data = vec![];
     try!(file.read_to_end(&mut image_data));
     let mut image = load_from_memory(&image_data).unwrap();
@@ -289,6 +288,8 @@ struct PendingLoad {
     // The url being loaded. Do not forget that this may be several Mb
     // if we are loading a data: url.
     url: ServoUrl,
+
+    final_url: Option<ServoUrl>,
 }
 
 impl PendingLoad {
@@ -299,6 +300,7 @@ impl PendingLoad {
             result: None,
             listeners: vec!(),
             url: url,
+            final_url: None,
         }
     }
 
@@ -320,6 +322,9 @@ struct ImageCacheStore {
     // The placeholder image used when an image fails to load
     placeholder_image: Option<Arc<Image>>,
 
+    // The URL used for the placeholder image
+    placeholder_url: ServoUrl,
+
     // Webrender API instance.
     webrender_api: webrender_traits::RenderApi,
 }
@@ -356,9 +361,11 @@ impl ImageCacheStore {
             LoadResult::PlaceholderLoaded(..) | LoadResult::None => {}
         }
 
+        let url = pending_load.final_url.clone();
         let image_response = match load_result {
-            LoadResult::Loaded(image) => ImageResponse::Loaded(Arc::new(image)),
-            LoadResult::PlaceholderLoaded(image) => ImageResponse::PlaceholderLoaded(image),
+            LoadResult::Loaded(image) => ImageResponse::Loaded(Arc::new(image), url.unwrap()),
+            LoadResult::PlaceholderLoaded(image) =>
+                ImageResponse::PlaceholderLoaded(image, self.placeholder_url.clone()),
             LoadResult::None => ImageResponse::None,
         };
 
@@ -378,11 +385,11 @@ impl ImageCacheStore {
                                         -> Option<Result<ImageOrMetadataAvailable, ImageState>> {
         self.completed_loads.get(url).map(|completed_load| {
             match (&completed_load.image_response, placeholder) {
-                (&ImageResponse::Loaded(ref image), _) |
-                (&ImageResponse::PlaceholderLoaded(ref image), UsePlaceholder::Yes) => {
-                    Ok(ImageOrMetadataAvailable::ImageAvailable(image.clone()))
+                (&ImageResponse::Loaded(ref image, ref url), _) |
+                (&ImageResponse::PlaceholderLoaded(ref image, ref url), UsePlaceholder::Yes) => {
+                    Ok(ImageOrMetadataAvailable::ImageAvailable(image.clone(), url.clone()))
                 }
-                (&ImageResponse::PlaceholderLoaded(_), UsePlaceholder::No) |
+                (&ImageResponse::PlaceholderLoaded(_, _), UsePlaceholder::No) |
                 (&ImageResponse::None, _) |
                 (&ImageResponse::MetadataLoaded(_), _) => {
                     Err(ImageState::LoadError)
@@ -409,11 +416,16 @@ pub struct ImageCacheImpl {
 impl ImageCache for ImageCacheImpl {
     fn new(webrender_api: webrender_traits::RenderApi) -> ImageCacheImpl {
         debug!("New image cache");
+
+        let mut placeholder_path = resources_dir_path().expect("Can't figure out resources path.");
+        placeholder_path.push("rippy.png");
+
         ImageCacheImpl {
             store: Arc::new(Mutex::new(ImageCacheStore {
                 pending_loads: AllPendingLoads::new(),
                 completed_loads: HashMap::new(),
-                placeholder_image: get_placeholder_image(&webrender_api).ok(),
+                placeholder_image: get_placeholder_image(&webrender_api, &placeholder_path).ok(),
+                placeholder_url: ServoUrl::from_file_path(&placeholder_path).unwrap(),
                 webrender_api: webrender_api,
             }))
         }
@@ -496,7 +508,21 @@ impl ImageCache for ImageCacheImpl {
         match (action, id) {
             (FetchResponseMsg::ProcessRequestBody, _) |
             (FetchResponseMsg::ProcessRequestEOF, _) => return,
-            (FetchResponseMsg::ProcessResponse(_response), _) => {}
+            (FetchResponseMsg::ProcessResponse(response), _) => {
+                let mut store = self.store.lock().unwrap();
+                let pending_load = store.pending_loads.get_by_key_mut(&id).unwrap();
+                let metadata = match response {
+                    Ok(meta) => {
+                        Some(match meta {
+                            FetchMetadata::Unfiltered(m) => m,
+                            FetchMetadata::Filtered { unsafe_, .. } => unsafe_,
+                        })
+                    },
+                    Err(_) => None,
+                };
+                let final_url = metadata.as_ref().map(|m| m.final_url.clone());
+                pending_load.final_url = final_url;
+            }
             (FetchResponseMsg::ProcessResponseChunk(data), _) => {
                 debug!("Got some data for {:?}", id);
                 let mut store = self.store.lock().unwrap();
@@ -509,7 +535,8 @@ impl ImageCache for ImageCacheImpl {
                         let img_metadata = ImageMetadata { width: dimensions.width,
                                                            height: dimensions.height };
                         for listener in &pending_load.listeners {
-                            listener.respond(ImageResponse::MetadataLoaded(img_metadata.clone()));
+                            listener.respond(
+                                ImageResponse::MetadataLoaded(img_metadata.clone()));
                         }
                         pending_load.metadata = Some(img_metadata);
                     }