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

script/dom/
messageport.rs
