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

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) =>
-                match image.get_url() {
-                    None => true,
-                    Some(url) => {
-                        // 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()
-                    }
-                }
+            HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::HTMLImageElement(image) => {
+                let image_origin = image.get_origin().expect("Image's origin is missing");
+                let document = document_from_node(&*self.canvas);
+                document.url().clone().origin() == image_origin
+            }
         }
     }
 
@@ -429,8 +424,8 @@ impl CanvasRenderingContext2D {
         };
 
         let img = match self.request_image_from_cache(url) {
-            ImageResponse::Loaded(img) => img,
-            ImageResponse::PlaceholderLoaded(_) |
+            ImageResponse::Loaded(img, _) => img,
+            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)) =>
-                ImageResponse::Loaded(image),
+            Ok(ImageOrMetadataAvailable::ImageAvailable(image, url)) =>
+                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)) => {
-                self.process_image_response(ImageResponse::Loaded(image));
+            Ok(ImageOrMetadataAvailable::ImageAvailable(image, url)) => {
+                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::PlaceholderLoaded(_) | ImageResponse::None |
+                    ImageResponse::Loaded(img, _) => img,
+                    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::PlaceholderLoaded(_) |
+            ImageResponse::Loaded(_, _) |
+            ImageResponse::PlaceholderLoaded(_, _) |
             ImageResponse::None => { nodes.remove(); }
         }
         self.add_pending_reflow();