script/dom/workers/
abstractworkerglobalscope.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use crossbeam_channel::{Receiver, select};
6use devtools_traits::DevtoolScriptControlMsg;
7use rustc_hash::FxHashSet;
8
9use crate::dom::bindings::conversions::DerivedFrom;
10use crate::dom::bindings::reflector::DomObject;
11use crate::dom::dedicatedworkerglobalscope::AutoWorkerReset;
12use crate::dom::globalscope::GlobalScope;
13use crate::dom::worker::TrustedWorkerAddress;
14use crate::dom::workerglobalscope::WorkerGlobalScope;
15use crate::realms::enter_realm;
16use crate::script_runtime::CanGc;
17use crate::task_queue::{QueuedTaskConversion, TaskQueue};
18
19pub(crate) trait WorkerEventLoopMethods {
20    type WorkerMsg: QueuedTaskConversion + Send;
21    type ControlMsg;
22    type Event;
23    fn task_queue(&self) -> &TaskQueue<Self::WorkerMsg>;
24    fn handle_event(&self, event: Self::Event, cx: &mut js::context::JSContext) -> bool;
25    fn handle_worker_post_event(
26        &self,
27        worker: &TrustedWorkerAddress,
28    ) -> Option<AutoWorkerReset<'_>>;
29    fn from_control_msg(msg: Self::ControlMsg) -> Self::Event;
30    fn from_worker_msg(msg: Self::WorkerMsg) -> Self::Event;
31    fn from_devtools_msg(msg: DevtoolScriptControlMsg) -> Self::Event;
32    fn from_timer_msg() -> Self::Event;
33    fn control_receiver(&self) -> &Receiver<Self::ControlMsg>;
34}
35
36// https://html.spec.whatwg.org/multipage/#worker-event-loop
37pub(crate) fn run_worker_event_loop<T, WorkerMsg, Event>(
38    worker_scope: &T,
39    worker: Option<&TrustedWorkerAddress>,
40    cx: &mut js::context::JSContext,
41) where
42    WorkerMsg: QueuedTaskConversion + Send,
43    T: WorkerEventLoopMethods<WorkerMsg = WorkerMsg, Event = Event>
44        + DerivedFrom<WorkerGlobalScope>
45        + DerivedFrom<GlobalScope>
46        + DomObject,
47{
48    let scope = worker_scope.upcast::<WorkerGlobalScope>();
49    let task_queue = worker_scope.task_queue();
50
51    let never = crossbeam_channel::never();
52    let devtools_receiver = scope.devtools_receiver().unwrap_or(&never);
53
54    let event = select! {
55        recv(worker_scope.control_receiver()) -> msg => T::from_control_msg(msg.unwrap()),
56        recv(task_queue.select()) -> msg => {
57            task_queue.take_tasks(msg.unwrap(), &FxHashSet::default());
58            T::from_worker_msg(task_queue.recv().unwrap())
59        },
60        // RoutedReceivers have two results
61        recv(devtools_receiver) -> msg => T::from_devtools_msg(msg.unwrap().unwrap()),
62        recv(scope.timer_scheduler().wait_channel()) -> _ => T::from_timer_msg(),
63    };
64
65    scope.timer_scheduler().dispatch_completed_timers();
66
67    let mut sequential = vec![event];
68
69    // https://html.spec.whatwg.org/multipage/#worker-event-loop
70    // Once the WorkerGlobalScope's closing flag is set to true,
71    // the event loop's task queues must discard any further tasks
72    // that would be added to them
73    // (tasks already on the queue are unaffected except where otherwise specified).
74    while !scope.is_closing() {
75        // Batch all events that are ready.
76        // The task queue will throttle non-priority tasks if necessary.
77        match task_queue.take_tasks_and_recv(&FxHashSet::default()) {
78            Err(_) => match devtools_receiver.try_recv() {
79                Ok(message) => sequential.push(T::from_devtools_msg(message.unwrap())),
80                Err(_) => break,
81            },
82            Ok(ev) => sequential.push(T::from_worker_msg(ev)),
83        }
84    }
85
86    // Step 3
87    for event in sequential {
88        let _realm = enter_realm(worker_scope);
89        if !worker_scope.handle_event(event, cx) {
90            // Shutdown
91            return;
92        }
93        // Step 6
94        let _ar = match worker {
95            Some(worker) => worker_scope.handle_worker_post_event(worker),
96            None => None,
97        };
98        scope.perform_a_microtask_checkpoint(CanGc::from_cx(cx));
99    }
100    worker_scope
101        .upcast::<GlobalScope>()
102        .perform_a_dom_garbage_collection_checkpoint();
103}