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

script/dom/globalscope/
messageport.rs
