Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / Modules / websockets / ThreadableWebSocketChannelClientWrapper.cpp
1 /*
2  * Copyright (C) 2011 Google Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #if ENABLE(WEB_SOCKETS)
33 #include "ThreadableWebSocketChannelClientWrapper.h"
34
35 #include "ScriptExecutionContext.h"
36 #include "WebSocketChannelClient.h"
37 #include <wtf/PassRefPtr.h>
38 #include <wtf/RefPtr.h>
39 #include <wtf/text/StringView.h>
40
41 namespace WebCore {
42
43 ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext* context, WebSocketChannelClient* client)
44     : m_context(context)
45     , m_client(client)
46     , m_peer(nullptr)
47     , m_failedWebSocketChannelCreation(false)
48     , m_syncMethodDone(true)
49     , m_sendRequestResult(ThreadableWebSocketChannel::SendFail)
50     , m_bufferedAmount(0)
51     , m_suspended(false)
52 {
53 }
54
55 Ref<ThreadableWebSocketChannelClientWrapper> ThreadableWebSocketChannelClientWrapper::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
56 {
57     return adoptRef(*new ThreadableWebSocketChannelClientWrapper(context, client));
58 }
59
60 void ThreadableWebSocketChannelClientWrapper::clearSyncMethodDone()
61 {
62     m_syncMethodDone = false;
63 }
64
65 void ThreadableWebSocketChannelClientWrapper::setSyncMethodDone()
66 {
67     m_syncMethodDone = true;
68 }
69
70 bool ThreadableWebSocketChannelClientWrapper::syncMethodDone() const
71 {
72     return m_syncMethodDone;
73 }
74
75 WorkerThreadableWebSocketChannel::Peer* ThreadableWebSocketChannelClientWrapper::peer() const
76 {
77     return m_peer;
78 }
79
80 void ThreadableWebSocketChannelClientWrapper::didCreateWebSocketChannel(WorkerThreadableWebSocketChannel::Peer* peer)
81 {
82     m_peer = peer;
83     m_syncMethodDone = true;
84 }
85
86 void ThreadableWebSocketChannelClientWrapper::clearPeer()
87 {
88     m_peer = nullptr;
89 }
90
91 bool ThreadableWebSocketChannelClientWrapper::failedWebSocketChannelCreation() const
92 {
93     return m_failedWebSocketChannelCreation;
94 }
95
96 void ThreadableWebSocketChannelClientWrapper::setFailedWebSocketChannelCreation()
97 {
98     m_failedWebSocketChannelCreation = true;
99 }
100
101 String ThreadableWebSocketChannelClientWrapper::subprotocol() const
102 {
103     if (m_subprotocol.isEmpty())
104         return emptyString();
105     return String(m_subprotocol);
106 }
107
108 void ThreadableWebSocketChannelClientWrapper::setSubprotocol(const String& subprotocol)
109 {
110     unsigned length = subprotocol.length();
111     m_subprotocol.resize(length);
112     StringView(subprotocol).getCharactersWithUpconvert(m_subprotocol.data());
113 }
114
115 String ThreadableWebSocketChannelClientWrapper::extensions() const
116 {
117     if (m_extensions.isEmpty())
118         return emptyString();
119     return String(m_extensions);
120 }
121
122 void ThreadableWebSocketChannelClientWrapper::setExtensions(const String& extensions)
123 {
124     unsigned length = extensions.length();
125     m_extensions.resize(length);
126     StringView(extensions).getCharactersWithUpconvert(m_extensions.data());
127 }
128
129 ThreadableWebSocketChannel::SendResult ThreadableWebSocketChannelClientWrapper::sendRequestResult() const
130 {
131     return m_sendRequestResult;
132 }
133
134 void ThreadableWebSocketChannelClientWrapper::setSendRequestResult(ThreadableWebSocketChannel::SendResult sendRequestResult)
135 {
136     m_sendRequestResult = sendRequestResult;
137     m_syncMethodDone = true;
138 }
139
140 unsigned long ThreadableWebSocketChannelClientWrapper::bufferedAmount() const
141 {
142     return m_bufferedAmount;
143 }
144
145 void ThreadableWebSocketChannelClientWrapper::setBufferedAmount(unsigned long bufferedAmount)
146 {
147     m_bufferedAmount = bufferedAmount;
148     m_syncMethodDone = true;
149 }
150
151 void ThreadableWebSocketChannelClientWrapper::clearClient()
152 {
153     m_client = nullptr;
154 }
155
156 void ThreadableWebSocketChannelClientWrapper::didConnect()
157 {
158     ref();
159     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this] (ScriptExecutionContext&) {
160         if (m_client)
161             m_client->didConnect();
162         deref();
163     }));
164
165     if (!m_suspended)
166         processPendingTasks();
167 }
168
169 void ThreadableWebSocketChannelClientWrapper::didReceiveMessage(const String& message)
170 {
171     ref();
172     String messageCopy = message.isolatedCopy();
173     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, message] (ScriptExecutionContext&) {
174         if (m_client)
175             m_client->didReceiveMessage(message);
176         deref();
177     }));
178
179     if (!m_suspended)
180         processPendingTasks();
181 }
182
183 void ThreadableWebSocketChannelClientWrapper::didReceiveBinaryData(Vector<char>&& binaryData)
184 {
185     ref();
186     Vector<char>* capturedData = new Vector<char>(WTFMove(binaryData));
187     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, capturedData] (ScriptExecutionContext&) {
188         if (m_client)
189             m_client->didReceiveBinaryData(WTFMove(*capturedData));
190         delete capturedData;
191         deref();
192     }));
193
194     if (!m_suspended)
195         processPendingTasks();
196 }
197
198 void ThreadableWebSocketChannelClientWrapper::didUpdateBufferedAmount(unsigned long bufferedAmount)
199 {
200     ref();
201     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this, bufferedAmount] (ScriptExecutionContext&) {
202         if (m_client)
203             m_client->didUpdateBufferedAmount(bufferedAmount);
204         deref();
205     }));
206
207     if (!m_suspended)
208         processPendingTasks();
209 }
210
211 void ThreadableWebSocketChannelClientWrapper::didStartClosingHandshake()
212 {
213     ref();
214     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this] (ScriptExecutionContext&) {
215         if (m_client)
216             m_client->didStartClosingHandshake();
217         deref();
218     }));
219
220     if (!m_suspended)
221         processPendingTasks();
222 }
223
224 void ThreadableWebSocketChannelClientWrapper::didClose(unsigned long unhandledBufferedAmount, WebSocketChannelClient::ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
225 {
226     ref();
227     String reasonCopy = reason.isolatedCopy();
228     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>(
229         [this, unhandledBufferedAmount, closingHandshakeCompletion, code, reasonCopy] (ScriptExecutionContext&) {
230             if (m_client)
231                 m_client->didClose(unhandledBufferedAmount, closingHandshakeCompletion, code, reasonCopy);
232             deref();
233         }));
234
235     if (!m_suspended)
236         processPendingTasks();
237 }
238
239 void ThreadableWebSocketChannelClientWrapper::didReceiveMessageError()
240 {
241     ref();
242     m_pendingTasks.append(std::make_unique<ScriptExecutionContext::Task>([this] (ScriptExecutionContext&) {
243         if (m_client)
244             m_client->didReceiveMessageError();
245         deref();
246     }));
247
248     if (!m_suspended)
249         processPendingTasks();
250 }
251
252 void ThreadableWebSocketChannelClientWrapper::suspend()
253 {
254     m_suspended = true;
255 }
256
257 void ThreadableWebSocketChannelClientWrapper::resume()
258 {
259     m_suspended = false;
260     processPendingTasks();
261 }
262
263 void ThreadableWebSocketChannelClientWrapper::processPendingTasks()
264 {
265     if (m_suspended)
266         return;
267     if (!m_syncMethodDone) {
268         // When a synchronous operation is in progress (i.e. the execution stack contains
269         // WorkerThreadableWebSocketChannel::waitForMethodCompletion()), we cannot invoke callbacks in this run loop.
270         ref();
271         m_context->postTask([this] (ScriptExecutionContext& context) {
272             ASSERT_UNUSED(context, context.isWorkerGlobalScope());
273             processPendingTasks();
274             deref();
275         });
276         return;
277     }
278
279     Vector<std::unique_ptr<ScriptExecutionContext::Task>> pendingTasks = WTFMove(m_pendingTasks);
280     for (auto& task : pendingTasks)
281         task->performTask(*m_context);
282 }
283
284 } // namespace WebCore
285
286 #endif