1use std::fmt;
6
7use base::id::PipelineId;
8use malloc_size_of_derive::MallocSizeOf;
9use strum_macros::VariantArray;
10use stylo_atoms::Atom;
11
12use crate::dom::bindings::refcounted::Trusted;
13use crate::dom::event::{EventBubbles, EventCancelable, EventTask, SimpleEventTask};
14use crate::dom::eventtarget::EventTarget;
15use crate::messaging::{CommonScriptMsg, ScriptEventLoopSender};
16use crate::script_runtime::ScriptThreadEventCategory;
17use crate::task::{TaskCanceller, TaskOnce};
18use crate::task_manager::TaskManager;
19
20#[derive(Clone, Copy, Debug, Eq, Hash, JSTraceable, MallocSizeOf, PartialEq, VariantArray)]
24pub(crate) enum TaskSourceName {
25 Bitmap,
27 Canvas,
28 Clipboard,
29 DatabaseAccess,
30 DOMManipulation,
31 FileReading,
32 FontLoading,
34 HistoryTraversal,
35 Networking,
36 PerformanceTimeline,
37 PortMessage,
38 UserInteraction,
39 RemoteEvent,
40 Rendering,
42 MediaElement,
43 WebSocket,
44 Timer,
45 Gamepad,
47 IntersectionObserver,
49 WebGPU,
51}
52
53impl From<TaskSourceName> for ScriptThreadEventCategory {
54 fn from(value: TaskSourceName) -> Self {
55 match value {
56 TaskSourceName::Bitmap => ScriptThreadEventCategory::ScriptEvent,
57 TaskSourceName::Canvas => ScriptThreadEventCategory::ScriptEvent,
58 TaskSourceName::Clipboard => ScriptThreadEventCategory::ScriptEvent,
59 TaskSourceName::DatabaseAccess => ScriptThreadEventCategory::ScriptEvent,
60 TaskSourceName::DOMManipulation => ScriptThreadEventCategory::ScriptEvent,
61 TaskSourceName::FileReading => ScriptThreadEventCategory::FileRead,
62 TaskSourceName::FontLoading => ScriptThreadEventCategory::FontLoading,
63 TaskSourceName::HistoryTraversal => ScriptThreadEventCategory::HistoryEvent,
64 TaskSourceName::Networking => ScriptThreadEventCategory::NetworkEvent,
65 TaskSourceName::PerformanceTimeline => {
66 ScriptThreadEventCategory::PerformanceTimelineTask
67 },
68 TaskSourceName::PortMessage => ScriptThreadEventCategory::PortMessage,
69 TaskSourceName::UserInteraction => ScriptThreadEventCategory::InputEvent,
70 TaskSourceName::RemoteEvent => ScriptThreadEventCategory::NetworkEvent,
71 TaskSourceName::Rendering => ScriptThreadEventCategory::Rendering,
72 TaskSourceName::MediaElement => ScriptThreadEventCategory::ScriptEvent,
73 TaskSourceName::WebSocket => ScriptThreadEventCategory::WebSocketEvent,
74 TaskSourceName::Timer => ScriptThreadEventCategory::TimerEvent,
75 TaskSourceName::Gamepad => ScriptThreadEventCategory::InputEvent,
76 TaskSourceName::IntersectionObserver => ScriptThreadEventCategory::ScriptEvent,
77 TaskSourceName::WebGPU => ScriptThreadEventCategory::ScriptEvent,
78 }
79 }
80}
81
82pub(crate) struct TaskSource<'task_manager> {
83 pub(crate) task_manager: &'task_manager TaskManager,
84 pub(crate) name: TaskSourceName,
85}
86
87impl TaskSource<'_> {
88 pub(crate) fn queue(&self, task: impl TaskOnce + 'static) {
90 let canceller = self.task_manager.canceller(self.name);
91 if canceller.cancelled() {
92 return;
93 }
94
95 self.queue_unconditionally(canceller.wrap_task(task))
96 }
97
98 pub(crate) fn queue_unconditionally(&self, task: impl TaskOnce + 'static) {
100 let sender = self.task_manager.sender();
101 sender
102 .as_ref()
103 .expect("Tried to enqueue task for DedicatedWorker while not handling a message.")
104 .send(CommonScriptMsg::Task(
105 self.name.into(),
106 Box::new(task),
107 Some(self.task_manager.pipeline_id()),
108 self.name,
109 ))
110 .expect("Tried to send a task on a task queue after shutdown.");
111 }
112
113 pub(crate) fn queue_simple_event(&self, target: &EventTarget, name: Atom) {
114 let target = Trusted::new(target);
115 self.queue(SimpleEventTask { target, name });
116 }
117
118 pub(crate) fn queue_event(
119 &self,
120 target: &EventTarget,
121 name: Atom,
122 bubbles: EventBubbles,
123 cancelable: EventCancelable,
124 ) {
125 let target = Trusted::new(target);
126 self.queue(EventTask {
127 target,
128 name,
129 bubbles,
130 cancelable,
131 });
132 }
133
134 pub(crate) fn to_sendable(&self) -> SendableTaskSource {
137 let sender = self.task_manager.sender();
138 let sender = sender
139 .as_ref()
140 .expect("Tried to enqueue task for DedicatedWorker while not handling a message.")
141 .clone();
142 SendableTaskSource {
143 sender,
144 pipeline_id: self.task_manager.pipeline_id(),
145 name: self.name,
146 canceller: self.task_manager.canceller(self.name),
147 }
148 }
149}
150
151impl<'task_manager> From<TaskSource<'task_manager>> for SendableTaskSource {
152 fn from(task_source: TaskSource<'task_manager>) -> Self {
153 task_source.to_sendable()
154 }
155}
156
157#[derive(JSTraceable, MallocSizeOf)]
158pub(crate) struct SendableTaskSource {
159 pub(crate) sender: ScriptEventLoopSender,
160 #[no_trace]
161 pub(crate) pipeline_id: PipelineId,
162 pub(crate) name: TaskSourceName,
163 pub(crate) canceller: TaskCanceller,
164}
165
166impl SendableTaskSource {
167 pub(crate) fn queue(&self, task: impl TaskOnce + 'static) {
168 if !self.canceller.cancelled() {
169 self.queue_unconditionally(self.canceller.wrap_task(task))
170 }
171 }
172
173 pub(crate) fn queue_unconditionally(&self, task: impl TaskOnce + 'static) {
175 if self
176 .sender
177 .send(CommonScriptMsg::Task(
178 self.name.into(),
179 Box::new(task),
180 Some(self.pipeline_id),
181 self.name,
182 ))
183 .is_err()
184 {
185 warn!(
186 "Could not queue non-main-thread task {:?}. Likely tried to queue during shutdown.",
187 self.name
188 );
189 }
190 }
191}
192
193impl Clone for SendableTaskSource {
194 fn clone(&self) -> Self {
195 Self {
196 sender: self.sender.clone(),
197 pipeline_id: self.pipeline_id,
198 name: self.name,
199 canceller: self.canceller.clone(),
200 }
201 }
202}
203
204impl fmt::Debug for SendableTaskSource {
205 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
206 write!(f, "{:?}(...)", self.name)
207 }
208}