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

components/layout/context.rs

@@ -183,7 +183,7 @@ impl<'a> LayoutContext<'a> {
         }
 
         match self.get_or_request_image_or_meta(node, url.clone(), use_placeholder) {
-            Some(ImageOrMetadataAvailable::ImageAvailable(image)) => {
+            Some(ImageOrMetadataAvailable::ImageAvailable(image, _)) => {
                 let image_info = WebRenderImageInfo::from_image(&*image);
                 if image_info.key.is_none() {
                     Some(image_info)

components/layout/fragment.rs

@@ -378,7 +378,7 @@ impl ImageFragmentInfo {
         });
 
         let (image, metadata) = match image_or_metadata {
-            Some(ImageOrMetadataAvailable::ImageAvailable(i)) => {
+            Some(ImageOrMetadataAvailable::ImageAvailable(i, _)) => {
                 (Some(i.clone()), Some(ImageMetadata { height: i.height, width: i.width } ))
             }
             Some(ImageOrMetadataAvailable::MetadataAvailable(m)) => {

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>> {
+fn get_placeholder_image(webrender_api: &webrender_traits::RenderApi, path: &PathBuf) -> io::Result<Arc<Image>> {
-    let mut placeholder_path = try!(resources_dir_path());
+    let mut file = try!(File::open(path));
-    placeholder_path.push("rippy.png");
-    let mut file = try!(File::open(&placeholder_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::Loaded(image) => ImageResponse::Loaded(Arc::new(image), url.unwrap()),
-            LoadResult::PlaceholderLoaded(image) => ImageResponse::PlaceholderLoaded(image),
+            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::Loaded(ref image, ref url), _) |
-                (&ImageResponse::PlaceholderLoaded(ref image), UsePlaceholder::Yes) => {
+                (&ImageResponse::PlaceholderLoaded(ref image, ref url), UsePlaceholder::Yes) => {
-                    Ok(ImageOrMetadataAvailable::ImageAvailable(image.clone()))
+                    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);
                     }

components/net_traits/image_cache.rs

@@ -25,7 +25,7 @@ pub enum CanRequestImages {
 /// Indicating either entire image or just metadata availability
 #[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
 pub enum ImageOrMetadataAvailable {
-    ImageAvailable(Arc<Image>),
+    ImageAvailable(Arc<Image>, ServoUrl),
     MetadataAvailable(ImageMetadata),
 }
 
@@ -63,11 +63,11 @@ impl ImageResponder {
 #[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
 pub enum ImageResponse {
     /// The requested image was loaded.
-    Loaded(Arc<Image>),
+    Loaded(Arc<Image>, ServoUrl),
     /// The request image metadata was loaded.
     MetadataLoaded(ImageMetadata),
     /// The requested image failed to load, so a placeholder was loaded instead.
-    PlaceholderLoaded(Arc<Image>),
+    PlaceholderLoaded(Arc<Image>, ServoUrl),
     /// Neither the requested image nor the placeholder could be loaded.
     None,
 }

components/script/dom/canvasrenderingcontext2d.rs

@@ -32,7 +32,7 @@ use dom::htmlcanvaselement::HTMLCanvasElement;
 use dom::htmlcanvaselement::utils as canvas_utils;
 use dom::htmlimageelement::HTMLImageElement;
 use dom::imagedata::ImageData;
-use dom::node::{Node, NodeDamage, window_from_node};
+use dom::node::{document_from_node, Node, NodeDamage, window_from_node};
 use dom_struct::dom_struct;
 use euclid::matrix2d::Matrix2D;
 use euclid::point::Point2D;
@@ -228,16 +228,11 @@ impl CanvasRenderingContext2D {
             }
             HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::CanvasRenderingContext2D(image) =>
                 image.origin_is_clean(),
-            HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::HTMLImageElement(image) =>
+            HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::HTMLImageElement(image) => {
-                match image.get_url() {
+                let image_origin = image.get_origin().expect("Image's origin is missing");
-                    None => true,
+                let document = document_from_node(&*self.canvas);
-                    Some(url) => {
+                document.url().clone().origin() == image_origin
-                        // TODO(zbarsky): we should check the origin of the image against
+            }
-                        // the entry settings object, but for now check it against the canvas' doc.
-                        let node: &Node = &*self.canvas.upcast();
-                        url.origin() == node.owner_doc().url().origin()
-                    }
-                }
         }
     }
 
@@ -429,8 +424,8 @@ impl CanvasRenderingContext2D {
         };
 
         let img = match self.request_image_from_cache(url) {
-            ImageResponse::Loaded(img) => img,
+            ImageResponse::Loaded(img, _) => img,
-            ImageResponse::PlaceholderLoaded(_) |
+            ImageResponse::PlaceholderLoaded(_, _) |
             ImageResponse::None |
             ImageResponse::MetadataLoaded(_) => {
                 return None;

components/script/dom/htmlcanvaselement.rs

@@ -371,8 +371,8 @@ pub mod utils {
                                                UsePlaceholder::No,
                                                CanRequestImages::No);
         match response {
-            Ok(ImageOrMetadataAvailable::ImageAvailable(image)) =>
+            Ok(ImageOrMetadataAvailable::ImageAvailable(image, url)) =>
-                ImageResponse::Loaded(image),
+                ImageResponse::Loaded(image, url),
             _ => ImageResponse::None,
         }
     }

components/script/dom/htmlimageelement.rs

@@ -48,6 +48,7 @@ use network_listener::{NetworkListener, PreInvoke};
 use num_traits::ToPrimitive;
 use script_thread::Runnable;
 use servo_url::ServoUrl;
+use servo_url::origin::ImmutableOrigin;
 use std::cell::Cell;
 use std::default::Default;
 use std::i32;
@@ -73,6 +74,7 @@ struct ImageRequest {
     #[ignore_heap_size_of = "Arc"]
     image: Option<Arc<Image>>,
     metadata: Option<ImageMetadata>,
+    final_url: Option<ServoUrl>,
 }
 #[dom_struct]
 pub struct HTMLImageElement {
@@ -215,8 +217,8 @@ impl HTMLImageElement {
                                                UsePlaceholder::Yes,
                                                CanRequestImages::Yes);
         match response {
-            Ok(ImageOrMetadataAvailable::ImageAvailable(image)) => {
+            Ok(ImageOrMetadataAvailable::ImageAvailable(image, url)) => {
-                self.process_image_response(ImageResponse::Loaded(image));
+                self.process_image_response(ImageResponse::Loaded(image, url));
             }
 
             Ok(ImageOrMetadataAvailable::MetadataAvailable(m)) => {
@@ -273,7 +275,8 @@ impl HTMLImageElement {
 
     fn process_image_response(&self, image: ImageResponse) {
         let (image, metadata, trigger_image_load, trigger_image_error) = match image {
-            ImageResponse::Loaded(image) | ImageResponse::PlaceholderLoaded(image) => {
+            ImageResponse::Loaded(image, url) | ImageResponse::PlaceholderLoaded(image, url) => {
+                self.current_request.borrow_mut().final_url = Some(url);
                 (Some(image.clone()),
                  Some(ImageMetadata { height: image.height, width: image.width }),
                  true,
@@ -378,6 +381,7 @@ impl HTMLImageElement {
                 image: None,
                 metadata: None,
                 blocker: None,
+                final_url: None,
             }),
             pending_request: DOMRefCell::new(ImageRequest {
                 state: State::Unavailable,
@@ -386,6 +390,7 @@ impl HTMLImageElement {
                 image: None,
                 metadata: None,
                 blocker: None,
+                final_url: None,
             }),
             form_owner: Default::default(),
             generation: Default::default(),
@@ -441,6 +446,14 @@ impl HTMLImageElement {
 
         useMapElements.map(|mapElem| mapElem.get_area_elements())
     }
+
+    pub fn get_origin(&self) -> Option<ImmutableOrigin> {
+        match self.current_request.borrow_mut().final_url {
+            Some(ref url) => Some(url.origin()),
+            None => None
+        }
+    }
+
 }
 
 pub trait LayoutHTMLImageElementHelpers {

components/script/dom/webglrenderingcontext.rs

@@ -465,8 +465,8 @@ impl WebGLRenderingContext {
                 let window = window_from_node(&*self.canvas);
 
                 let img = match canvas_utils::request_image_from_cache(&window, img_url) {
-                    ImageResponse::Loaded(img) => img,
+                    ImageResponse::Loaded(img, _) => img,
-                    ImageResponse::PlaceholderLoaded(_) | ImageResponse::None |
+                    ImageResponse::PlaceholderLoaded(_, _) | ImageResponse::None |
                     ImageResponse::MetadataLoaded(_)
                         => return Err(()),
                 };

components/script/dom/window.rs

@@ -386,8 +386,8 @@ impl Window {
         }
         match response.response {
             ImageResponse::MetadataLoaded(_) => {}
-            ImageResponse::Loaded(_) |
+            ImageResponse::Loaded(_, _) |
-            ImageResponse::PlaceholderLoaded(_) |
+            ImageResponse::PlaceholderLoaded(_, _) |
             ImageResponse::None => { nodes.remove(); }
         }
         self.add_pending_reflow();

tests/wpt/metadata/MANIFEST.json

@@ -399550,7 +399550,7 @@
    "support"
   ],
   "common/canvas-tests.js": [
-   "2db347399bee84e76c01a15ca5c0c3006fcd4d4e",
+   "329e3ae1cfde2ee0525302e6a3260faed3885f28",
    "support"
   ],
   "common/css-red.txt": [

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.drawImage.canvas.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.drawImage.canvas.redirect.html]
-  type: testharness
-  [drawImage of unclean canvas makes the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.drawImage.image.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.drawImage.image.redirect.html]
-  type: testharness
-  [drawImage of different-origin image makes the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.canvas.fillStyle.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.canvas.fillStyle.redirect.html]
-  type: testharness
-  [Setting fillStyle to a pattern of an unclean canvas makes the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.canvas.strokeStyle.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.canvas.strokeStyle.redirect.html]
-  type: testharness
-  [Setting strokeStyle to a pattern of an unclean canvas makes the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.canvas.timing.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.canvas.timing.redirect.html]
-  type: testharness
-  [Pattern safety depends on whether the source was origin-clean, not on whether it still is clean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.create.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.create.redirect.html]
-  type: testharness
-  [Creating an unclean pattern does not make the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.cross.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.cross.redirect.html]
-  type: testharness
-  [Using an unclean pattern makes the target canvas origin-unclean, not the pattern canvas]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.image.fillStyle.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.image.fillStyle.redirect.html]
-  type: testharness
-  [Setting fillStyle to a pattern of a different-origin image makes the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.pattern.image.strokeStyle.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.pattern.image.strokeStyle.redirect.html]
-  type: testharness
-  [Setting strokeStyle to a pattern of a different-origin image makes the canvas origin-unclean]
-    expected: FAIL
-

tests/wpt/metadata/html/semantics/embedded-content/the-canvas-element/security.reset.redirect.html.ini

@@ -1,5 +0,0 @@
-[security.reset.redirect.html]
-  type: testharness
-  [Resetting the canvas state does not reset the origin-clean flag]
-    expected: FAIL
-

tests/wpt/mozilla/meta/mozilla/adopted_node_is_same_origin_domain.html.ini

@@ -2,3 +2,4 @@
   type: testharness
   [Adopting a node should make it same-origin-domain.]
     expected: FAIL
+

tests/wpt/web-platform-tests/common/canvas-tests.js

@@ -101,4 +101,5 @@ function addCrossOriginRedirectYellowImage()
     img.className = "resource";
     img.src = get_host_info().HTTP_ORIGIN + "/common/redirect.py?location=" +
         get_host_info().HTTP_REMOTE_ORIGIN + "/images/yellow.png";
+    document.body.appendChild(img);
 }