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

script/dom/globalscope/
messageport.rs
