script/dom/event/
messageevent.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 https://mozilla.org/MPL/2.0/. */
4
5use dom_struct::dom_struct;
6use js::jsapi::Heap;
7use js::jsval::JSVal;
8use js::rust::{HandleObject, HandleValue, MutableHandleValue};
9use script_bindings::cell::DomRefCell;
10use script_bindings::reflector::reflect_dom_object_with_proto;
11use stylo_atoms::Atom;
12
13use crate::dom::bindings::codegen::Bindings::EventBinding::EventMethods;
14use crate::dom::bindings::codegen::Bindings::MessageEventBinding;
15use crate::dom::bindings::codegen::Bindings::MessageEventBinding::MessageEventMethods;
16use crate::dom::bindings::codegen::UnionTypes::WindowProxyOrMessagePortOrServiceWorker;
17use crate::dom::bindings::error::Fallible;
18use crate::dom::bindings::frozenarray::CachedFrozenArray;
19use crate::dom::bindings::inheritance::Castable;
20use crate::dom::bindings::root::{Dom, DomRoot};
21use crate::dom::bindings::str::DOMString;
22use crate::dom::bindings::trace::RootedTraceableBox;
23use crate::dom::event::Event;
24use crate::dom::eventtarget::EventTarget;
25use crate::dom::globalscope::GlobalScope;
26use crate::dom::messageport::MessagePort;
27use crate::dom::serviceworker::ServiceWorker;
28use crate::dom::windowproxy::WindowProxy;
29use crate::script_runtime::{CanGc, JSContext};
30
31#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
32#[derive(JSTraceable, MallocSizeOf)]
33enum SrcObject {
34    WindowProxy(Dom<WindowProxy>),
35    MessagePort(Dom<MessagePort>),
36    ServiceWorker(Dom<ServiceWorker>),
37}
38
39impl From<&WindowProxyOrMessagePortOrServiceWorker> for SrcObject {
40    fn from(src_object: &WindowProxyOrMessagePortOrServiceWorker) -> SrcObject {
41        match src_object {
42            WindowProxyOrMessagePortOrServiceWorker::WindowProxy(blob) => {
43                SrcObject::WindowProxy(Dom::from_ref(blob))
44            },
45            WindowProxyOrMessagePortOrServiceWorker::MessagePort(stream) => {
46                SrcObject::MessagePort(Dom::from_ref(stream))
47            },
48            WindowProxyOrMessagePortOrServiceWorker::ServiceWorker(stream) => {
49                SrcObject::ServiceWorker(Dom::from_ref(stream))
50            },
51        }
52    }
53}
54
55#[dom_struct]
56#[expect(non_snake_case)]
57pub(crate) struct MessageEvent {
58    event: Event,
59    #[ignore_malloc_size_of = "mozjs"]
60    data: Heap<JSVal>,
61    origin: DomRefCell<DOMString>,
62    source: DomRefCell<Option<SrcObject>>,
63    lastEventId: DomRefCell<DOMString>,
64    ports: DomRefCell<Vec<Dom<MessagePort>>>,
65    #[ignore_malloc_size_of = "mozjs"]
66    frozen_ports: CachedFrozenArray,
67}
68
69#[expect(non_snake_case)]
70impl MessageEvent {
71    pub(crate) fn new_inherited(
72        origin: DOMString,
73        source: Option<&WindowProxyOrMessagePortOrServiceWorker>,
74        lastEventId: DOMString,
75        ports: Vec<DomRoot<MessagePort>>,
76    ) -> MessageEvent {
77        MessageEvent {
78            event: Event::new_inherited(),
79            data: Heap::default(),
80            source: DomRefCell::new(source.map(|source| source.into())),
81            origin: DomRefCell::new(origin),
82            lastEventId: DomRefCell::new(lastEventId),
83            ports: DomRefCell::new(
84                ports
85                    .into_iter()
86                    .map(|port| Dom::from_ref(&*port))
87                    .collect(),
88            ),
89            frozen_ports: CachedFrozenArray::new(),
90        }
91    }
92
93    pub(crate) fn new_uninitialized(global: &GlobalScope, can_gc: CanGc) -> DomRoot<MessageEvent> {
94        Self::new_uninitialized_with_proto(global, None, can_gc)
95    }
96
97    fn new_uninitialized_with_proto(
98        global: &GlobalScope,
99        proto: Option<HandleObject>,
100        can_gc: CanGc,
101    ) -> DomRoot<MessageEvent> {
102        MessageEvent::new_initialized(
103            global,
104            proto,
105            HandleValue::undefined(),
106            DOMString::new(),
107            None,
108            DOMString::new(),
109            vec![],
110            can_gc,
111        )
112    }
113
114    #[allow(clippy::too_many_arguments)]
115    fn new_initialized(
116        global: &GlobalScope,
117        proto: Option<HandleObject>,
118        data: HandleValue,
119        origin: DOMString,
120        source: Option<&WindowProxyOrMessagePortOrServiceWorker>,
121        lastEventId: DOMString,
122        ports: Vec<DomRoot<MessagePort>>,
123        can_gc: CanGc,
124    ) -> DomRoot<MessageEvent> {
125        let ev = Box::new(MessageEvent::new_inherited(
126            origin,
127            source,
128            lastEventId,
129            ports,
130        ));
131        let ev = reflect_dom_object_with_proto(ev, global, proto, can_gc);
132        ev.data.set(data.get());
133
134        ev
135    }
136
137    #[allow(clippy::too_many_arguments)]
138    pub(crate) fn new(
139        global: &GlobalScope,
140        type_: Atom,
141        bubbles: bool,
142        cancelable: bool,
143        data: HandleValue,
144        origin: DOMString,
145        source: Option<&WindowProxyOrMessagePortOrServiceWorker>,
146        lastEventId: DOMString,
147        ports: Vec<DomRoot<MessagePort>>,
148        can_gc: CanGc,
149    ) -> DomRoot<MessageEvent> {
150        Self::new_with_proto(
151            global,
152            None,
153            type_,
154            bubbles,
155            cancelable,
156            data,
157            origin,
158            source,
159            lastEventId,
160            ports,
161            can_gc,
162        )
163    }
164
165    #[allow(clippy::too_many_arguments)]
166    fn new_with_proto(
167        global: &GlobalScope,
168        proto: Option<HandleObject>,
169        type_: Atom,
170        bubbles: bool,
171        cancelable: bool,
172        data: HandleValue,
173        origin: DOMString,
174        source: Option<&WindowProxyOrMessagePortOrServiceWorker>,
175        lastEventId: DOMString,
176        ports: Vec<DomRoot<MessagePort>>,
177        can_gc: CanGc,
178    ) -> DomRoot<MessageEvent> {
179        let ev = MessageEvent::new_initialized(
180            global,
181            proto,
182            data,
183            origin,
184            source,
185            lastEventId,
186            ports,
187            can_gc,
188        );
189        {
190            let event = ev.upcast::<Event>();
191            event.init_event(type_, bubbles, cancelable);
192        }
193        ev
194    }
195
196    pub(crate) fn dispatch_jsval(
197        cx: &mut js::context::JSContext,
198        target: &EventTarget,
199        scope: &GlobalScope,
200        message: HandleValue,
201        origin: Option<&str>,
202        source: Option<&WindowProxy>,
203        ports: Vec<DomRoot<MessagePort>>,
204    ) {
205        let messageevent = MessageEvent::new(
206            scope,
207            atom!("message"),
208            false,
209            false,
210            message,
211            DOMString::from(origin.unwrap_or("")),
212            source
213                .map(|source| {
214                    WindowProxyOrMessagePortOrServiceWorker::WindowProxy(DomRoot::from_ref(source))
215                })
216                .as_ref(),
217            DOMString::new(),
218            ports,
219            CanGc::from_cx(cx),
220        );
221        messageevent.upcast::<Event>().fire(cx, target);
222    }
223
224    pub(crate) fn dispatch_error(
225        cx: &mut js::context::JSContext,
226        target: &EventTarget,
227        scope: &GlobalScope,
228    ) {
229        let init = MessageEventBinding::MessageEventInit::empty();
230        let messageevent = MessageEvent::new(
231            scope,
232            atom!("messageerror"),
233            init.parent.bubbles,
234            init.parent.cancelable,
235            init.data.handle(),
236            init.origin.clone(),
237            init.source.as_ref(),
238            init.lastEventId.clone(),
239            init.ports.clone(),
240            CanGc::from_cx(cx),
241        );
242        messageevent.upcast::<Event>().fire(cx, target);
243    }
244}
245
246impl MessageEventMethods<crate::DomTypeHolder> for MessageEvent {
247    /// <https://html.spec.whatwg.org/multipage/#messageevent>
248    fn Constructor(
249        global: &GlobalScope,
250        proto: Option<HandleObject>,
251        can_gc: CanGc,
252        type_: DOMString,
253        init: RootedTraceableBox<MessageEventBinding::MessageEventInit>,
254    ) -> Fallible<DomRoot<MessageEvent>> {
255        let ev = MessageEvent::new_with_proto(
256            global,
257            proto,
258            Atom::from(type_),
259            init.parent.bubbles,
260            init.parent.cancelable,
261            init.data.handle(),
262            init.origin.clone(),
263            init.source.as_ref(),
264            init.lastEventId.clone(),
265            init.ports.clone(),
266            can_gc,
267        );
268        Ok(ev)
269    }
270
271    /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-data>
272    fn Data(&self, _cx: JSContext, mut retval: MutableHandleValue) {
273        retval.set(self.data.get())
274    }
275
276    /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-origin>
277    fn Origin(&self) -> DOMString {
278        self.origin.borrow().clone()
279    }
280
281    /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-source>
282    fn GetSource(&self) -> Option<WindowProxyOrMessagePortOrServiceWorker> {
283        match &*self.source.borrow() {
284            Some(SrcObject::WindowProxy(i)) => Some(
285                WindowProxyOrMessagePortOrServiceWorker::WindowProxy(DomRoot::from_ref(i)),
286            ),
287            Some(SrcObject::MessagePort(i)) => Some(
288                WindowProxyOrMessagePortOrServiceWorker::MessagePort(DomRoot::from_ref(i)),
289            ),
290            Some(SrcObject::ServiceWorker(i)) => Some(
291                WindowProxyOrMessagePortOrServiceWorker::ServiceWorker(DomRoot::from_ref(i)),
292            ),
293            None => None,
294        }
295    }
296
297    /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-lasteventid>
298    fn LastEventId(&self) -> DOMString {
299        self.lastEventId.borrow().clone()
300    }
301
302    /// <https://dom.spec.whatwg.org/#dom-event-istrusted>
303    fn IsTrusted(&self) -> bool {
304        self.event.IsTrusted()
305    }
306
307    /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-ports>
308    fn Ports(&self, cx: JSContext, can_gc: CanGc, retval: MutableHandleValue) {
309        self.frozen_ports.get_or_init(
310            || {
311                self.ports
312                    .borrow()
313                    .iter()
314                    .map(|port| DomRoot::from_ref(&**port))
315                    .collect()
316            },
317            cx,
318            retval,
319            can_gc,
320        );
321    }
322
323    /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-initmessageevent>
324    #[expect(non_snake_case)]
325    fn InitMessageEvent(
326        &self,
327        _cx: JSContext,
328        type_: DOMString,
329        bubbles: bool,
330        cancelable: bool,
331        data: HandleValue,
332        origin: DOMString,
333        lastEventId: DOMString,
334        source: Option<WindowProxyOrMessagePortOrServiceWorker>,
335        ports: Vec<DomRoot<MessagePort>>,
336    ) {
337        self.data.set(data.get());
338        *self.origin.borrow_mut() = origin;
339        *self.source.borrow_mut() = source.as_ref().map(|source| source.into());
340        *self.lastEventId.borrow_mut() = lastEventId;
341        *self.ports.borrow_mut() = ports
342            .into_iter()
343            .map(|port| Dom::from_ref(&*port))
344            .collect();
345        self.frozen_ports.clear();
346        self.event
347            .init_event(Atom::from(type_), bubbles, cancelable);
348    }
349}
script/dom/event/messageevent.rs

script/dom/event/
messageevent.rs
