Use task! to forward unhandled errors to worker objects

components/script/dom/dedicatedworkerglobalscope.rs

@@ -15,15 +15,18 @@ use dom::bindings::js::{Root, RootCollection};
 use dom::bindings::reflector::DomObject;
 use dom::bindings::str::DOMString;
 use dom::bindings::structuredclone::StructuredCloneData;
+use dom::errorevent::ErrorEvent;
+use dom::event::{Event, EventBubbles, EventCancelable, EventStatus};
+use dom::eventtarget::EventTarget;
 use dom::globalscope::GlobalScope;
 use dom::messageevent::MessageEvent;
-use dom::worker::{TrustedWorkerAddress, Worker, WorkerErrorHandler};
+use dom::worker::{TrustedWorkerAddress, Worker};
 use dom::workerglobalscope::WorkerGlobalScope;
 use dom_struct::dom_struct;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
 use js::jsapi::{HandleValue, JS_SetInterruptCallback};
-use js::jsapi::{JSAutoCompartment, JSContext};
+use js::jsapi::{JSAutoCompartment, JSContext, NullHandleValue};
 use js::jsval::UndefinedValue;
 use js::rust::Runtime;
 use msg::constellation_msg::TopLevelBrowsingContextId;
@@ -348,13 +351,36 @@ impl DedicatedWorkerGlobalScope {
         }
     }
 
+    // https://html.spec.whatwg.org/multipage/#runtime-script-errors-2
+    #[allow(unsafe_code)]
     pub fn forward_error_to_worker_object(&self, error_info: ErrorInfo) {
         let worker = self.worker.borrow().as_ref().unwrap().clone();
+        let task = box task!(forward_error_to_worker_object: move || {
+            let worker = worker.root();
+            let global = worker.global();
+
+            // Step 1.
+            let event = ErrorEvent::new(
+                &global,
+                atom!("error"),
+                EventBubbles::DoesNotBubble,
+                EventCancelable::Cancelable,
+                error_info.message.as_str().into(),
+                error_info.filename.as_str().into(),
+                error_info.lineno,
+                error_info.column,
+                unsafe { NullHandleValue },
+            );
+            let event_status =
+                event.upcast::<Event>().fire(worker.upcast::<EventTarget>());
+
+            // Step 2.
+            if event_status == EventStatus::NotCanceled {
+                global.report_an_error(error_info, unsafe { NullHandleValue });
+            }
+        });
         // TODO: Should use the DOM manipulation task source.
-        self.parent_sender
+        self.parent_sender.send(CommonScriptMsg::Task(WorkerEvent, task)).unwrap();
-            .send(CommonScriptMsg::Task(WorkerEvent,
-                                               box WorkerErrorHandler::new(worker, error_info)))
-            .unwrap();
     }
 }
 

components/script/dom/htmliframeelement.rs

@@ -54,7 +54,6 @@ use servo_url::ServoUrl;
 use std::cell::Cell;
 use style::attr::{AttrValue, LengthOrPercentageOrAuto};
 use style::context::ReflowGoal;
-use task::Task;
 use task_source::TaskSource;
 
 bitflags! {
@@ -233,9 +232,15 @@ impl HTMLIFrameElement {
 
         // https://github.com/whatwg/html/issues/490
         if mode == ProcessingMode::FirstTime && !self.upcast::<Element>().has_attribute(&local_name!("src")) {
-            let event_loop = window.dom_manipulation_task_source();
+            let this = Trusted::new(self);
-            let _ = event_loop.queue(box IFrameLoadEventSteps::new(self),
+            let pipeline_id = self.pipeline_id().unwrap();
-                                     window.upcast());
+            // FIXME(nox): Why are errors silenced here?
+            let _ = window.dom_manipulation_task_source().queue(
+                box task!(iframe_load_event_steps: move || {
+                    this.root().iframe_load_event_steps(pipeline_id);
+                }),
+                window.upcast(),
+            );
             return;
         }
 
@@ -835,24 +840,3 @@ impl VirtualMethods for HTMLIFrameElement {
         self.destroy_nested_browsing_context();
     }
 }
-
-struct IFrameLoadEventSteps {
-    frame_element: Trusted<HTMLIFrameElement>,
-    pipeline_id: PipelineId,
-}
-
-impl IFrameLoadEventSteps {
-    fn new(frame_element: &HTMLIFrameElement) -> IFrameLoadEventSteps {
-        IFrameLoadEventSteps {
-            frame_element: Trusted::new(frame_element),
-            pipeline_id: frame_element.pipeline_id().unwrap(),
-        }
-    }
-}
-
-impl Task for IFrameLoadEventSteps {
-    fn run(self: Box<Self>) {
-        let this = self.frame_element.root();
-        this.iframe_load_event_steps(self.pipeline_id);
-    }
-}

components/script/dom/window.rs

@@ -111,7 +111,7 @@ use style::selector_parser::PseudoElement;
 use style::str::HTML_SPACE_CHARACTERS;
 use style::stylesheets::CssRuleType;
 use style_traits::PARSING_MODE_DEFAULT;
-use task::{Task, TaskCanceller};
+use task::TaskCanceller;
 use task_source::dom_manipulation::DOMManipulationTaskSource;
 use task_source::file_reading::FileReadingTaskSource;
 use task_source::history_traversal::HistoryTraversalTaskSource;

components/script/dom/worker.rs

@@ -7,7 +7,7 @@ use dom::abstractworker::{SharedRt, SimpleWorkerErrorHandler};
 use dom::abstractworker::WorkerScriptMsg;
 use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::codegen::Bindings::WorkerBinding::WorkerMethods;
-use dom::bindings::error::{Error, ErrorResult, Fallible, ErrorInfo};
+use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::Trusted;
@@ -15,15 +15,13 @@ use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::str::DOMString;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
-use dom::errorevent::ErrorEvent;
-use dom::event::{Event, EventBubbles, EventCancelable, EventStatus};
 use dom::eventtarget::EventTarget;
 use dom::globalscope::GlobalScope;
 use dom::messageevent::MessageEvent;
 use dom::workerglobalscope::prepare_workerscope_init;
 use dom_struct::dom_struct;
 use ipc_channel::ipc;
-use js::jsapi::{HandleValue, JSAutoCompartment, JSContext, NullHandleValue};
+use js::jsapi::{HandleValue, JSAutoCompartment, JSContext};
 use js::jsval::UndefinedValue;
 use script_traits::WorkerScriptLoadOrigin;
 use std::cell::Cell;
@@ -139,27 +137,6 @@ impl Worker {
         let worker = address.root();
         worker.upcast().fire_event(atom!("error"));
     }
-
-    #[allow(unsafe_code)]
-    fn dispatch_error(&self, error_info: ErrorInfo) {
-        let global = self.global();
-        let event = ErrorEvent::new(&global,
-                                    atom!("error"),
-                                    EventBubbles::DoesNotBubble,
-                                    EventCancelable::Cancelable,
-                                    error_info.message.as_str().into(),
-                                    error_info.filename.as_str().into(),
-                                    error_info.lineno,
-                                    error_info.column,
-                                    unsafe { NullHandleValue });
-
-        let event_status = event.upcast::<Event>().fire(self.upcast::<EventTarget>());
-        if event_status == EventStatus::Canceled {
-            return;
-        }
-
-        global.report_an_error(error_info, unsafe { NullHandleValue });
-    }
 }
 
 impl WorkerMethods for Worker {
@@ -205,24 +182,3 @@ impl Task for SimpleWorkerErrorHandler<Worker> {
         Worker::dispatch_simple_error(this.addr);
     }
 }
-
-pub struct WorkerErrorHandler {
-    address: Trusted<Worker>,
-    error_info: ErrorInfo,
-}
-
-impl WorkerErrorHandler {
-    pub fn new(address: Trusted<Worker>, error_info: ErrorInfo) -> WorkerErrorHandler {
-        WorkerErrorHandler {
-            address: address,
-            error_info: error_info,
-        }
-    }
-}
-
-impl Task for WorkerErrorHandler {
-    fn run(self: Box<Self>) {
-        let this = *self;
-        this.address.root().dispatch_error(this.error_info);
-    }
-}