Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / dom / default / PlatformMessagePortChannel.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  * Copyright (C) 2013 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "PlatformMessagePortChannel.h"
34
35 #include "MessagePort.h"
36 #include "ScriptExecutionContext.h"
37
38 namespace WebCore {
39
40 void MessagePortChannel::createChannel(MessagePort* port1, MessagePort* port2)
41 {
42     Ref<PlatformMessagePortChannel::MessagePortQueue> queue1 = PlatformMessagePortChannel::MessagePortQueue::create();
43     Ref<PlatformMessagePortChannel::MessagePortQueue> queue2 = PlatformMessagePortChannel::MessagePortQueue::create();
44
45     auto channel1 = std::make_unique<MessagePortChannel>(PlatformMessagePortChannel::create(queue1.ptr(), queue2.ptr()));
46     auto channel2 = std::make_unique<MessagePortChannel>(PlatformMessagePortChannel::create(queue2.ptr(), queue1.ptr()));
47
48     channel1->m_channel->m_entangledChannel = channel2->m_channel;
49     channel2->m_channel->m_entangledChannel = channel1->m_channel;
50
51     port1->entangle(WTFMove(channel2));
52     port2->entangle(WTFMove(channel1));
53 }
54
55 MessagePortChannel::MessagePortChannel(RefPtr<PlatformMessagePortChannel>&& channel)
56     : m_channel(WTFMove(channel))
57 {
58 }
59
60 MessagePortChannel::~MessagePortChannel()
61 {
62     close();
63 }
64
65 bool MessagePortChannel::entangleIfOpen(MessagePort* port)
66 {
67     // We can't call member functions on our remote pair while holding our mutex or we'll deadlock,
68     // but we need to guard against the remote port getting closed/freed, so create a standalone reference.
69     RefPtr<PlatformMessagePortChannel> remote = m_channel->entangledChannel();
70     if (!remote)
71         return false;
72     remote->setRemotePort(port);
73     return true;
74 }
75
76 void MessagePortChannel::disentangle()
77 {
78     RefPtr<PlatformMessagePortChannel> remote = m_channel->entangledChannel();
79     if (remote)
80         remote->setRemotePort(nullptr);
81 }
82
83 void MessagePortChannel::postMessageToRemote(Ref<SerializedScriptValue>&& message, std::unique_ptr<MessagePortChannelArray> channels)
84 {
85     LockHolder lock(m_channel->m_mutex);
86     if (!m_channel->m_outgoingQueue)
87         return;
88     bool wasEmpty = m_channel->m_outgoingQueue->appendAndCheckEmpty(std::make_unique<EventData>(WTFMove(message), WTFMove(channels)));
89     if (wasEmpty && m_channel->m_remotePort)
90         m_channel->m_remotePort->messageAvailable();
91 }
92
93 auto MessagePortChannel::takeMessageFromRemote() -> std::unique_ptr<EventData>
94 {
95     LockHolder lock(m_channel->m_mutex);
96     return m_channel->m_incomingQueue->takeMessage();
97 }
98
99 auto MessagePortChannel::takeAllMessagesFromRemote() -> Deque<std::unique_ptr<EventData>>
100 {
101     LockHolder lock(m_channel->m_mutex);
102     return m_channel->m_incomingQueue->takeAllMessages();
103 }
104
105 void MessagePortChannel::close()
106 {
107     RefPtr<PlatformMessagePortChannel> remote = m_channel->entangledChannel();
108     if (!remote)
109         return;
110     m_channel->closeInternal();
111     remote->closeInternal();
112 }
113
114 bool MessagePortChannel::isConnectedTo(MessagePort* port)
115 {
116     // FIXME: What guarantees that the result remains the same after we release the lock?
117     LockHolder lock(m_channel->m_mutex);
118     return m_channel->m_remotePort == port;
119 }
120
121 bool MessagePortChannel::hasPendingActivity()
122 {
123     // FIXME: What guarantees that the result remains the same after we release the lock?
124     LockHolder lock(m_channel->m_mutex);
125     return !m_channel->m_incomingQueue->isEmpty();
126 }
127
128 MessagePort* MessagePortChannel::locallyEntangledPort(const ScriptExecutionContext* context)
129 {
130     LockHolder lock(m_channel->m_mutex);
131     // See if both contexts are run by the same thread (are the same context, or are both documents).
132     if (m_channel->m_remotePort) {
133         // The remote port's ScriptExecutionContext is guaranteed not to change here - MessagePort::contextDestroyed()
134         // will close the port before the context goes away, and close() will block because we are holding the mutex.
135         ScriptExecutionContext* remoteContext = m_channel->m_remotePort->scriptExecutionContext();
136         if (remoteContext == context || (remoteContext && remoteContext->isDocument() && context->isDocument()))
137             return m_channel->m_remotePort;
138     }
139     return 0;
140 }
141
142 Ref<PlatformMessagePortChannel> PlatformMessagePortChannel::create(MessagePortQueue* incoming, MessagePortQueue* outgoing)
143 {
144     return adoptRef(*new PlatformMessagePortChannel(incoming, outgoing));
145 }
146
147 PlatformMessagePortChannel::PlatformMessagePortChannel(MessagePortQueue* incoming, MessagePortQueue* outgoing)
148     : m_incomingQueue(incoming)
149     , m_outgoingQueue(outgoing)
150 {
151 }
152
153 PlatformMessagePortChannel::~PlatformMessagePortChannel() = default;
154
155 void PlatformMessagePortChannel::setRemotePort(MessagePort* port)
156 {
157     LockHolder lock(m_mutex);
158     // Should never set port if it is already set.
159     ASSERT(!port || !m_remotePort);
160     m_remotePort = port;
161 }
162
163 RefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::entangledChannel()
164 {
165     // FIXME: What guarantees that the result remains the same after we release the lock?
166     // This lock only guarantees that the returned pointer will not be pointing to released memory,
167     // but not that it will still be pointing to this object's entangled port channel.
168     LockHolder lock(m_mutex);
169     return m_entangledChannel;
170 }
171
172 void PlatformMessagePortChannel::closeInternal()
173 {
174     LockHolder lock(m_mutex);
175     // Disentangle ourselves from the other end. We still maintain a reference to our incoming queue, since previously-existing messages should still be delivered.
176     m_remotePort = nullptr;
177     m_entangledChannel = nullptr;
178     m_outgoingQueue = nullptr;
179 }
180
181 } // namespace WebCore