Add the TaskSourceName to CommonScriptMsg::Task

Update QueuedTaskConversion and the TaskQueue to use it

components/script/dom/dedicatedworkerglobalscope.rs

@@ -33,7 +33,7 @@ use js::rust::HandleValue;
 use msg::constellation_msg::TopLevelBrowsingContextId;
 use net_traits::{IpcSend, load_whole_resource};
 use net_traits::request::{CredentialsMode, Destination, RequestInit};
-use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, ScriptThreadEventCategory, new_rt_and_cx, Runtime};
+use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, new_rt_and_cx, Runtime};
 use script_runtime::ScriptThreadEventCategory::WorkerEvent;
 use script_traits::{TimerEvent, TimerSource, WorkerGlobalScopeInit, WorkerScriptLoadOrigin};
 use servo_rand::random;
@@ -45,6 +45,7 @@ use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
 use style::thread_state::{self, ThreadState};
 use task_queue::{QueuedTask, QueuedTaskConversion, TaskQueue};
+use task_source::TaskSourceName;
 
 /// Set the `worker` field of a related DedicatedWorkerGlobalScope object to a particular
 /// value for the duration of this object's lifetime. This ensures that the related Worker
@@ -86,7 +87,7 @@ pub enum MixedMessage {
 }
 
 impl QueuedTaskConversion for DedicatedWorkerScriptMsg {
-    fn task_category(&self) -> Option<&ScriptThreadEventCategory> {
+    fn task_source_name(&self) -> Option<&TaskSourceName> {
         let common_worker_msg = match self {
             DedicatedWorkerScriptMsg::CommonWorker(_, common_worker_msg) => common_worker_msg,
             _ => return None,
@@ -95,11 +96,10 @@ impl QueuedTaskConversion for DedicatedWorkerScriptMsg {
             WorkerScriptMsg::Common(ref script_msg) => script_msg,
             _ => return None,
         };
-        let category = match script_msg {
-            CommonScriptMsg::Task(category, _boxed, _pipeline_id) => category,
+        match script_msg {
+            CommonScriptMsg::Task(_category, _boxed, _pipeline_id, source_name) => Some(&source_name),
             _ => return None,
-        };
-        Some(category)
+        }
     }
 
     fn into_queued_task(self) -> Option<QueuedTask> {
@@ -111,17 +111,22 @@ impl QueuedTaskConversion for DedicatedWorkerScriptMsg {
             WorkerScriptMsg::Common(script_msg) => script_msg,
             _ => return None,
         };
-        let (category, boxed, pipeline_id) = match script_msg {
-            CommonScriptMsg::Task(category, boxed, pipeline_id) =>
-                (category, boxed, pipeline_id),
+        let (category, boxed, pipeline_id, task_source) = match script_msg {
+            CommonScriptMsg::Task(category, boxed, pipeline_id, task_source) =>
+                (category, boxed, pipeline_id, task_source),
             _ => return None,
         };
-        Some((Some(worker), category, boxed, pipeline_id))
+        Some((Some(worker), category, boxed, pipeline_id, task_source))
     }
 
     fn from_queued_task(queued_task: QueuedTask) -> Self {
-        let (worker, category, boxed, pipeline_id) = queued_task;
-        let script_msg = CommonScriptMsg::Task(category, boxed, pipeline_id);
+        let (worker, category, boxed, pipeline_id, task_source) = queued_task;
+        let script_msg = CommonScriptMsg::Task(
+            category,
+            boxed,
+            pipeline_id,
+            task_source
+        );
         DedicatedWorkerScriptMsg::CommonWorker(worker.unwrap(), WorkerScriptMsg::Common(script_msg))
     }
 
@@ -295,7 +300,8 @@ impl DedicatedWorkerGlobalScope {
                     parent_sender.send(CommonScriptMsg::Task(
                         WorkerEvent,
                         Box::new(SimpleWorkerErrorHandler::new(worker)),
-                        pipeline_id
+                        pipeline_id,
+                        TaskSourceName::DOMManipulation,
                     )).unwrap();
                     return;
                 }
@@ -446,8 +452,12 @@ impl DedicatedWorkerGlobalScope {
                 global.report_an_error(error_info, HandleValue::null());
             }
         }));
-        // TODO: Should use the DOM manipulation task source.
-        self.parent_sender.send(CommonScriptMsg::Task(WorkerEvent, task, Some(pipeline_id))).unwrap();
+        self.parent_sender.send(CommonScriptMsg::Task(
+            WorkerEvent,
+            task,
+            Some(pipeline_id),
+            TaskSourceName::DOMManipulation,
+            )).unwrap();
     }
 }
 
@@ -472,7 +482,13 @@ impl DedicatedWorkerGlobalScopeMethods for DedicatedWorkerGlobalScope {
         let task = Box::new(task!(post_worker_message: move || {
             Worker::handle_message(worker, data);
         }));
-        self.parent_sender.send(CommonScriptMsg::Task(WorkerEvent, task, Some(pipeline_id))).unwrap();
+        // TODO: Change this task source to a new `unshipped-port-message-queue` task source
+        self.parent_sender.send(CommonScriptMsg::Task(
+            WorkerEvent,
+            task,
+            Some(pipeline_id),
+            TaskSourceName::DOMManipulation,
+        )).unwrap();
         Ok(())
     }
 

components/script/dom/document.rs

@@ -2837,7 +2837,14 @@ impl Document {
         let trusted_pending = Trusted::new(pending);
         let trusted_promise = TrustedPromise::new(promise.clone());
         let handler = ElementPerformFullscreenEnter::new(trusted_pending, trusted_promise, error);
-        let script_msg = CommonScriptMsg::Task(ScriptThreadEventCategory::EnterFullscreen, handler, pipeline_id);
+        // NOTE: This steps should be running in parallel
+        // https://fullscreen.spec.whatwg.org/#dom-element-requestfullscreen
+        let script_msg = CommonScriptMsg::Task(
+            ScriptThreadEventCategory::EnterFullscreen,
+            handler,
+            pipeline_id,
+            TaskSourceName::DOMManipulation,
+        );
         let msg = MainThreadScriptMsg::Common(script_msg);
         window.main_thread_script_chan().send(msg).unwrap();
 
@@ -2870,7 +2877,14 @@ impl Document {
         let trusted_promise = TrustedPromise::new(promise.clone());
         let handler = ElementPerformFullscreenExit::new(trusted_element, trusted_promise);
         let pipeline_id = Some(global.pipeline_id());
-        let script_msg = CommonScriptMsg::Task(ScriptThreadEventCategory::ExitFullscreen, handler, pipeline_id);
+        // NOTE: This steps should be running in parallel
+        // https://fullscreen.spec.whatwg.org/#exit-fullscreen
+        let script_msg = CommonScriptMsg::Task(
+            ScriptThreadEventCategory::ExitFullscreen,
+            handler,
+            pipeline_id,
+            TaskSourceName::DOMManipulation,
+        );
         let msg = MainThreadScriptMsg::Common(script_msg);
         window.main_thread_script_chan().send(msg).unwrap();
 

components/script/dom/serviceworkerglobalscope.rs

@@ -27,7 +27,7 @@ use js::jsapi::{JSAutoCompartment, JSContext, JS_AddInterruptCallback};
 use js::jsval::UndefinedValue;
 use net_traits::{load_whole_resource, IpcSend, CustomResponseMediator};
 use net_traits::request::{CredentialsMode, Destination, RequestInit};
-use script_runtime::{CommonScriptMsg, ScriptChan, ScriptThreadEventCategory, new_rt_and_cx, Runtime};
+use script_runtime::{CommonScriptMsg, ScriptChan, new_rt_and_cx, Runtime};
 use script_traits::{TimerEvent, WorkerGlobalScopeInit, ScopeThings, ServiceWorkerMsg, WorkerScriptLoadOrigin};
 use servo_config::prefs::PREFS;
 use servo_rand::random;
@@ -37,6 +37,7 @@ use std::thread;
 use std::time::Duration;
 use style::thread_state::{self, ThreadState};
 use task_queue::{QueuedTask, QueuedTaskConversion, TaskQueue};
+use task_source::TaskSourceName;
 
 /// Messages used to control service worker event loop
 pub enum ServiceWorkerScriptMsg {
@@ -49,16 +50,15 @@ pub enum ServiceWorkerScriptMsg {
 }
 
 impl QueuedTaskConversion for ServiceWorkerScriptMsg {
-    fn task_category(&self) -> Option<&ScriptThreadEventCategory> {
+    fn task_source_name(&self) -> Option<&TaskSourceName> {
         let script_msg = match self {
             ServiceWorkerScriptMsg::CommonWorker(WorkerScriptMsg::Common(script_msg)) => script_msg,
             _ => return None,
         };
-        let category = match script_msg {
-            CommonScriptMsg::Task(category, _boxed, _pipeline_id) => category,
+        match script_msg {
+            CommonScriptMsg::Task(_category, _boxed, _pipeline_id, task_source) => Some(&task_source),
             _ => return None,
-        };
-        Some(&category)
+        }
     }
 
     fn into_queued_task(self) -> Option<QueuedTask> {
@@ -66,17 +66,17 @@ impl QueuedTaskConversion for ServiceWorkerScriptMsg {
             ServiceWorkerScriptMsg::CommonWorker(WorkerScriptMsg::Common(script_msg)) => script_msg,
             _ => return None,
         };
-        let (category, boxed, pipeline_id) = match script_msg {
-            CommonScriptMsg::Task(category, boxed, pipeline_id) =>
-                (category, boxed, pipeline_id),
+        let (category, boxed, pipeline_id, task_source) = match script_msg {
+            CommonScriptMsg::Task(category, boxed, pipeline_id, task_source) =>
+                (category, boxed, pipeline_id, task_source),
             _ => return None,
         };
-        Some((None, category, boxed, pipeline_id))
+        Some((None, category, boxed, pipeline_id, task_source))
     }
 
     fn from_queued_task(queued_task: QueuedTask) -> Self {
-        let (_worker, category, boxed, pipeline_id) = queued_task;
-        let script_msg = CommonScriptMsg::Task(category, boxed, pipeline_id);
+        let (_worker, category, boxed, pipeline_id, task_source) = queued_task;
+        let script_msg = CommonScriptMsg::Task(category, boxed, pipeline_id, task_source);
         ServiceWorkerScriptMsg::CommonWorker(WorkerScriptMsg::Common(script_msg))
     }
 

components/script/dom/vrdisplay.rs

@@ -42,6 +42,7 @@ use std::ops::Deref;
 use std::rc::Rc;
 use std::sync::mpsc;
 use std::thread;
+use task_source::TaskSourceName;
 use webvr_traits::{WebVRDisplayData, WebVRDisplayEvent, WebVRFrameData, WebVRLayer, WebVRMsg};
 
 #[dom_struct]
@@ -517,7 +518,14 @@ impl VRDisplay {
                 let task = Box::new(task!(handle_vrdisplay_raf: move || {
                     this.root().handle_raf(&sender);
                 }));
-                js_sender.send(CommonScriptMsg::Task(WebVREvent, task, Some(pipeline_id))).unwrap();
+                // NOTE: WebVR spec doesn't specify what task source we should use. Is
+                // dom-manipulation a good choice long term?
+                js_sender.send(CommonScriptMsg::Task(
+                    WebVREvent,
+                    task,
+                    Some(pipeline_id),
+                    TaskSourceName::DOMManipulation,
+                )).unwrap();
 
                 // Run Sync Poses in parallell on Render thread
                 let msg = WebVRCommand::SyncPoses(display_id, near, far, sync_sender.clone());

components/script/dom/websocket.rs

@@ -268,7 +268,13 @@ impl WebSocket {
             let pipeline_id = self.global().pipeline_id();
             self.global()
                 .script_chan()
-                .send(CommonScriptMsg::Task(WebSocketEvent, task, Some(pipeline_id)))
+                // TODO: Use a dedicated `websocket-task-source` task source instead.
+                .send(CommonScriptMsg::Task(
+                    WebSocketEvent,
+                    task,
+                    Some(pipeline_id),
+                    TaskSourceName::Networking,
+                ))
                 .unwrap();
         }
 

components/script/dom/window.rs

@@ -1666,7 +1666,8 @@ impl Window {
                     let _ = self.script_chan.send(CommonScriptMsg::Task(
                         ScriptThreadEventCategory::DomEvent,
                         Box::new(self.task_canceller(TaskSourceName::DOMManipulation).wrap_task(task)),
-                        self.pipeline_id()
+                        self.pipeline_id(),
+                        TaskSourceName::DOMManipulation,
                     ));
                     doc.set_url(url.clone());
                     return
@@ -2123,7 +2124,8 @@ impl Window {
         let _ = self.script_chan.send(CommonScriptMsg::Task(
             ScriptThreadEventCategory::DomEvent,
             Box::new(self.task_canceller(TaskSourceName::DOMManipulation).wrap_task(task)),
-            self.pipeline_id()
+            self.pipeline_id(),
+            TaskSourceName::DOMManipulation,
         ));
     }
 }

components/script/dom/workerglobalscope.rs

@@ -397,7 +397,7 @@ impl WorkerGlobalScope {
 
     pub fn process_event(&self, msg: CommonScriptMsg) {
         match msg {
-            CommonScriptMsg::Task(_, task, _) => {
+            CommonScriptMsg::Task(_, task, _, _) => {
                 task.run_box()
             },
             CommonScriptMsg::CollectReports(reports_chan) => {

components/script/dom/worklet.rs

@@ -66,6 +66,7 @@ use style::thread_state::{self, ThreadState};
 use swapper::Swapper;
 use swapper::swapper;
 use task::TaskBox;
+use task_source::TaskSourceName;
 use uuid::Uuid;
 
 // Magic numbers
@@ -644,7 +645,14 @@ impl WorkletThread {
     where
         T: TaskBox + 'static,
     {
-        let msg = CommonScriptMsg::Task(ScriptThreadEventCategory::WorkletEvent, Box::new(task), None);
+        // NOTE: It's unclear which task source should be used here:
+        // https://drafts.css-houdini.org/worklets/#dom-worklet-addmodule
+        let msg = CommonScriptMsg::Task(
+            ScriptThreadEventCategory::WorkletEvent,
+            Box::new(task),
+            None,
+            TaskSourceName::DOMManipulation,
+        );
         let msg = MainThreadScriptMsg::Common(msg);
         self.global_init.to_script_thread_sender.send(msg).expect("Worklet thread outlived script thread.");
     }

components/script/script_runtime.rs

@@ -43,6 +43,7 @@ use std::panic::AssertUnwindSafe;
 use std::ptr;
 use style::thread_state::{self, ThreadState};
 use task::TaskBox;
+use task_source::TaskSourceName;
 use time::{Tm, now};
 
 /// Common messages used to control the event loops in both the script and the worker
@@ -51,14 +52,14 @@ pub enum CommonScriptMsg {
     /// supplied channel.
     CollectReports(ReportsChan),
     /// Generic message that encapsulates event handling.
-    Task(ScriptThreadEventCategory, Box<TaskBox>, Option<PipelineId>),
+    Task(ScriptThreadEventCategory, Box<TaskBox>, Option<PipelineId>, TaskSourceName),
 }
 
 impl fmt::Debug for CommonScriptMsg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             CommonScriptMsg::CollectReports(_) => write!(f, "CollectReports(...)"),
-            CommonScriptMsg::Task(ref category, ref task, _) => {
+            CommonScriptMsg::Task(ref category, ref task, _, _) => {
                 f.debug_tuple("Task").field(category).field(task).finish()
             },
         }

components/script/script_thread.rs

@@ -117,6 +117,7 @@ use std::sync::mpsc::{Receiver, Select, Sender, channel};
 use std::thread;
 use style::thread_state::{self, ThreadState};
 use task_queue::{QueuedTask, QueuedTaskConversion, TaskQueue};
+use task_source::TaskSourceName;
 use task_source::dom_manipulation::DOMManipulationTaskSource;
 use task_source::file_reading::FileReadingTaskSource;
 use task_source::history_traversal::HistoryTraversalTaskSource;
@@ -248,16 +249,15 @@ pub enum MainThreadScriptMsg {
 }
 
 impl QueuedTaskConversion for MainThreadScriptMsg {
-    fn task_category(&self) -> Option<&ScriptThreadEventCategory> {
+    fn task_source_name(&self) -> Option<&TaskSourceName> {
         let script_msg = match self {
             MainThreadScriptMsg::Common(script_msg) => script_msg,
             _ => return None,
         };
-        let category = match script_msg {
-            CommonScriptMsg::Task(category, _boxed, _pipeline_id) => category,
+        match script_msg {
+            CommonScriptMsg::Task(_category, _boxed, _pipeline_id, task_source) => Some(&task_source),
             _ => return None,
-        };
-        Some(&category)
+        }
     }
 
     fn into_queued_task(self) -> Option<QueuedTask> {
@@ -265,17 +265,17 @@ impl QueuedTaskConversion for MainThreadScriptMsg {
             MainThreadScriptMsg::Common(script_msg) => script_msg,
             _ => return None,
         };
-        let (category, boxed, pipeline_id) = match script_msg {
-            CommonScriptMsg::Task(category, boxed, pipeline_id) =>
-                (category, boxed, pipeline_id),
+        let (category, boxed, pipeline_id, task_source) = match script_msg {
+            CommonScriptMsg::Task(category, boxed, pipeline_id, task_source) =>
+                (category, boxed, pipeline_id, task_source),
             _ => return None,
         };
-        Some((None, category, boxed, pipeline_id))
+        Some((None, category, boxed, pipeline_id, task_source))
     }
 
     fn from_queued_task(queued_task: QueuedTask) -> Self {
-        let (_worker, category, boxed, pipeline_id) = queued_task;
-        let script_msg = CommonScriptMsg::Task(category, boxed, pipeline_id);
+        let (_worker, category, boxed, pipeline_id, task_source) = queued_task;
+        let script_msg = CommonScriptMsg::Task(category, boxed, pipeline_id, task_source);
         MainThreadScriptMsg::Common(script_msg)
     }
 
@@ -1279,7 +1279,7 @@ impl ScriptThread {
             MixedMessage::FromDevtools(_) => None,
             MixedMessage::FromScript(ref inner_msg) => {
                 match *inner_msg {
-                    MainThreadScriptMsg::Common(CommonScriptMsg::Task(_, _, pipeline_id)) =>
+                    MainThreadScriptMsg::Common(CommonScriptMsg::Task(_, _, pipeline_id, _)) =>
                         pipeline_id,
                     MainThreadScriptMsg::Common(CommonScriptMsg::CollectReports(_)) => None,
                     MainThreadScriptMsg::Navigate(pipeline_id, ..) => Some(pipeline_id),
@@ -1433,7 +1433,7 @@ impl ScriptThread {
             MainThreadScriptMsg::Navigate(parent_pipeline_id, load_data, replace) => {
                 self.handle_navigate(parent_pipeline_id, None, load_data, replace)
             },
-            MainThreadScriptMsg::Common(CommonScriptMsg::Task(_, task, _)) => {
+            MainThreadScriptMsg::Common(CommonScriptMsg::Task(_, task, _, _)) => {
                 task.run_box()
             }
             MainThreadScriptMsg::Common(CommonScriptMsg::CollectReports(chan)) => {

components/script/task_queue.rs

@@ -16,11 +16,17 @@ use task::TaskBox;
 use task_source::TaskSourceName;
 
 
-pub type QueuedTask = (Option<TrustedWorkerAddress>, ScriptThreadEventCategory, Box<TaskBox>, Option<PipelineId>);
+pub type QueuedTask = (
+    Option<TrustedWorkerAddress>,
+    ScriptThreadEventCategory,
+    Box<TaskBox>,
+    Option<PipelineId>,
+    TaskSourceName
+);
 
 /// Defining the operations used to convert from a msg T to a QueuedTask.
 pub trait QueuedTaskConversion {
-    fn task_category(&self) -> Option<&ScriptThreadEventCategory>;
+    fn task_source_name(&self) -> Option<&TaskSourceName>;
     fn into_queued_task(self) -> Option<QueuedTask>;
     fn from_queued_task(queued_task: QueuedTask) -> Self;
     fn wake_up_msg() -> Self;
@@ -60,12 +66,12 @@ impl<T: QueuedTaskConversion> TaskQueue<T> {
             .collect();
 
         let to_be_throttled: Vec<T> = non_throttled.drain_filter(|msg|{
-            let category = match msg.task_category() {
-                Some(category) => category,
+            let task_source = match msg.task_source_name() {
+                Some(task_source) => task_source,
                 None => return false,
             };
-            match category {
-                ScriptThreadEventCategory::PerformanceTimelineTask => return true,
+            match task_source {
+                TaskSourceName::PerformanceTimeline => return true,
                 _ => {
                     // A task that will not be throttled, start counting "business"
                     self.taken_task_counter.set(self.taken_task_counter.get() + 1);
@@ -81,20 +87,15 @@ impl<T: QueuedTaskConversion> TaskQueue<T> {
 
         for msg in to_be_throttled {
             // Categorize tasks per task queue.
-            let (worker, category, boxed, pipeline_id) = match msg.into_queued_task() {
-                Some((worker, category, boxed, pipeline_id)) => (worker, category, boxed, pipeline_id),
+            let (worker, category, boxed, pipeline_id, task_source) = match msg.into_queued_task() {
+                Some(queued_task) => queued_task,
                 None => unreachable!("A message to be throttled should always be convertible into a queued task"),
             };
-            // FIXME: Add the task-source name directly to CommonScriptMsg::Task.
-            let task_source = match category {
-                ScriptThreadEventCategory::PerformanceTimelineTask => TaskSourceName::PerformanceTimeline,
-                _ => unreachable!(),
-            };
             let mut throttled_tasks = self.throttled.borrow_mut();
             throttled_tasks
-                .entry(task_source)
+                .entry(task_source.clone())
                 .or_insert(VecDeque::new())
-                .push_back((worker, category, boxed, pipeline_id));
+                .push_back((worker, category, boxed, pipeline_id, task_source));
         }
     }
 

components/script/task_source/dom_manipulation.rs

@@ -40,7 +40,8 @@ impl TaskSource for DOMManipulationTaskSource {
         let msg = MainThreadScriptMsg::Common(CommonScriptMsg::Task(
             ScriptThreadEventCategory::ScriptEvent,
             Box::new(canceller.wrap_task(task)),
-            Some(self.1)
+            Some(self.1),
+            DOMManipulationTaskSource::NAME,
         ));
         self.0.send(msg).map_err(|_| ())
     }

components/script/task_source/file_reading.rs

@@ -34,6 +34,7 @@ impl TaskSource for FileReadingTaskSource {
             ScriptThreadEventCategory::FileRead,
             Box::new(canceller.wrap_task(task)),
             Some(self.1),
+            FileReadingTaskSource::NAME,
         ))
     }
 }

components/script/task_source/mod.rs

@@ -20,7 +20,7 @@ use task::{TaskCanceller, TaskOnce};
 // Note: When adding a task source, update this enum.
 // Note: The HistoryTraversalTaskSource is not part of this,
 // because it doesn't implement TaskSource.
-#[derive(Eq, Hash, IntoEnumIterator, JSTraceable, PartialEq)]
+#[derive(Clone, Eq, Hash, IntoEnumIterator, JSTraceable, PartialEq)]
 pub enum TaskSourceName {
     DOMManipulation,
     FileReading,

components/script/task_source/networking.rs

@@ -31,6 +31,7 @@ impl TaskSource for NetworkingTaskSource {
             ScriptThreadEventCategory::NetworkEvent,
             Box::new(canceller.wrap_task(task)),
             Some(self.1),
+            NetworkingTaskSource::NAME,
         ))
     }
 }
@@ -46,6 +47,7 @@ impl NetworkingTaskSource {
             ScriptThreadEventCategory::NetworkEvent,
             Box::new(task),
             Some(self.1),
+            NetworkingTaskSource::NAME,
         ))
     }
 }

components/script/task_source/performance_timeline.rs

@@ -44,7 +44,8 @@ impl TaskSource for PerformanceTimelineTaskSource {
         let msg = CommonScriptMsg::Task(
             ScriptThreadEventCategory::PerformanceTimelineTask,
             Box::new(canceller.wrap_task(task)),
-            Some(self.1)
+            Some(self.1),
+            PerformanceTimelineTaskSource::NAME,
         );
         self.0.send(msg).map_err(|_| ())
     }

components/script/task_source/remote_event.rs

@@ -31,6 +31,7 @@ impl TaskSource for RemoteEventTaskSource {
             ScriptThreadEventCategory::NetworkEvent,
             Box::new(canceller.wrap_task(task)),
             Some(self.1),
+            RemoteEventTaskSource::NAME,
         ))
     }
 }

components/script/task_source/user_interaction.rs

@@ -40,7 +40,8 @@ impl TaskSource for UserInteractionTaskSource {
         let msg = MainThreadScriptMsg::Common(CommonScriptMsg::Task(
             ScriptThreadEventCategory::InputEvent,
             Box::new(canceller.wrap_task(task)),
-            Some(self.1)
+            Some(self.1),
+            UserInteractionTaskSource::NAME,
         ));
         self.0.send(msg).map_err(|_| ())
     }