Refactor WorkerGlobalScope::report_an_error

components/script/dom/dedicatedworkerglobalscope.rs

@@ -17,10 +17,6 @@ use dom::bindings::js::{Root, RootCollection};
 use dom::bindings::reflector::Reflectable;
 use dom::bindings::str::DOMString;
 use dom::bindings::structuredclone::StructuredCloneData;
-use dom::errorevent::ErrorEvent;
-use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::eventdispatcher::EventStatus;
-use dom::eventtarget::EventTarget;
 use dom::messageevent::MessageEvent;
 use dom::worker::{TrustedWorkerAddress, WorkerErrorHandler, WorkerMessageHandler};
 use dom::workerglobalscope::WorkerGlobalScope;
@@ -36,7 +32,6 @@ use rand::random;
 use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, StackRootTLS, get_reports, new_rt_and_cx};
 use script_runtime::ScriptThreadEventCategory::WorkerEvent;
 use script_traits::{TimerEvent, TimerSource, WorkerGlobalScopeInit, WorkerScriptLoadOrigin};
-use std::cell::Cell;
 use std::mem::replace;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::AtomicBool;
@@ -92,8 +87,6 @@ pub struct DedicatedWorkerGlobalScope {
     #[ignore_heap_size_of = "Can't measure trait objects"]
     /// Sender to the parent thread.
     parent_sender: Box<ScriptChan + Send>,
-    /// https://html.spec.whatwg.org/multipage/#in-error-reporting-mode
-    in_error_reporting_mode: Cell<bool>
 }
 
 impl DedicatedWorkerGlobalScope {
@@ -120,7 +113,6 @@ impl DedicatedWorkerGlobalScope {
             timer_event_port: timer_event_port,
             parent_sender: parent_sender,
             worker: DOMRefCell::new(None),
-            in_error_reporting_mode: Cell::new(false),
         }
     }
 
@@ -338,33 +330,7 @@ impl DedicatedWorkerGlobalScope {
         }
     }
 
-    /// https://html.spec.whatwg.org/multipage/#report-the-error
+    pub fn forward_error_to_worker_object(&self, error_info: ErrorInfo) {
-    pub fn report_an_error(&self, error_info: ErrorInfo, value: HandleValue) {
-        // Step 1.
-        if self.in_error_reporting_mode.get() {
-            return;
-        }
-
-        // Step 2.
-        self.in_error_reporting_mode.set(true);
-
-        // Steps 3-12.
-        // FIXME(#13195): muted errors.
-        let event = ErrorEvent::new(GlobalRef::Worker(self.upcast()),
-                                    atom!("error"),
-                                    EventBubbles::DoesNotBubble,
-                                    EventCancelable::Cancelable,
-                                    error_info.message.as_str().into(),
-                                    error_info.filename.as_str().into(),
-                                    error_info.lineno,
-                                    error_info.column,
-                                    value);
-
-        // Step 13.
-        let event_status = event.upcast::<Event>().fire(self.upcast::<EventTarget>());
-
-        // Step 15
-        if event_status == EventStatus::NotCanceled {
         let worker = self.worker.borrow().as_ref().unwrap().clone();
         // TODO: Should use the DOM manipulation task source.
         self.parent_sender
@@ -372,10 +338,6 @@ impl DedicatedWorkerGlobalScope {
                                                box WorkerErrorHandler::new(worker, error_info)))
             .unwrap();
     }
-
-        // Step 14
-        self.in_error_reporting_mode.set(false);
-    }
 }
 
 #[allow(unsafe_code)]

components/script/dom/workerglobalscope.rs

@@ -18,6 +18,9 @@ use dom::bindings::str::DOMString;
 use dom::console::TimerSet;
 use dom::crypto::Crypto;
 use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
+use dom::errorevent::ErrorEvent;
+use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::eventdispatcher::EventStatus;
 use dom::eventtarget::EventTarget;
 use dom::promise::Promise;
 use dom::serviceworkerglobalscope::ServiceWorkerGlobalScope;
@@ -122,6 +125,9 @@ pub struct WorkerGlobalScope {
     console_timers: TimerSet,
 
     promise_job_queue: PromiseJobQueue,
+
+    /// https://html.spec.whatwg.org/multipage/#in-error-reporting-mode
+    in_error_reporting_mode: Cell<bool>
 }
 
 impl WorkerGlobalScope {
@@ -155,6 +161,7 @@ impl WorkerGlobalScope {
             scheduler_chan: init.scheduler_chan,
             console_timers: TimerSet::new(),
             promise_job_queue: PromiseJobQueue::new(),
+            in_error_reporting_mode: Default::default(),
         }
     }
 
@@ -490,9 +497,38 @@ impl WorkerGlobalScope {
 
     /// https://html.spec.whatwg.org/multipage/#report-the-error
     pub fn report_an_error(&self, error_info: ErrorInfo, value: HandleValue) {
-        self.downcast::<DedicatedWorkerGlobalScope>()
+        // Step 1.
-            .expect("Should implement report_an_error for this worker")
+        if self.in_error_reporting_mode.get() {
-            .report_an_error(error_info, value);
+            return;
+        }
+
+        // Step 2.
+        self.in_error_reporting_mode.set(true);
+
+        // Steps 3-12.
+        // FIXME(#13195): muted errors.
+        let event = ErrorEvent::new(GlobalRef::Worker(self),
+                                    atom!("error"),
+                                    EventBubbles::DoesNotBubble,
+                                    EventCancelable::Cancelable,
+                                    error_info.message.as_str().into(),
+                                    error_info.filename.as_str().into(),
+                                    error_info.lineno,
+                                    error_info.column,
+                                    value);
+
+        // Step 13.
+        let event_status = event.upcast::<Event>().fire(self.upcast::<EventTarget>());
+
+        // Step 15
+        if event_status == EventStatus::NotCanceled {
+            if let Some(dedicated) = self.downcast::<DedicatedWorkerGlobalScope>() {
+                dedicated.forward_error_to_worker_object(error_info);
+            }
+        }
+
+        // Step 14
+        self.in_error_reporting_mode.set(false);
     }
 }