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
202                .clone()
203                .to_jsval(cx, &self.global(), rooted_error.handle_mut());
204            self.cross_realm_transform_send_error(cx, rooted_error.handle());
205        }
206
207        result
208    }
209
210    /// <https://streams.spec.whatwg.org/#abstract-opdef-packandpostmessage>
211    #[expect(unsafe_code)]
212    pub(crate) fn pack_and_post_message(
213        &self,
214        cx: &mut JSContext,
215        type_: &str,
216        value: HandleValue,
217    ) -> ErrorResult {
218        // Let message be OrdinaryObjectCreate(null).
219        rooted!(&in(cx) let mut message = unsafe { JS_NewObject(cx, ptr::null()) });
220        rooted!(&in(cx) let mut type_string = UndefinedValue());
221        type_.safe_to_jsval(cx.into(), type_string.handle_mut(), CanGc::from_cx(cx));
222
223        // Perform ! CreateDataProperty(message, "type", type).
224        set_dictionary_property(cx.into(), message.handle(), c"type", type_string.handle())
225            .expect("Setting the message type should not fail.");
226
227        // Perform ! CreateDataProperty(message, "value", value).
228        set_dictionary_property(cx.into(), message.handle(), c"value", value)
229            .expect("Setting the message value should not fail.");
230
231        // Let targetPort be the port with which port is entangled, if any; otherwise let it be null.
232        // Done in `global.post_messageport_msg`.
233
234        // Let options be «[ "transfer" → « » ]».
235        let mut rooted = CustomAutoRooter::new(vec![]);
236        let transfer = unsafe { CustomAutoRooterGuard::new(cx.raw_cx(), &mut rooted) };
237
238        // Run the message port post message steps providing targetPort, message, and options.
239        rooted!(&in(cx) let mut message_val = UndefinedValue());
240        message.safe_to_jsval(cx.into(), message_val.handle_mut(), CanGc::from_cx(cx));
241        self.post_message_impl(cx, message_val.handle(), transfer)
242    }
243}
244
245impl Transferable for MessagePort {
246    type Index = MessagePortIndex;
247    type Data = MessagePortImpl;
248
249    /// <https://html.spec.whatwg.org/multipage/#message-ports:transfer-steps>
250    fn transfer(
251        &self,
252        _cx: &mut js::context::JSContext,
253    ) -> Fallible<(MessagePortId, MessagePortImpl)> {
254        // <https://html.spec.whatwg.org/multipage/#structuredserializewithtransfer>
255        // Step 5.2. If transferable has a [[Detached]] internal slot and
256        // transferable.[[Detached]] is true, then throw a "DataCloneError"
257        // DOMException.
258        if self.detached.get() {
259            return Err(Error::DataClone(None));
260        }
261
262        self.detached.set(true);
263        let id = self.message_port_id();
264
265        // 1. Run local transfer logic, and return the object to be transferred.
266        let transferred_port = self.global().mark_port_as_transferred(id);
267
268        Ok((*id, transferred_port))
269    }
270
271    /// <https://html.spec.whatwg.org/multipage/#message-ports:transfer-receiving-steps>
272    fn transfer_receive(
273        cx: &mut js::context::JSContext,
274        owner: &GlobalScope,
275        id: MessagePortId,
276        port_impl: MessagePortImpl,
277    ) -> Result<DomRoot<Self>, ()> {
278        let transferred_port = MessagePort::new_transferred(
279            owner,
280            id,
281            port_impl.entangled_port_id(),
282            CanGc::from_cx(cx),
283        );
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: RootedTraceableBox<StructuredSerializeOptions>,
318    ) -> ErrorResult {
319        if self.detached.get() {
320            return Ok(());
321        }
322        let mut rooted = CustomAutoRooter::new(
323            options
324                .transfer
325                .iter()
326                .map(|js: &RootedTraceableBox<Heap<*mut JSObject>>| js.get())
327                .collect(),
328        );
329        #[expect(unsafe_code)]
330        let guard = unsafe { CustomAutoRooterGuard::new(cx.raw_cx(), &mut rooted) };
331        self.post_message_impl(cx, message, guard)
332    }
333
334    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-start>
335    fn Start(&self, cx: &mut JSContext) {
336        if self.detached.get() {
337            return;
338        }
339        self.global().start_message_port(cx, self.message_port_id());
340    }
341
342    /// <https://html.spec.whatwg.org/multipage/#dom-messageport-close>
343    fn Close(&self, cx: &mut JSContext) {
344        // Set this's [[Detached]] internal slot value to true.
345        self.detached.set(true);
346
347        let global = self.global();
348        global.close_message_port(self.message_port_id());
349
350        // If this is entangled, disentangle it.
351        global.disentangle_port(cx, self);
352    }
353
354    /// <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessage>
355    fn GetOnmessage(&self, cx: &mut JSContext) -> Option<Rc<EventHandlerNonNull>> {
356        if self.detached.get() {
357            return None;
358        }
359        let eventtarget = self.upcast::<EventTarget>();
360        eventtarget.get_event_handler_common(cx, "message")
361    }
362
363    /// <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessage>
364    fn SetOnmessage(&self, cx: &mut JSContext, listener: Option<Rc<EventHandlerNonNull>>) {
365        if self.detached.get() {
366            return;
367        }
368        self.set_onmessage(cx, listener);
369        // Note: we cannot use the event_handler macro, due to the need to start the port.
370        self.global().start_message_port(cx, self.message_port_id());
371    }
372
373    // <https://html.spec.whatwg.org/multipage/#handler-messageport-onmessageerror>
374    event_handler!(messageerror, GetOnmessageerror, SetOnmessageerror);
375
376    // <https://html.spec.whatwg.org/multipage/#handler-messageport-onclose>
377    event_handler!(close, GetOnclose, SetOnclose);
378}
script/dom/messageport.rs

script/dom/
messageport.rs
