#include "modules/websockets/WorkerThreadableWebSocketChannel.h"
-#include "bindings/v8/ScriptCallStackFactory.h"
+#include "bindings/core/v8/ScriptCallStackFactory.h"
#include "core/dom/CrossThreadTask.h"
#include "core/dom/Document.h"
#include "core/dom/ExecutionContext.h"
#include "core/inspector/ScriptCallFrame.h"
#include "core/inspector/ScriptCallStack.h"
#include "core/workers/WorkerLoaderProxy.h"
-#include "core/workers/WorkerRunLoop.h"
#include "core/workers/WorkerThread.h"
#include "modules/websockets/MainThreadWebSocketChannel.h"
#include "modules/websockets/NewWebSocketChannelImpl.h"
#include "wtf/Functional.h"
#include "wtf/MainThread.h"
-namespace WebCore {
+namespace blink {
+
+typedef WorkerThreadableWebSocketChannel::Bridge Bridge;
+typedef WorkerThreadableWebSocketChannel::Peer Peer;
// Created and destroyed on the worker thread. All setters of this class are
// called on the main thread, while all getters are called on the worker
// thread. signalWorkerThread() must be called before any getters are called.
-class ThreadableWebSocketChannelSyncHelper {
+class ThreadableWebSocketChannelSyncHelper : public GarbageCollectedFinalized<ThreadableWebSocketChannelSyncHelper> {
public:
- static PassOwnPtr<ThreadableWebSocketChannelSyncHelper> create(PassOwnPtr<blink::WebWaitableEvent> event)
+ static ThreadableWebSocketChannelSyncHelper* create(PassOwnPtr<WebWaitableEvent> event)
+ {
+ return new ThreadableWebSocketChannelSyncHelper(event);
+ }
+
+ ~ThreadableWebSocketChannelSyncHelper()
{
- return adoptPtr(new ThreadableWebSocketChannelSyncHelper(event));
}
// All setters are called on the main thread.
{
m_connectRequestResult = connectRequestResult;
}
- void setSendRequestResult(WebSocketChannel::SendResult sendRequestResult)
- {
- m_sendRequestResult = sendRequestResult;
- }
// All getter are called on the worker thread.
bool connectRequestResult() const
{
return m_connectRequestResult;
}
- WebSocketChannel::SendResult sendRequestResult() const
- {
- return m_sendRequestResult;
- }
// This should be called after all setters are called and before any
// getters are called.
{
m_event->signal();
}
-
- blink::WebWaitableEvent* event() const
+ void wait()
{
- return m_event.get();
+ m_event->wait();
}
+ void trace(Visitor* visitor) { }
+
private:
- ThreadableWebSocketChannelSyncHelper(PassOwnPtr<blink::WebWaitableEvent> event)
+ explicit ThreadableWebSocketChannelSyncHelper(PassOwnPtr<WebWaitableEvent> event)
: m_event(event)
, m_connectRequestResult(false)
- , m_sendRequestResult(WebSocketChannel::SendFail)
{
}
- OwnPtr<blink::WebWaitableEvent> m_event;
+ OwnPtr<WebWaitableEvent> m_event;
bool m_connectRequestResult;
- WebSocketChannel::SendResult m_sendRequestResult;
};
WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerGlobalScope& workerGlobalScope, WebSocketChannelClient* client, const String& sourceURL, unsigned lineNumber)
WorkerThreadableWebSocketChannel::~WorkerThreadableWebSocketChannel()
{
- if (m_bridge)
- m_bridge->disconnect();
+ ASSERT(!m_bridge);
}
bool WorkerThreadableWebSocketChannel::connect(const KURL& url, const String& protocol)
{
- if (m_bridge)
- return m_bridge->connect(url, protocol);
- return false;
+ ASSERT(m_bridge);
+ return m_bridge->connect(url, protocol);
}
-WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::send(const String& message)
+void WorkerThreadableWebSocketChannel::send(const String& message)
{
- if (!m_bridge)
- return WebSocketChannel::SendFail;
- return m_bridge->send(message);
+ ASSERT(m_bridge);
+ m_bridge->send(message);
}
-WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
+void WorkerThreadableWebSocketChannel::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
{
- if (!m_bridge)
- return WebSocketChannel::SendFail;
- return m_bridge->send(binaryData, byteOffset, byteLength);
+ ASSERT(m_bridge);
+ m_bridge->send(binaryData, byteOffset, byteLength);
}
-WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::send(PassRefPtr<BlobDataHandle> blobData)
+void WorkerThreadableWebSocketChannel::send(PassRefPtr<BlobDataHandle> blobData)
{
- if (!m_bridge)
- return WebSocketChannel::SendFail;
- return m_bridge->send(blobData);
+ ASSERT(m_bridge);
+ m_bridge->send(blobData);
}
void WorkerThreadableWebSocketChannel::close(int code, const String& reason)
{
- if (m_bridge)
- m_bridge->close(code, reason);
+ ASSERT(m_bridge);
+ m_bridge->close(code, reason);
}
void WorkerThreadableWebSocketChannel::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
void WorkerThreadableWebSocketChannel::trace(Visitor* visitor)
{
+ visitor->trace(m_bridge);
visitor->trace(m_workerClientWrapper);
WebSocketChannel::trace(visitor);
}
-WorkerThreadableWebSocketChannel::Peer::Peer(PassRefPtr<WeakReference<Peer> > reference, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, WorkerLoaderProxy& loaderProxy, ExecutionContext* context, const String& sourceURL, unsigned lineNumber, PassOwnPtr<ThreadableWebSocketChannelSyncHelper> syncHelper)
+Peer::Peer(ThreadableWebSocketChannelClientWrapper* clientWrapper, WorkerLoaderProxy& loaderProxy, ThreadableWebSocketChannelSyncHelper* syncHelper)
: m_workerClientWrapper(clientWrapper)
, m_loaderProxy(loaderProxy)
, m_mainWebSocketChannel(nullptr)
, m_syncHelper(syncHelper)
- , m_weakFactory(reference, this)
{
- ASSERT(isMainThread());
- ASSERT(m_workerClientWrapper.get());
-
- Document* document = toDocument(context);
- if (RuntimeEnabledFeatures::experimentalWebSocketEnabled()) {
- m_mainWebSocketChannel = NewWebSocketChannelImpl::create(document, this, sourceURL, lineNumber);
- } else {
- m_mainWebSocketChannel = MainThreadWebSocketChannel::create(document, this, sourceURL, lineNumber);
- }
-
- m_syncHelper->signalWorkerThread();
+ ASSERT(!isMainThread());
}
-WorkerThreadableWebSocketChannel::Peer::~Peer()
+Peer::~Peer()
{
- ASSERT(isMainThread());
- if (m_mainWebSocketChannel)
- m_mainWebSocketChannel->disconnect();
+ ASSERT(!isMainThread());
}
-void WorkerThreadableWebSocketChannel::Peer::initialize(ExecutionContext* context, PassRefPtr<WeakReference<Peer> > reference, WorkerLoaderProxy* loaderProxy, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper, const String& sourceURLAtConnection, unsigned lineNumberAtConnection, PassOwnPtr<ThreadableWebSocketChannelSyncHelper> syncHelper)
+Peer* Peer::create(ThreadableWebSocketChannelClientWrapper* clientWrapper, WorkerLoaderProxy& loaderProxy, ThreadableWebSocketChannelSyncHelper* syncHelper)
{
- // The caller must call destroy() to free the peer.
- new Peer(reference, clientWrapper, *loaderProxy, context, sourceURLAtConnection, lineNumberAtConnection, syncHelper);
+ return new Peer(clientWrapper, loaderProxy, syncHelper);
}
-void WorkerThreadableWebSocketChannel::Peer::destroy()
+void Peer::initializeInternal(ExecutionContext* context, const String& sourceURL, unsigned lineNumber)
{
ASSERT(isMainThread());
- delete this;
+ Document* document = toDocument(context);
+ if (RuntimeEnabledFeatures::experimentalWebSocketEnabled()) {
+ m_mainWebSocketChannel = NewWebSocketChannelImpl::create(document, this, sourceURL, lineNumber);
+ } else {
+ m_mainWebSocketChannel = MainThreadWebSocketChannel::create(document, this, sourceURL, lineNumber);
+ }
+ m_syncHelper->signalWorkerThread();
}
-void WorkerThreadableWebSocketChannel::Peer::connect(const KURL& url, const String& protocol)
+void Peer::connect(const KURL& url, const String& protocol)
{
ASSERT(isMainThread());
+ ASSERT(m_syncHelper);
if (!m_mainWebSocketChannel) {
m_syncHelper->setConnectRequestResult(false);
} else {
m_syncHelper->signalWorkerThread();
}
-void WorkerThreadableWebSocketChannel::Peer::send(const String& message)
+void Peer::send(const String& message)
{
ASSERT(isMainThread());
- if (!m_mainWebSocketChannel) {
- m_syncHelper->setSendRequestResult(WebSocketChannel::SendFail);
- } else {
- WebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(message);
- m_syncHelper->setSendRequestResult(sendRequestResult);
- }
- m_syncHelper->signalWorkerThread();
+ if (m_mainWebSocketChannel)
+ m_mainWebSocketChannel->send(message);
}
-void WorkerThreadableWebSocketChannel::Peer::sendArrayBuffer(PassOwnPtr<Vector<char> > data)
+void Peer::sendArrayBuffer(PassOwnPtr<Vector<char> > data)
{
ASSERT(isMainThread());
- if (!m_mainWebSocketChannel) {
- m_syncHelper->setSendRequestResult(WebSocketChannel::SendFail);
- } else {
- WebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(data);
- m_syncHelper->setSendRequestResult(sendRequestResult);
- }
- m_syncHelper->signalWorkerThread();
+ if (m_mainWebSocketChannel)
+ m_mainWebSocketChannel->send(data);
}
-void WorkerThreadableWebSocketChannel::Peer::sendBlob(PassRefPtr<BlobDataHandle> blobData)
+void Peer::sendBlob(PassRefPtr<BlobDataHandle> blobData)
{
ASSERT(isMainThread());
- if (!m_mainWebSocketChannel) {
- m_syncHelper->setSendRequestResult(WebSocketChannel::SendFail);
- } else {
- WebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(blobData);
- m_syncHelper->setSendRequestResult(sendRequestResult);
- }
- m_syncHelper->signalWorkerThread();
+ if (m_mainWebSocketChannel)
+ m_mainWebSocketChannel->send(blobData);
}
-void WorkerThreadableWebSocketChannel::Peer::close(int code, const String& reason)
+void Peer::close(int code, const String& reason)
{
ASSERT(isMainThread());
+ ASSERT(m_syncHelper);
if (!m_mainWebSocketChannel)
return;
m_mainWebSocketChannel->close(code, reason);
}
-void WorkerThreadableWebSocketChannel::Peer::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
+void Peer::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
{
ASSERT(isMainThread());
+ ASSERT(m_syncHelper);
if (!m_mainWebSocketChannel)
return;
m_mainWebSocketChannel->fail(reason, level, sourceURL, lineNumber);
}
-void WorkerThreadableWebSocketChannel::Peer::disconnect()
+void Peer::disconnect()
{
ASSERT(isMainThread());
- if (!m_mainWebSocketChannel)
- return;
- m_mainWebSocketChannel->disconnect();
- m_mainWebSocketChannel = nullptr;
+ ASSERT(m_syncHelper);
+ if (m_mainWebSocketChannel) {
+ m_mainWebSocketChannel->disconnect();
+ m_mainWebSocketChannel = nullptr;
+ }
+ m_syncHelper->signalWorkerThread();
}
-static void workerGlobalScopeDidConnect(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, const String& subprotocol, const String& extensions)
+static void workerGlobalScopeDidConnect(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper, const String& subprotocol, const String& extensions)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didConnect(subprotocol, extensions);
}
-void WorkerThreadableWebSocketChannel::Peer::didConnect(const String& subprotocol, const String& extensions)
+void Peer::didConnect(const String& subprotocol, const String& extensions)
{
ASSERT(isMainThread());
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidConnect, m_workerClientWrapper.get(), subprotocol, extensions);
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidConnect, m_workerClientWrapper, subprotocol, extensions);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-static void workerGlobalScopeDidReceiveMessage(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, const String& message)
+static void workerGlobalScopeDidReceiveMessage(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper, const String& message)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didReceiveMessage(message);
}
-void WorkerThreadableWebSocketChannel::Peer::didReceiveMessage(const String& message)
+void Peer::didReceiveMessage(const String& message)
{
ASSERT(isMainThread());
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidReceiveMessage, m_workerClientWrapper.get(), message);
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidReceiveMessage, m_workerClientWrapper, message);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-static void workerGlobalScopeDidReceiveBinaryData(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassOwnPtr<Vector<char> > binaryData)
+static void workerGlobalScopeDidReceiveBinaryData(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper, PassOwnPtr<Vector<char> > binaryData)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didReceiveBinaryData(binaryData);
}
-void WorkerThreadableWebSocketChannel::Peer::didReceiveBinaryData(PassOwnPtr<Vector<char> > binaryData)
+void Peer::didReceiveBinaryData(PassOwnPtr<Vector<char> > binaryData)
{
ASSERT(isMainThread());
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidReceiveBinaryData, m_workerClientWrapper.get(), binaryData);
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidReceiveBinaryData, m_workerClientWrapper, binaryData);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-static void workerGlobalScopeDidConsumeBufferedAmount(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, unsigned long consumed)
+static void workerGlobalScopeDidConsumeBufferedAmount(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper, unsigned long consumed)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didConsumeBufferedAmount(consumed);
}
-void WorkerThreadableWebSocketChannel::Peer::didConsumeBufferedAmount(unsigned long consumed)
+void Peer::didConsumeBufferedAmount(unsigned long consumed)
{
ASSERT(isMainThread());
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidConsumeBufferedAmount, m_workerClientWrapper.get(), consumed);
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidConsumeBufferedAmount, m_workerClientWrapper, consumed);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-static void workerGlobalScopeDidStartClosingHandshake(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper)
+static void workerGlobalScopeDidStartClosingHandshake(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didStartClosingHandshake();
}
-void WorkerThreadableWebSocketChannel::Peer::didStartClosingHandshake()
+void Peer::didStartClosingHandshake()
{
ASSERT(isMainThread());
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidStartClosingHandshake, m_workerClientWrapper.get());
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidStartClosingHandshake, m_workerClientWrapper);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-static void workerGlobalScopeDidClose(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, WebSocketChannelClient::ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
+static void workerGlobalScopeDidClose(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper, WebSocketChannelClient::ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didClose(closingHandshakeCompletion, code, reason);
}
-void WorkerThreadableWebSocketChannel::Peer::didClose(ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
+void Peer::didClose(ClosingHandshakeCompletionStatus closingHandshakeCompletion, unsigned short code, const String& reason)
{
ASSERT(isMainThread());
- m_mainWebSocketChannel = nullptr;
+ if (m_mainWebSocketChannel) {
+ m_mainWebSocketChannel->disconnect();
+ m_mainWebSocketChannel = nullptr;
+ }
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidClose, m_workerClientWrapper.get(), closingHandshakeCompletion, code, reason);
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidClose, m_workerClientWrapper, closingHandshakeCompletion, code, reason);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-static void workerGlobalScopeDidReceiveMessageError(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper)
+static void workerGlobalScopeDidReceiveMessageError(ExecutionContext* context, ThreadableWebSocketChannelClientWrapper* workerClientWrapper)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->didReceiveMessageError();
}
-void WorkerThreadableWebSocketChannel::Peer::didReceiveMessageError()
+void Peer::didReceiveMessageError()
{
ASSERT(isMainThread());
// It is important to seprate task creation from posting
// the task. See the above comment.
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&workerGlobalScopeDidReceiveMessageError, m_workerClientWrapper.get());
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&workerGlobalScopeDidReceiveMessageError, m_workerClientWrapper);
m_loaderProxy.postTaskToWorkerGlobalScope(task.release());
}
-WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, WorkerGlobalScope& workerGlobalScope)
+void Peer::trace(Visitor* visitor)
+{
+ visitor->trace(m_workerClientWrapper);
+ visitor->trace(m_mainWebSocketChannel);
+ visitor->trace(m_syncHelper);
+ WebSocketChannelClient::trace(visitor);
+}
+
+Bridge::Bridge(ThreadableWebSocketChannelClientWrapper* workerClientWrapper, WorkerGlobalScope& workerGlobalScope)
: m_workerClientWrapper(workerClientWrapper)
, m_workerGlobalScope(workerGlobalScope)
, m_loaderProxy(m_workerGlobalScope->thread()->workerLoaderProxy())
- , m_syncHelper(0)
+ , m_syncHelper(ThreadableWebSocketChannelSyncHelper::create(adoptPtr(Platform::current()->createWaitableEvent())))
+ , m_peer(Peer::create(m_workerClientWrapper, m_loaderProxy, m_syncHelper))
{
ASSERT(m_workerClientWrapper.get());
}
-WorkerThreadableWebSocketChannel::Bridge::~Bridge()
+Bridge::~Bridge()
{
- disconnect();
+ ASSERT(!m_peer);
}
-void WorkerThreadableWebSocketChannel::Bridge::initialize(const String& sourceURL, unsigned lineNumber)
+void Bridge::initialize(const String& sourceURL, unsigned lineNumber)
{
- RefPtr<WeakReference<Peer> > reference = WeakReference<Peer>::createUnbound();
- m_peer = WeakPtr<Peer>(reference);
-
- OwnPtr<ThreadableWebSocketChannelSyncHelper> syncHelper = ThreadableWebSocketChannelSyncHelper::create(adoptPtr(blink::Platform::current()->createWaitableEvent()));
- // This pointer is guaranteed to be valid until we call terminatePeer.
- m_syncHelper = syncHelper.get();
-
- RefPtr<Bridge> protect(this);
- OwnPtr<ExecutionContextTask> task = createCallbackTask(&Peer::initialize, reference.release(), AllowCrossThreadAccess(&m_loaderProxy), m_workerClientWrapper.get(), sourceURL, lineNumber, syncHelper.release());
+ // In order to assure all temporary objects to be destroyed before
+ // posting the task, we separate task creation and posting.
+ // In other words, it is dangerous to have a complicated expression
+ // as a waitForMethodCompletion argument.
+ OwnPtr<ExecutionContextTask> task = createCrossThreadTask(&Peer::initialize, AllowCrossThreadAccess(m_peer.get()), sourceURL, lineNumber);
if (!waitForMethodCompletion(task.release())) {
// The worker thread has been signalled to shutdown before method completion.
- terminatePeer();
+ disconnect();
}
}
-bool WorkerThreadableWebSocketChannel::Bridge::connect(const KURL& url, const String& protocol)
+bool Bridge::connect(const KURL& url, const String& protocol)
{
- if (hasTerminatedPeer())
+ if (!m_peer)
return false;
- RefPtr<Bridge> protect(this);
- // It is important to seprate task creation from calling
- // waitForMethodCompletion. See the above comment.
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::connect, m_peer, url.copy(), protocol.isolatedCopy()));
- if (!waitForMethodCompletion(task.release()))
+ if (!waitForMethodCompletion(createCrossThreadTask(&Peer::connect, m_peer.get(), url, protocol)))
return false;
return m_syncHelper->connectRequestResult();
}
-WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const String& message)
+void Bridge::send(const String& message)
{
- if (hasTerminatedPeer())
- return WebSocketChannel::SendFail;
-
- RefPtr<Bridge> protect(this);
- // It is important to seprate task creation from calling
- // waitForMethodCompletion. See the above comment.
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::send, m_peer, message.isolatedCopy()));
- if (!waitForMethodCompletion(task.release()))
- return WebSocketChannel::SendFail;
-
- return m_syncHelper->sendRequestResult();
+ ASSERT(m_peer);
+ m_loaderProxy.postTaskToLoader(createCrossThreadTask(&Peer::send, m_peer.get(), message));
}
-WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
+void Bridge::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
{
- if (hasTerminatedPeer())
- return WebSocketChannel::SendFail;
-
+ ASSERT(m_peer);
// ArrayBuffer isn't thread-safe, hence the content of ArrayBuffer is copied into Vector<char>.
OwnPtr<Vector<char> > data = adoptPtr(new Vector<char>(byteLength));
if (binaryData.byteLength())
memcpy(data->data(), static_cast<const char*>(binaryData.data()) + byteOffset, byteLength);
- RefPtr<Bridge> protect(this);
- // It is important to seprate task creation from calling
- // waitForMethodCompletion. See the above comment.
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::sendArrayBuffer, m_peer, data.release()));
- if (!waitForMethodCompletion(task.release()))
- return WebSocketChannel::SendFail;
-
- return m_syncHelper->sendRequestResult();
+ m_loaderProxy.postTaskToLoader(createCrossThreadTask(&Peer::sendArrayBuffer, m_peer.get(), data.release()));
}
-WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(PassRefPtr<BlobDataHandle> data)
+void Bridge::send(PassRefPtr<BlobDataHandle> data)
{
- if (hasTerminatedPeer())
- return WebSocketChannel::SendFail;
-
- RefPtr<Bridge> protect(this);
- // It is important to seprate task creation from calling
- // waitForMethodCompletion. See the above comment.
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::sendBlob, m_peer, data));
- if (!waitForMethodCompletion(task.release()))
- return WebSocketChannel::SendFail;
-
- return m_syncHelper->sendRequestResult();
+ ASSERT(m_peer);
+ m_loaderProxy.postTaskToLoader(createCrossThreadTask(&Peer::sendBlob, m_peer.get(), data));
}
-void WorkerThreadableWebSocketChannel::Bridge::close(int code, const String& reason)
+void Bridge::close(int code, const String& reason)
{
- if (hasTerminatedPeer())
- return;
-
- // It is important to seprate task creation from calling
- // waitForMethodCompletion. See the above comment.
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::close, m_peer, code, reason.isolatedCopy()));
- m_loaderProxy.postTaskToLoader(task.release());
+ ASSERT(m_peer);
+ m_loaderProxy.postTaskToLoader(createCrossThreadTask(&Peer::close, m_peer.get(), code, reason));
}
-void WorkerThreadableWebSocketChannel::Bridge::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
+void Bridge::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
{
- if (hasTerminatedPeer())
- return;
-
- // It is important to seprate task creation from calling
- // waitForMethodCompletion. See the above comment.
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::fail, m_peer, reason.isolatedCopy(), level, sourceURL.isolatedCopy(), lineNumber));
- m_loaderProxy.postTaskToLoader(task.release());
+ ASSERT(m_peer);
+ m_loaderProxy.postTaskToLoader(createCrossThreadTask(&Peer::fail, m_peer.get(), reason, level, sourceURL, lineNumber));
}
-void WorkerThreadableWebSocketChannel::Bridge::disconnect()
+void Bridge::disconnect()
{
- clearClientWrapper();
- terminatePeer();
-}
+ if (!m_peer)
+ return;
-void WorkerThreadableWebSocketChannel::Bridge::clearClientWrapper()
-{
m_workerClientWrapper->clearClient();
+ waitForMethodCompletion(createCrossThreadTask(&Peer::disconnect, m_peer.get()));
+ // Here |m_peer| is detached from the main thread and we can delete it.
+
+ m_peer = nullptr;
+ m_syncHelper = nullptr;
+ // We won't use this any more.
+ m_workerGlobalScope.clear();
}
// 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.
-bool WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion(PassOwnPtr<ExecutionContextTask> task)
+bool Bridge::waitForMethodCompletion(PassOwnPtr<ExecutionContextTask> task)
{
ASSERT(m_workerGlobalScope);
ASSERT(m_syncHelper);
// We wait for the syncHelper event even if a shutdown event is fired.
// See https://codereview.chromium.org/267323004/#msg43 for why we need to wait this.
- Vector<blink::WebWaitableEvent*> events;
- events.append(m_syncHelper->event());
ThreadState::SafePointScope scope(ThreadState::HeapPointersOnStack);
- blink::Platform::current()->waitMultipleEvents(events);
+ m_syncHelper->wait();
// This is checking whether a shutdown event is fired or not.
- return !m_workerGlobalScope->thread()->runLoop().terminated();
+ return !m_workerGlobalScope->thread()->terminated();
}
-void WorkerThreadableWebSocketChannel::Bridge::terminatePeer()
+void Bridge::trace(Visitor* visitor)
{
- OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::destroy, m_peer));
- m_loaderProxy.postTaskToLoader(task.release());
- // Peer::destroy() deletes m_peer and then m_syncHelper will be released.
- // We must not touch m_syncHelper any more.
- m_syncHelper = 0;
-
- // We won't use this any more.
- m_workerGlobalScope = nullptr;
+ visitor->trace(m_workerClientWrapper);
+ visitor->trace(m_workerGlobalScope);
+ visitor->trace(m_syncHelper);
+ visitor->trace(m_peer);
}
-} // namespace WebCore
+} // namespace blink