1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWeb/DOM/EventDispatcher.h>
#include <LibWeb/HTML/EventHandler.h>
#include <LibWeb/HTML/EventLoop/EventLoop.h>
#include <LibWeb/HTML/EventNames.h>
#include <LibWeb/HTML/MessageEvent.h>
#include <LibWeb/HTML/MessagePort.h>
namespace Web::HTML {
JS::NonnullGCPtr<MessagePort> MessagePort::create(HTML::Window& window)
{
return *window.heap().allocate<MessagePort>(window.realm(), window);
}
MessagePort::MessagePort(HTML::Window& window)
: DOM::EventTarget(window.realm())
{
set_prototype(&window.cached_web_prototype("MessagePort"));
}
MessagePort::~MessagePort() = default;
void MessagePort::visit_edges(Cell::Visitor& visitor)
{
Base::visit_edges(visitor);
visitor.visit(m_remote_port.ptr());
}
void MessagePort::disentangle()
{
m_remote_port->m_remote_port = nullptr;
m_remote_port = nullptr;
}
// https://html.spec.whatwg.org/multipage/web-messaging.html#entangle
void MessagePort::entangle_with(MessagePort& remote_port)
{
if (m_remote_port.ptr() == &remote_port)
return;
// 1. If one of the ports is already entangled, then disentangle it and the port that it was entangled with.
if (is_entangled())
disentangle();
if (remote_port.is_entangled())
remote_port.disentangle();
// 2. Associate the two ports to be entangled, so that they form the two parts of a new channel.
// (There is no MessageChannel object that represents this channel.)
remote_port.m_remote_port = this;
m_remote_port = &remote_port;
}
// https://html.spec.whatwg.org/multipage/web-messaging.html#dom-messageport-postmessage
void MessagePort::post_message(JS::Value message)
{
// 1. Let targetPort be the port with which this MessagePort is entangled, if any; otherwise let it be null.
auto* target_port = m_remote_port.ptr();
// FIXME: 2. Let options be «[ "transfer" → transfer ]».
// 3. Run the message port post message steps providing targetPort, message and options.
// https://html.spec.whatwg.org/multipage/web-messaging.html#message-port-post-message-steps
// FIXME: 1. Let transfer be options["transfer"].
// FIXME: 2. If transfer contains this MessagePort, then throw a "DataCloneError" DOMException.
// 3. Let doomed be false.
bool doomed = false;
// FIXME: 4. If targetPort is not null and transfer contains targetPort, then set doomed to true and optionally report to a developer console that the target port was posted to itself, causing the communication channel to be lost.
// FIXME: 5. Let serializeWithTransferResult be StructuredSerializeWithTransfer(message, transfer). Rethrow any exceptions.
// 6. If targetPort is null, or if doomed is true, then return.
if (!target_port || doomed)
return;
// FIXME: 7. Add a task that runs the following steps to the port message queue of targetPort:
// FIXME: This is an ad-hoc hack implementation instead, since we don't currently
// have serialization and deserialization of messages.
main_thread_event_loop().task_queue().add(HTML::Task::create(HTML::Task::Source::PostedMessage, nullptr, [strong_port = JS::make_handle(*target_port), message]() mutable {
MessageEventInit event_init {};
event_init.data = message;
event_init.origin = "<origin>";
strong_port->dispatch_event(*MessageEvent::create(verify_cast<HTML::Window>(strong_port->realm().global_object()), HTML::EventNames::message, event_init));
}));
}
void MessagePort::start()
{
// FIXME: Message ports are supposed to be disabled by default.
}
// https://html.spec.whatwg.org/multipage/web-messaging.html#dom-messageport-close
void MessagePort::close()
{
// 1. Set this MessagePort object's [[Detached]] internal slot value to true.
m_detached = true;
// 2. If this MessagePort object is entangled, disentangle it.
if (is_entangled())
disentangle();
}
#undef __ENUMERATE
#define __ENUMERATE(attribute_name, event_name) \
void MessagePort::set_##attribute_name(Bindings::CallbackType* value) \
{ \
set_event_handler_attribute(event_name, value); \
} \
Bindings::CallbackType* MessagePort::attribute_name() \
{ \
return event_handler_attribute(event_name); \
}
ENUMERATE_MESSAGE_PORT_EVENT_HANDLERS(__ENUMERATE)
#undef __ENUMERATE
}
|
