1use std::cell::Cell;
6use std::sync::Arc;
7use std::sync::atomic::{AtomicBool, Ordering};
8
9use constellation_traits::{StructuredSerializedData, WorkerScriptLoadOrigin};
10use crossbeam_channel::{Sender, unbounded};
11use devtools_traits::{DevtoolsPageInfo, ScriptToDevtoolsControlMsg, WorkerId};
12use dom_struct::dom_struct;
13use ipc_channel::ipc;
14use js::jsapi::{Heap, JSObject};
15use js::jsval::UndefinedValue;
16use js::rust::{CustomAutoRooter, CustomAutoRooterGuard, HandleObject, HandleValue};
17use net_traits::request::Referrer;
18use uuid::Uuid;
19
20use crate::dom::abstractworker::{SimpleWorkerErrorHandler, WorkerScriptMsg};
21use crate::dom::bindings::cell::DomRefCell;
22use crate::dom::bindings::codegen::Bindings::MessagePortBinding::StructuredSerializeOptions;
23use crate::dom::bindings::codegen::Bindings::WorkerBinding::{WorkerMethods, WorkerOptions};
24use crate::dom::bindings::codegen::UnionTypes::TrustedScriptURLOrUSVString;
25use crate::dom::bindings::error::{Error, ErrorResult, Fallible};
26use crate::dom::bindings::inheritance::Castable;
27use crate::dom::bindings::refcounted::Trusted;
28use crate::dom::bindings::reflector::{DomGlobal, reflect_dom_object_with_proto};
29use crate::dom::bindings::root::DomRoot;
30use crate::dom::bindings::structuredclone;
31use crate::dom::bindings::trace::{CustomTraceable, RootedTraceableBox};
32use crate::dom::dedicatedworkerglobalscope::{
33 DedicatedWorkerGlobalScope, DedicatedWorkerScriptMsg,
34};
35use crate::dom::eventtarget::EventTarget;
36use crate::dom::globalscope::GlobalScope;
37use crate::dom::messageevent::MessageEvent;
38use crate::dom::trustedscripturl::TrustedScriptURL;
39use crate::dom::window::Window;
40use crate::dom::workerglobalscope::prepare_workerscope_init;
41use crate::realms::enter_realm;
42use crate::script_runtime::{CanGc, JSContext, ThreadSafeJSContext};
43use crate::task::TaskOnce;
44
45pub(crate) type TrustedWorkerAddress = Trusted<Worker>;
46
47#[dom_struct]
49pub(crate) struct Worker {
50 eventtarget: EventTarget,
51 sender: Sender<DedicatedWorkerScriptMsg>,
54 #[ignore_malloc_size_of = "Arc"]
55 closing: Arc<AtomicBool>,
56 terminated: Cell<bool>,
57 #[ignore_malloc_size_of = "Arc"]
58 #[no_trace]
59 context_for_interrupt: DomRefCell<Option<ThreadSafeJSContext>>,
60}
61
62impl Worker {
63 fn new_inherited(sender: Sender<DedicatedWorkerScriptMsg>, closing: Arc<AtomicBool>) -> Worker {
64 Worker {
65 eventtarget: EventTarget::new_inherited(),
66 sender,
67 closing,
68 terminated: Cell::new(false),
69 context_for_interrupt: Default::default(),
70 }
71 }
72
73 fn new(
74 global: &GlobalScope,
75 proto: Option<HandleObject>,
76 sender: Sender<DedicatedWorkerScriptMsg>,
77 closing: Arc<AtomicBool>,
78 can_gc: CanGc,
79 ) -> DomRoot<Worker> {
80 reflect_dom_object_with_proto(
81 Box::new(Worker::new_inherited(sender, closing)),
82 global,
83 proto,
84 can_gc,
85 )
86 }
87
88 pub(crate) fn is_terminated(&self) -> bool {
89 self.terminated.get()
90 }
91
92 pub(crate) fn set_context_for_interrupt(&self, cx: ThreadSafeJSContext) {
93 assert!(
94 self.context_for_interrupt.borrow().is_none(),
95 "Context for interrupt must be set only once"
96 );
97 *self.context_for_interrupt.borrow_mut() = Some(cx);
98 }
99
100 pub(crate) fn handle_message(
101 address: TrustedWorkerAddress,
102 data: StructuredSerializedData,
103 can_gc: CanGc,
104 ) {
105 let worker = address.root();
106
107 if worker.is_terminated() {
108 return;
109 }
110
111 let global = worker.global();
112 let target = worker.upcast();
113 let _ac = enter_realm(target);
114 rooted!(in(*GlobalScope::get_cx()) let mut message = UndefinedValue());
115 if let Ok(ports) = structuredclone::read(&global, data, message.handle_mut()) {
116 MessageEvent::dispatch_jsval(
117 target,
118 &global,
119 message.handle(),
120 None,
121 None,
122 ports,
123 can_gc,
124 );
125 } else {
126 MessageEvent::dispatch_error(target, &global, can_gc);
128 }
129 }
130
131 pub(crate) fn dispatch_simple_error(address: TrustedWorkerAddress, can_gc: CanGc) {
132 let worker = address.root();
133 worker.upcast().fire_event(atom!("error"), can_gc);
134 }
135
136 fn post_message_impl(
138 &self,
139 cx: JSContext,
140 message: HandleValue,
141 transfer: CustomAutoRooterGuard<Vec<*mut JSObject>>,
142 ) -> ErrorResult {
143 let data = structuredclone::write(cx, message, Some(transfer))?;
144 let address = Trusted::new(self);
145
146 let _ = self.sender.send(DedicatedWorkerScriptMsg::CommonWorker(
149 address,
150 WorkerScriptMsg::DOMMessage {
151 origin: self.global().origin().immutable().clone(),
152 data: Box::new(data),
153 },
154 ));
155 Ok(())
156 }
157}
158
159impl WorkerMethods<crate::DomTypeHolder> for Worker {
160 #[allow(unsafe_code)]
162 fn Constructor(
163 global: &GlobalScope,
164 proto: Option<HandleObject>,
165 can_gc: CanGc,
166 script_url: TrustedScriptURLOrUSVString,
167 worker_options: &WorkerOptions,
168 ) -> Fallible<DomRoot<Worker>> {
169 let compliant_script_url = TrustedScriptURL::get_trusted_script_url_compliant_string(
173 global,
174 script_url,
175 "Worker",
176 "constructor",
177 can_gc,
178 )?;
179 let worker_url = match global.api_base_url().join(&compliant_script_url) {
181 Ok(url) => url,
182 Err(_) => return Err(Error::Syntax),
183 };
184
185 let (sender, receiver) = unbounded();
186 let closing = Arc::new(AtomicBool::new(false));
187 let worker = Worker::new(global, proto, sender.clone(), closing.clone(), can_gc);
188 let worker_ref = Trusted::new(&*worker);
189
190 let worker_load_origin = WorkerScriptLoadOrigin {
191 referrer_url: match global.get_referrer() {
192 Referrer::Client(url) => Some(url),
193 Referrer::ReferrerUrl(url) => Some(url),
194 _ => None,
195 },
196 referrer_policy: global.get_referrer_policy(),
197 pipeline_id: global.pipeline_id(),
198 };
199
200 let webview_id = global.webview_id().expect("global must have a webview id");
201
202 let browsing_context = global
203 .downcast::<Window>()
204 .map(|w| w.window_proxy().browsing_context_id())
205 .or_else(|| {
206 global
207 .downcast::<DedicatedWorkerGlobalScope>()
208 .and_then(|w| w.browsing_context())
209 });
210
211 let (devtools_sender, devtools_receiver) = ipc::channel().unwrap();
212 let worker_id = WorkerId(Uuid::new_v4());
213 if let Some(chan) = global.devtools_chan() {
214 let pipeline_id = global.pipeline_id();
215 let title = format!("Worker for {}", worker_url);
216 if let Some(browsing_context) = browsing_context {
217 let page_info = DevtoolsPageInfo {
218 title,
219 url: worker_url.clone(),
220 is_top_level_global: false,
221 };
222 let _ = chan.send(ScriptToDevtoolsControlMsg::NewGlobal(
223 (browsing_context, pipeline_id, Some(worker_id), webview_id),
224 devtools_sender.clone(),
225 page_info,
226 ));
227 }
228 }
229
230 let init = prepare_workerscope_init(global, Some(devtools_sender), Some(worker_id));
231
232 let (control_sender, control_receiver) = unbounded();
233 let (context_sender, context_receiver) = unbounded();
234
235 let event_loop_sender = global
236 .event_loop_sender()
237 .expect("Tried to create a worker in a worker while not handling a message?");
238 let join_handle = DedicatedWorkerGlobalScope::run_worker_scope(
239 init,
240 worker_url,
241 devtools_receiver,
242 worker_ref,
243 event_loop_sender,
244 sender,
245 receiver,
246 worker_load_origin,
247 String::from(&*worker_options.name),
248 worker_options.type_,
249 closing.clone(),
250 global.image_cache(),
251 browsing_context,
252 #[cfg(feature = "webgpu")]
253 global.wgpu_id_hub(),
254 control_receiver,
255 context_sender,
256 global.insecure_requests_policy(),
257 global.policy_container(),
258 global.font_context().cloned(),
259 );
260
261 let context = context_receiver
262 .recv()
263 .expect("Couldn't receive a context for worker.");
264
265 worker.set_context_for_interrupt(context.clone());
266 global.track_worker(closing, join_handle, control_sender, context);
267
268 Ok(worker)
269 }
270
271 fn PostMessage(
273 &self,
274 cx: JSContext,
275 message: HandleValue,
276 transfer: CustomAutoRooterGuard<Vec<*mut JSObject>>,
277 ) -> ErrorResult {
278 self.post_message_impl(cx, message, transfer)
279 }
280
281 fn PostMessage_(
283 &self,
284 cx: JSContext,
285 message: HandleValue,
286 options: RootedTraceableBox<StructuredSerializeOptions>,
287 ) -> ErrorResult {
288 let mut rooted = CustomAutoRooter::new(
289 options
290 .transfer
291 .iter()
292 .map(|js: &RootedTraceableBox<Heap<*mut JSObject>>| js.get())
293 .collect(),
294 );
295 let guard = CustomAutoRooterGuard::new(*cx, &mut rooted);
296 self.post_message_impl(cx, message, guard)
297 }
298
299 fn Terminate(&self) {
301 if self.closing.swap(true, Ordering::SeqCst) {
303 return;
304 }
305
306 self.terminated.set(true);
308
309 if let Some(cx) = self.context_for_interrupt.borrow().as_ref() {
311 cx.request_interrupt_callback()
312 }
313 }
314
315 event_handler!(message, GetOnmessage, SetOnmessage);
317
318 event_handler!(messageerror, GetOnmessageerror, SetOnmessageerror);
320
321 event_handler!(error, GetOnerror, SetOnerror);
323}
324
325impl TaskOnce for SimpleWorkerErrorHandler<Worker> {
326 #[cfg_attr(crown, allow(crown::unrooted_must_root))]
327 fn run_once(self) {
328 Worker::dispatch_simple_error(self.addr, CanGc::note());
329 }
330}