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

script/dom/
messageport.rs
