From cad810f21b803229eb11403f9209855525a25d57 Mon Sep 17 00:00:00 2001 From: Steve Block Date: Fri, 6 May 2011 11:45:16 +0100 Subject: Merge WebKit at r75315: Initial merge by git. Change-Id: I570314b346ce101c935ed22a626b48c2af266b84 --- .../WorkerThreadableWebSocketChannel.cpp | 426 +++++++++++++++++++++ 1 file changed, 426 insertions(+) create mode 100644 Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp (limited to 'Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp') diff --git a/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp b/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp new file mode 100644 index 0000000..fd82591 --- /dev/null +++ b/Source/WebCore/websockets/WorkerThreadableWebSocketChannel.cpp @@ -0,0 +1,426 @@ +/* + * Copyright (C) 2009, 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(WEB_SOCKETS) && ENABLE(WORKERS) + +#include "WorkerThreadableWebSocketChannel.h" + +#include "CrossThreadTask.h" +#include "PlatformString.h" +#include "ScriptExecutionContext.h" +#include "ThreadableWebSocketChannelClientWrapper.h" +#include "WebSocketChannel.h" +#include "WebSocketChannelClient.h" +#include "WorkerContext.h" +#include "WorkerLoaderProxy.h" +#include "WorkerRunLoop.h" +#include "WorkerThread.h" + +#include + +namespace WebCore { + +WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerContext* context, WebSocketChannelClient* client, const String& taskMode, const KURL& url, const String& protocol) + : m_workerContext(context) + , m_workerClientWrapper(ThreadableWebSocketChannelClientWrapper::create(client)) + , m_bridge(Bridge::create(m_workerClientWrapper, m_workerContext, taskMode, url, protocol)) +{ +} + +WorkerThreadableWebSocketChannel::~WorkerThreadableWebSocketChannel() +{ + if (m_bridge) + m_bridge->disconnect(); +} + +void WorkerThreadableWebSocketChannel::connect() +{ + if (m_bridge) + m_bridge->connect(); +} + +bool WorkerThreadableWebSocketChannel::send(const String& message) +{ + if (!m_bridge) + return false; + return m_bridge->send(message); +} + +unsigned long WorkerThreadableWebSocketChannel::bufferedAmount() const +{ + if (!m_bridge) + return 0; + return m_bridge->bufferedAmount(); +} + +void WorkerThreadableWebSocketChannel::close() +{ + if (m_bridge) + m_bridge->close(); +} + +void WorkerThreadableWebSocketChannel::disconnect() +{ + m_bridge->disconnect(); + m_bridge.clear(); +} + +void WorkerThreadableWebSocketChannel::suspend() +{ + m_workerClientWrapper->suspend(); + if (m_bridge) + m_bridge->suspend(); +} + +void WorkerThreadableWebSocketChannel::resume() +{ + m_workerClientWrapper->resume(); + if (m_bridge) + m_bridge->resume(); +} + +WorkerThreadableWebSocketChannel::Peer::Peer(RefPtr clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode, const KURL& url, const String& protocol) + : m_workerClientWrapper(clientWrapper) + , m_loaderProxy(loaderProxy) + , m_mainWebSocketChannel(WebSocketChannel::create(context, this, url, protocol)) + , m_taskMode(taskMode) +{ + ASSERT(isMainThread()); +} + +WorkerThreadableWebSocketChannel::Peer::~Peer() +{ + ASSERT(isMainThread()); + if (m_mainWebSocketChannel) + m_mainWebSocketChannel->disconnect(); +} + +void WorkerThreadableWebSocketChannel::Peer::connect() +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel) + return; + m_mainWebSocketChannel->connect(); +} + +static void workerContextDidSend(ScriptExecutionContext* context, RefPtr workerClientWrapper, bool sent) +{ + ASSERT_UNUSED(context, context->isWorkerContext()); + workerClientWrapper->setSent(sent); +} + +void WorkerThreadableWebSocketChannel::Peer::send(const String& message) +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel || !m_workerClientWrapper) + return; + bool sent = m_mainWebSocketChannel->send(message); + m_loaderProxy.postTaskForModeToWorkerContext(createCallbackTask(&workerContextDidSend, m_workerClientWrapper, sent), m_taskMode); +} + +static void workerContextDidGetBufferedAmount(ScriptExecutionContext* context, RefPtr workerClientWrapper, unsigned long bufferedAmount) +{ + ASSERT_UNUSED(context, context->isWorkerContext()); + workerClientWrapper->setBufferedAmount(bufferedAmount); +} + +void WorkerThreadableWebSocketChannel::Peer::bufferedAmount() +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel || !m_workerClientWrapper) + return; + unsigned long bufferedAmount = m_mainWebSocketChannel->bufferedAmount(); + m_loaderProxy.postTaskForModeToWorkerContext(createCallbackTask(&workerContextDidGetBufferedAmount, m_workerClientWrapper, bufferedAmount), m_taskMode); +} + +void WorkerThreadableWebSocketChannel::Peer::close() +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel) + return; + m_mainWebSocketChannel->close(); + m_mainWebSocketChannel = 0; +} + +void WorkerThreadableWebSocketChannel::Peer::disconnect() +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel) + return; + m_mainWebSocketChannel->disconnect(); + m_mainWebSocketChannel = 0; +} + +void WorkerThreadableWebSocketChannel::Peer::suspend() +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel) + return; + m_mainWebSocketChannel->suspend(); +} + +void WorkerThreadableWebSocketChannel::Peer::resume() +{ + ASSERT(isMainThread()); + if (!m_mainWebSocketChannel) + return; + m_mainWebSocketChannel->resume(); +} + +static void workerContextDidConnect(ScriptExecutionContext* context, RefPtr workerClientWrapper) +{ + ASSERT_UNUSED(context, context->isWorkerContext()); + workerClientWrapper->didConnect(); +} + +void WorkerThreadableWebSocketChannel::Peer::didConnect() +{ + ASSERT(isMainThread()); + m_loaderProxy.postTaskForModeToWorkerContext(createCallbackTask(&workerContextDidConnect, m_workerClientWrapper), m_taskMode); +} + +static void workerContextDidReceiveMessage(ScriptExecutionContext* context, RefPtr workerClientWrapper, const String& message) +{ + ASSERT_UNUSED(context, context->isWorkerContext()); + workerClientWrapper->didReceiveMessage(message); +} + +void WorkerThreadableWebSocketChannel::Peer::didReceiveMessage(const String& message) +{ + ASSERT(isMainThread()); + m_loaderProxy.postTaskForModeToWorkerContext(createCallbackTask(&workerContextDidReceiveMessage, m_workerClientWrapper, message), m_taskMode); +} + +static void workerContextDidClose(ScriptExecutionContext* context, RefPtr workerClientWrapper, unsigned long unhandledBufferedAmount) +{ + ASSERT_UNUSED(context, context->isWorkerContext()); + workerClientWrapper->didClose(unhandledBufferedAmount); +} + +void WorkerThreadableWebSocketChannel::Peer::didClose(unsigned long unhandledBufferedAmount) +{ + ASSERT(isMainThread()); + m_mainWebSocketChannel = 0; + m_loaderProxy.postTaskForModeToWorkerContext(createCallbackTask(&workerContextDidClose, m_workerClientWrapper, unhandledBufferedAmount), m_taskMode); +} + +void WorkerThreadableWebSocketChannel::Bridge::setWebSocketChannel(ScriptExecutionContext* context, Bridge* thisPtr, Peer* peer, RefPtr workerClientWrapper) +{ + ASSERT_UNUSED(context, context->isWorkerContext()); + thisPtr->m_peer = peer; + workerClientWrapper->setSyncMethodDone(); +} + +void WorkerThreadableWebSocketChannel::Bridge::mainThreadCreateWebSocketChannel(ScriptExecutionContext* context, Bridge* thisPtr, RefPtr clientWrapper, const String& taskMode, const KURL& url, const String& protocol) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + + Peer* peer = Peer::create(clientWrapper, thisPtr->m_loaderProxy, context, taskMode, url, protocol); + thisPtr->m_loaderProxy.postTaskForModeToWorkerContext(createCallbackTask(&Bridge::setWebSocketChannel, thisPtr, peer, clientWrapper), taskMode); +} + +WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr workerClientWrapper, PassRefPtr workerContext, const String& taskMode, const KURL& url, const String& protocol) + : m_workerClientWrapper(workerClientWrapper) + , m_workerContext(workerContext) + , m_loaderProxy(m_workerContext->thread()->workerLoaderProxy()) + , m_taskMode(taskMode) + , m_peer(0) +{ + ASSERT(m_workerClientWrapper.get()); + setMethodNotCompleted(); + m_loaderProxy.postTaskToLoader(createCallbackTask(&Bridge::mainThreadCreateWebSocketChannel, this, m_workerClientWrapper, m_taskMode, url, protocol)); + waitForMethodCompletion(); + ASSERT(m_peer); +} + +WorkerThreadableWebSocketChannel::Bridge::~Bridge() +{ + disconnect(); +} + +void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + peer->connect(); +} + +void WorkerThreadableWebSocketChannel::Bridge::connect() +{ + ASSERT(m_workerClientWrapper); + ASSERT(m_peer); + m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadConnect, m_peer)); +} + +void WorkerThreadableWebSocketChannel::mainThreadSend(ScriptExecutionContext* context, Peer* peer, const String& message) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + peer->send(message); +} + +bool WorkerThreadableWebSocketChannel::Bridge::send(const String& message) +{ + if (!m_workerClientWrapper) + return false; + ASSERT(m_peer); + setMethodNotCompleted(); + m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadSend, m_peer, message)); + RefPtr protect(this); + waitForMethodCompletion(); + ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get(); + return clientWrapper && clientWrapper->sent(); +} + +void WorkerThreadableWebSocketChannel::mainThreadBufferedAmount(ScriptExecutionContext* context, Peer* peer) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + peer->bufferedAmount(); +} + +unsigned long WorkerThreadableWebSocketChannel::Bridge::bufferedAmount() +{ + if (!m_workerClientWrapper) + return 0; + ASSERT(m_peer); + setMethodNotCompleted(); + m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadBufferedAmount, m_peer)); + RefPtr protect(this); + waitForMethodCompletion(); + ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get(); + if (clientWrapper) + return clientWrapper->bufferedAmount(); + return 0; +} + +void WorkerThreadableWebSocketChannel::mainThreadClose(ScriptExecutionContext* context, Peer* peer) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + peer->close(); +} + +void WorkerThreadableWebSocketChannel::Bridge::close() +{ + ASSERT(m_peer); + m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadClose, m_peer)); +} + +void WorkerThreadableWebSocketChannel::mainThreadDestroy(ScriptExecutionContext* context, Peer* peer) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + delete peer; +} + +void WorkerThreadableWebSocketChannel::Bridge::disconnect() +{ + clearClientWrapper(); + if (m_peer) { + Peer* peer = m_peer; + m_peer = 0; + m_loaderProxy.postTaskToLoader(createCallbackTask(&mainThreadDestroy, peer)); + } + m_workerContext = 0; +} + +void WorkerThreadableWebSocketChannel::mainThreadSuspend(ScriptExecutionContext* context, Peer* peer) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + peer->suspend(); +} + +void WorkerThreadableWebSocketChannel::Bridge::suspend() +{ + ASSERT(m_peer); + m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadSuspend, m_peer)); +} + +void WorkerThreadableWebSocketChannel::mainThreadResume(ScriptExecutionContext* context, Peer* peer) +{ + ASSERT(isMainThread()); + ASSERT_UNUSED(context, context->isDocument()); + ASSERT(peer); + + peer->resume(); +} + +void WorkerThreadableWebSocketChannel::Bridge::resume() +{ + ASSERT(m_peer); + m_loaderProxy.postTaskToLoader(createCallbackTask(&WorkerThreadableWebSocketChannel::mainThreadResume, m_peer)); +} + +void WorkerThreadableWebSocketChannel::Bridge::clearClientWrapper() +{ + m_workerClientWrapper->clearClient(); +} + +void WorkerThreadableWebSocketChannel::Bridge::setMethodNotCompleted() +{ + ASSERT(m_workerClientWrapper); + m_workerClientWrapper->clearSyncMethodDone(); +} + +// Caller of this function should hold a reference to the bridge, because this function may call WebSocket::didClose() in the end, +// which causes the bridge to get disconnected from the WebSocket and deleted if there is no other reference. +void WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion() +{ + if (!m_workerContext) + return; + WorkerRunLoop& runLoop = m_workerContext->thread()->runLoop(); + MessageQueueWaitResult result = MessageQueueMessageReceived; + ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get(); + while (m_workerContext && clientWrapper && !clientWrapper->syncMethodDone() && result != MessageQueueTerminated) { + result = runLoop.runInMode(m_workerContext.get(), m_taskMode); // May cause this bridge to get disconnected, which makes m_workerContext become null. + clientWrapper = m_workerClientWrapper.get(); + } +} + +} // namespace WebCore + +#endif // ENABLE(WEB_SOCKETS) -- cgit v1.1