Prepare for error reporting in workers.

components/script/dom/abstractworker.rs

@@ -4,7 +4,6 @@
 
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::reflector::Reflectable;
-use dom::bindings::str::DOMString;
 use dom::bindings::structuredclone::StructuredCloneData;
 use js::jsapi::{JSRuntime, JS_RequestInterruptCallback};
 use js::rust::Runtime;
@@ -30,27 +29,6 @@ impl<T: Reflectable> SimpleWorkerErrorHandler<T> {
     }
 }
 
-pub struct WorkerErrorHandler<T: Reflectable> {
-    pub addr: Trusted<T>,
-    pub msg: DOMString,
-    pub file_name: DOMString,
-    pub line_num: u32,
-    pub col_num: u32,
-}
-
-impl<T: Reflectable> WorkerErrorHandler<T> {
-    pub fn new(addr: Trusted<T>, msg: DOMString, file_name: DOMString, line_num: u32, col_num: u32)
-            -> WorkerErrorHandler<T> {
-        WorkerErrorHandler {
-            addr: addr,
-            msg: msg,
-            file_name: file_name,
-            line_num: line_num,
-            col_num: col_num,
-        }
-    }
-}
-
 #[derive(Copy, Clone)]
 pub struct SharedRt {
     pub rt: *mut JSRuntime

components/script/dom/bindings/error.rs

@@ -245,9 +245,7 @@ pub unsafe fn report_pending_exception(cx: *mut JSContext, dispatch_event: bool)
 
         if dispatch_event {
             let global = global_root_from_context(cx);
-            if let GlobalRef::Window(window) = global.r() {
-                window.report_an_error(error_info, value.handle());
-            }
+            global.r().report_an_error(error_info, value.handle());
         }
     }
 }

components/script/dom/bindings/global.rs

@@ -10,11 +10,13 @@
 use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::conversions::root_from_object;
+use dom::bindings::error::ErrorInfo;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflectable, Reflector};
 use dom::window::{self, ScriptHelpers};
 use dom::workerglobalscope::WorkerGlobalScope;
 use ipc_channel::ipc::IpcSender;
+use js::jsapi::HandleValue;
 use js::jsapi::{CurrentGlobalOrNull, GetGlobalForObjectCrossCompartment};
 use js::jsapi::{JSContext, JSObject, JS_GetClass, MutableHandleValue};
 use js::{JSCLASS_IS_DOMJSCLASS, JSCLASS_IS_GLOBAL};
@@ -285,6 +287,14 @@ impl<'a> GlobalRef<'a> {
             GlobalRef::Worker(ref worker) => worker.get_runnable_wrapper(),
         }
     }
+
+    /// https://html.spec.whatwg.org/multipage/#report-the-error
+    pub fn report_an_error(&self, error_info: ErrorInfo, value: HandleValue) {
+        match *self {
+            GlobalRef::Window(ref window) => window.report_an_error(error_info, value),
+            GlobalRef::Worker(_) => (),
+        }
+    }
 }
 
 impl GlobalRoot {

components/script/dom/serviceworker.rs

@@ -2,21 +2,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::abstractworker::WorkerScriptMsg;
-use dom::abstractworker::{SimpleWorkerErrorHandler, WorkerErrorHandler};
+use dom::abstractworker::{SimpleWorkerErrorHandler, WorkerScriptMsg};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::ServiceWorkerBinding::{ServiceWorkerMethods, ServiceWorkerState, Wrap};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::Trusted;
-use dom::bindings::reflector::{Reflectable, reflect_dom_object};
-use dom::bindings::str::{DOMString, USVString};
-use dom::errorevent::ErrorEvent;
-use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::str::USVString;
 use dom::eventtarget::EventTarget;
-use js::jsval::UndefinedValue;
 use script_thread::Runnable;
 use std::cell::Cell;
 use std::sync::mpsc::Sender;
@@ -66,18 +62,6 @@ impl ServiceWorker {
         Url::parse(&self.script_url.borrow().clone()).unwrap()
     }
 
-    pub fn handle_error_message(address: TrustedServiceWorkerAddress, message: DOMString,
-                                filename: DOMString, lineno: u32, colno: u32) {
-        let worker = address.root();
-
-        let global = worker.r().global();
-        rooted!(in(global.r().get_cx()) let error = UndefinedValue());
-        let errorevent = ErrorEvent::new(global.r(), atom!("error"),
-                                         EventBubbles::Bubbles, EventCancelable::Cancelable,
-                                         message, filename, lineno, colno, error.handle());
-        errorevent.upcast::<Event>().fire(worker.upcast());
-    }
-
     pub fn install_serviceworker(global: GlobalRef,
                                  script_url: Url,
                                  skip_waiting: bool) -> Root<ServiceWorker> {
@@ -112,11 +96,3 @@ impl Runnable for SimpleWorkerErrorHandler<ServiceWorker> {
         ServiceWorker::dispatch_simple_error(this.addr);
     }
 }
-
-impl Runnable for WorkerErrorHandler<ServiceWorker> {
-    #[allow(unrooted_must_root)]
-    fn handler(self: Box<WorkerErrorHandler<ServiceWorker>>) {
-        let this = *self;
-        ServiceWorker::handle_error_message(this.addr, this.msg, this.file_name, this.line_num, this.col_num);
-    }
-}

components/script/dom/worker.rs

@@ -4,7 +4,7 @@
 
 use devtools_traits::{ScriptToDevtoolsControlMsg, DevtoolsPageInfo};
 use dom::abstractworker::WorkerScriptMsg;
-use dom::abstractworker::{SimpleWorkerErrorHandler, SharedRt, WorkerErrorHandler};
+use dom::abstractworker::{SimpleWorkerErrorHandler, SharedRt};
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::codegen::Bindings::WorkerBinding::WorkerMethods;
@@ -17,8 +17,6 @@ use dom::bindings::reflector::{Reflectable, 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};
 use dom::eventtarget::EventTarget;
 use dom::messageevent::MessageEvent;
 use dom::workerglobalscope::prepare_workerscope_init;
@@ -139,22 +137,6 @@ impl Worker {
         let worker = address.root();
         worker.upcast().fire_simple_event("error");
     }
-
-    pub fn handle_error_message(address: TrustedWorkerAddress, message: DOMString,
-                                filename: DOMString, lineno: u32, colno: u32) {
-        let worker = address.root();
-
-        if worker.is_terminated() {
-            return;
-        }
-
-        let global = worker.r().global();
-        rooted!(in(global.r().get_cx()) let error = UndefinedValue());
-        let errorevent = ErrorEvent::new(global.r(), atom!("error"),
-                                         EventBubbles::Bubbles, EventCancelable::Cancelable,
-                                         message, filename, lineno, colno, error.handle());
-        errorevent.upcast::<Event>().fire(worker.upcast());
-    }
 }
 
 impl WorkerMethods for Worker {
@@ -220,11 +202,3 @@ impl Runnable for SimpleWorkerErrorHandler<Worker> {
         Worker::dispatch_simple_error(this.addr);
     }
 }
-
-impl Runnable for WorkerErrorHandler<Worker> {
-    #[allow(unrooted_must_root)]
-    fn handler(self: Box<WorkerErrorHandler<Worker>>) {
-        let this = *self;
-        Worker::handle_error_message(this.addr, this.msg, this.file_name, this.line_num, this.col_num);
-    }
-}