script/dom/globalscope/
messageport.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 http://mozilla.org/MPL/2.0/. */
4
5use std::cell::{Cell, RefCell};
6use std::ptr;
7use std::rc::Rc;
8
9use dom_struct::dom_struct;
10use js::context::JSContext;
11use js::conversions::ToJSValConvertible;
12use js::jsapi::{Heap, JSObject};
13use js::jsval::UndefinedValue;
14use js::rust::wrappers2::JS_NewObject;
15use js::rust::{CustomAutoRooterGuard, HandleValue};
16use rustc_hash::FxHashMap;
17use script_bindings::callback::RootedCallback;
18use script_bindings::reflector::reflect_weak_referenceable_dom_object;
19use script_bindings::structuredclone::StructuredData;
20use servo_base::id::{MessagePortId, MessagePortIndex};
21use servo_constellation_traits::{MessagePortImpl, PortMessageTask};
22
23use crate::dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
24use crate::dom::bindings::codegen::Bindings::MessagePortBinding::{
25    MessagePortMethods, StructuredSerializeOptions,
26};
27use crate::dom::bindings::conversions::root_from_object;
28use crate::dom::bindings::error::{Error, ErrorResult, ErrorToJsval, Fallible};
29use crate::dom::bindings::inheritance::Castable;
30use crate::dom::bindings::reflector::DomGlobal;
31use crate::dom::bindings::root::DomRoot;
32use crate::dom::bindings::structuredclone;
33use crate::dom::bindings::trace::RootedTraceableBox;
34use crate::dom::bindings::transferable::Transferable;
35use crate::dom::bindings::utils::set_dictionary_property;
36use crate::dom::eventtarget::EventTarget;
37use crate::dom::globalscope::GlobalScope;
38
39#[dom_struct]
40/// The MessagePort used in the DOM.
41pub(crate) struct MessagePort {
42    eventtarget: EventTarget,
43    #[no_trace]
44    message_port_id: MessagePortId,
45    #[no_trace]
46    entangled_port: RefCell<Option<MessagePortId>>,
47    detached: Cell<bool>,
48}
49
50impl MessagePort {
51    fn new_inherited(message_port_id: MessagePortId) -> MessagePort {
52        MessagePort {
53            eventtarget: EventTarget::new_inherited(),
54            entangled_port: RefCell::new(None),
55            detached: Cell::new(false),
56            message_port_id,
57        }
58    }
59
60    /// <https://html.spec.whatwg.org/multipage/#create-a-new-messageport-object>
61    pub(crate) fn new(cx: &mut JSContext, owner: &GlobalScope) -> DomRoot<MessagePort> {
62        let port_id = MessagePortId::new();
63        reflect_weak_referenceable_dom_object(
64            cx,
65            Rc::new(MessagePort::new_inherited(port_id)),
66            owner,
67        )
68    }
69
70    /// Create a new port for an incoming transfer-received one.
71    pub(crate) fn new_transferred(
72        cx: &mut JSContext,
73        owner: &GlobalScope,
74        transferred_port: MessagePortId,
75        entangled_port: Option<MessagePortId>,
76    ) -> DomRoot<MessagePort> {
77        reflect_weak_referenceable_dom_object(
78            cx,
79            Rc::new(MessagePort {
80                message_port_id: transferred_port,
81                eventtarget: EventTarget::new_inherited(),
82                detached: Cell::new(false),
83                entangled_port: RefCell::new(entangled_port),
84            }),
85            owner,
86        )
87    }
88
89    /// <https://html.spec.whatwg.org/multipage/#entangle>
90    pub(crate) fn entangle(&self, other_id: MessagePortId) {
91        *self.entangled_port.borrow_mut() = Some(other_id);
92    }
93
94    /// <https://html.spec.whatwg.org/multipage/#disentangle>
95    pub(crate) fn disentangle(&self) -> Option<MessagePortId> {
96        // Disentangle initiatorPort and otherPort, so that they are no longer entangled or associated with each other.
97        // Note: called from `disentangle_port` in the global, where the rest happens.
98        self.entangled_port.borrow_mut().take()
99    }
100
101    /// Has the port been disentangled?
102    /// Used when starting the port to fire the `close` event,
103    /// to cover the case of a disentanglement while in transfer.
104    pub(crate) fn disentangled(&self) -> bool {
105        self.entangled_port.borrow().is_none()
106    }
107
108    pub(crate) fn message_port_id(&self) -> &MessagePortId {
109        &self.message_port_id
110    }
111
112    /// <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessage>
113    fn set_onmessage(
114        &self,
115        cx: &mut JSContext,
116        listener: Option<RootedCallback<EventHandlerNonNull>>,
117    ) {
118        let eventtarget = self.upcast::<EventTarget>();
119        eventtarget.set_event_handler_common(cx, "message", listener);
120    }
121
122    /// <https://html.spec.whatwg.org/multipage/#message-port-post-message-steps>
123    #[expect(unsafe_code)]
124    fn post_message_impl(
125        &self,
126        cx: &mut JSContext,
127        message: HandleValue,
128        transfer: CustomAutoRooterGuard<Vec<*mut JSObject>>,
129    ) -> ErrorResult {
130        if self.detached.get() {
131            return Ok(());
132        }
133
134        // Step 1 is the transfer argument.
135
136        let target_port = self.entangled_port.borrow();
137
138        // Step 3
139        let mut doomed = false;
140
141        let ports = transfer
142            .iter()
143            .filter_map(|&obj| unsafe { root_from_object::<MessagePort>(cx, obj).ok() });
144        for port in ports {
145            // Step 2
146            if port.message_port_id() == self.message_port_id() {
147                return Err(Error::DataClone(None));
148            }
149
150            // Step 4
151            if let Some(target_id) = target_port.as_ref() &&
152                port.message_port_id() == target_id
153            {
154                doomed = true;
155            }
156        }
157
158        // Step 5
159        let data = structuredclone::write(cx, message, Some(transfer))?;
160
161        if doomed {
162            // TODO: The spec says to optionally report such a case to a dev console.
163            return Ok(());
164        }
165
166        // Step 6, done in MessagePortImpl.
167
168        let incumbent = match GlobalScope::incumbent() {
169            None => unreachable!("postMessage called with no incumbent global"),
170            Some(incumbent) => incumbent,
171        };
172
173        // Step 7
174        let task = PortMessageTask {
175            origin: incumbent.origin().immutable().clone(),
176            data,
177        };
178
179        // Have the global proxy this call to the corresponding MessagePortImpl.
180        self.global()
181            .post_messageport_msg(*self.message_port_id(), task);
182        Ok(())
183    }
184
185    /// <https://streams.spec.whatwg.org/#abstract-opdef-crossrealmtransformsenderror>
186    pub(crate) fn cross_realm_transform_send_error(&self, cx: &mut JSContext, error: HandleValue) {
187        // Perform PackAndPostMessage(port, "error", error),
188        // discarding the result.
189        let _ = self.pack_and_post_message(cx, "error", error);
190    }
191
192    /// <https://streams.spec.whatwg.org/#abstract-opdef-packandpostmessagehandlingerror>
193    pub(crate) fn pack_and_post_message_handling_error(
194        &self,
195        cx: &mut JSContext,
196        type_: &str,
197        value: HandleValue,
198    ) -> ErrorResult {
199        // Let result be PackAndPostMessage(port, type, value).
200        let result = self.pack_and_post_message(cx, type_, value);
201
202        // If result is an abrupt completion,
203        if let Err(error) = result.as_ref() {
204            // Perform ! CrossRealmTransformSendError(port, result.[[Value]]).
205            rooted!(&in(cx) let mut rooted_error = UndefinedValue());
206            error
207                .clone()
208                .to_jsval(cx, &self.global(), rooted_error.handle_mut());
209            self.cross_realm_transform_send_error(cx, rooted_error.handle());
210        }
211
212        result
213    }
214
215    /// <https://streams.spec.whatwg.org/#abstract-opdef-packandpostmessage>
216    #[expect(unsafe_code)]
217    pub(crate) fn pack_and_post_message(
218        &self,
219        cx: &mut JSContext,
220        type_: &str,
221        value: HandleValue,
222    ) -> ErrorResult {
223        // Let message be OrdinaryObjectCreate(null).
224        rooted!(&in(cx) let mut message = unsafe { JS_NewObject(cx, ptr::null()) });
225        rooted!(&in(cx) let mut type_string = UndefinedValue());
226        type_.to_jsval(cx, type_string.handle_mut());
227
228        // Perform ! CreateDataProperty(message, "type", type).
229        set_dictionary_property(cx, message.handle(), c"type", type_string.handle())
230            .expect("Setting the message type should not fail.");
231
232        // Perform ! CreateDataProperty(message, "value", value).
233        set_dictionary_property(cx, message.handle(), c"value", value)
234            .expect("Setting the message value should not fail.");
235
236        // Let targetPort be the port with which port is entangled, if any; otherwise let it be null.
237        // Done in `global.post_messageport_msg`.
238
239        // Let options be «[ "transfer" → « » ]».
240        auto_root!(&in(cx) let transfer = Vec::<*mut JSObject>::new());
241
242        // Run the message port post message steps providing targetPort, message, and options.
243        rooted!(&in(cx) let mut message_val = UndefinedValue());
244        message.to_jsval(cx, message_val.handle_mut());
245        self.post_message_impl(cx, message_val.handle(), transfer)
246    }
247}
248
249impl Transferable for MessagePort {
250    type Index = MessagePortIndex;
251    type Data = MessagePortImpl;
252
253    /// <https://html.spec.whatwg.org/multipage/#message-ports:transfer-steps>
254    fn transfer(
255        &self,
256        _cx: &mut js::context::JSContext,
257    ) -> Fallible<(MessagePortId, MessagePortImpl)> {
258        // <https://html.spec.whatwg.org/multipage/#structuredserializewithtransfer>
259        // Step 5.2. If transferable has a [[Detached]] internal slot and
260        // transferable.[[Detached]] is true, then throw a "DataCloneError"
261        // DOMException.
262        if self.detached.get() {
263            return Err(Error::DataClone(None));
264        }
265
266        self.detached.set(true);
267        let id = self.message_port_id();
268
269        // 1. Run local transfer logic, and return the object to be transferred.
270        let transferred_port = self.global().mark_port_as_transferred(id);
271
272        Ok((*id, transferred_port))
273    }
274
275    /// <https://html.spec.whatwg.org/multipage/#message-ports:transfer-receiving-steps>
276    fn transfer_receive(
277        cx: &mut js::context::JSContext,
278        owner: &GlobalScope,
279        id: MessagePortId,
280        port_impl: MessagePortImpl,
281    ) -> Result<DomRoot<Self>, ()> {
282        let transferred_port =
283            MessagePort::new_transferred(cx, owner, id, port_impl.entangled_port_id());
284        owner.track_message_port(&transferred_port, Some(port_impl));
285        Ok(transferred_port)
286    }
287
288    fn serialized_storage<'a>(
289        data: StructuredData<'a, '_>,
290    ) -> &'a mut Option<FxHashMap<MessagePortId, Self::Data>> {
291        match data {
292            StructuredData::Reader(r) => &mut r.port_impls,
293            StructuredData::Writer(w) => &mut w.ports,
294        }
295    }
296}
297
298impl MessagePortMethods<crate::DomTypeHolder> for MessagePort {
299    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-postmessage>
300    fn PostMessage(
301        &self,
302        cx: &mut JSContext,
303        message: HandleValue,
304        transfer: CustomAutoRooterGuard<Vec<*mut JSObject>>,
305    ) -> ErrorResult {
306        if self.detached.get() {
307            return Ok(());
308        }
309        self.post_message_impl(cx, message, transfer)
310    }
311
312    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-postmessage>
313    fn PostMessage_(
314        &self,
315        cx: &mut JSContext,
316        message: HandleValue,
317        options: &StructuredSerializeOptions,
318    ) -> ErrorResult {
319        if self.detached.get() {
320            return Ok(());
321        }
322        auto_root!(&in(cx) let guard =
323            options
324                .transfer
325                .iter()
326                .map(|js: &RootedTraceableBox<Heap<*mut JSObject>>| js.get())
327                .collect::<Vec<_>>());
328        self.post_message_impl(cx, message, guard)
329    }
330
331    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-start>
332    fn Start(&self, cx: &mut JSContext) {
333        if self.detached.get() {
334            return;
335        }
336        self.global().start_message_port(cx, self.message_port_id());
337    }
338
339    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-close>
340    fn Close(&self, cx: &mut JSContext) {
341        // Set this's [[Detached]] internal slot value to true.
342        self.detached.set(true);
343
344        let global = self.global();
345        global.close_message_port(self.message_port_id());
346
347        // If this is entangled, disentangle it.
348        global.disentangle_port(cx, self);
349    }
350
351    /// <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessage>
352    fn GetOnmessage(&self, cx: &mut JSContext) -> Option<RootedCallback<EventHandlerNonNull>> {
353        if self.detached.get() {
354            return None;
355        }
356        let eventtarget = self.upcast::<EventTarget>();
357        eventtarget.get_event_handler_common(cx, "message")
358    }
359
360    /// <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessage>
361    fn SetOnmessage(
362        &self,
363        cx: &mut JSContext,
364        listener: Option<RootedCallback<EventHandlerNonNull>>,
365    ) {
366        if self.detached.get() {
367            return;
368        }
369        self.set_onmessage(cx, listener);
370        // Note: we cannot use the event_handler macro, due to the need to start the port.
371        self.global().start_message_port(cx, self.message_port_id());
372    }
373
374    // <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessageerror>
375    event_handler!(messageerror, GetOnmessageerror, SetOnmessageerror);
376
377    // <https://html.spec.whatwg.org/multipage/#handler-messageport-onclose>
378    event_handler!(close, GetOnclose, SetOnclose);
379}
script/dom/globalscope/messageport.rs

script/dom/globalscope/
messageport.rs
