Title: [201837] trunk/Source/WebCore
Revision
201837
Author
achristen...@apple.com
Date
2016-06-08 15:27:46 -0700 (Wed, 08 Jun 2016)

Log Message

Modernize WebSocket code
https://bugs.webkit.org/show_bug.cgi?id=158539

Reviewed by Brady Eidson.

No new tests, no change in behavior.

* Modules/websockets/ThreadableWebSocketChannel.cpp:
(WebCore::ThreadableWebSocketChannel::create):
* Modules/websockets/ThreadableWebSocketChannel.h:
(WebCore::ThreadableWebSocketChannel::ThreadableWebSocketChannel):
* Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp:
(WebCore::ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper):
(WebCore::ThreadableWebSocketChannelClientWrapper::create):
(WebCore::ThreadableWebSocketChannelClientWrapper::processPendingTasks):
* Modules/websockets/ThreadableWebSocketChannelClientWrapper.h:
* Modules/websockets/WebSocket.cpp:
(WebCore::WebSocket::connect):
* Modules/websockets/WebSocketChannel.cpp:
(WebCore::WebSocketChannel::WebSocketChannel):
* Modules/websockets/WebSocketChannel.h:
(WebCore::WebSocketChannel::create):
* Modules/websockets/WorkerThreadableWebSocketChannel.cpp:
(WebCore::WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel):
(WebCore::WorkerThreadableWebSocketChannel::subprotocol):
(WebCore::WorkerThreadableWebSocketChannel::extensions):
(WebCore::WorkerThreadableWebSocketChannel::resume):
(WebCore::WorkerThreadableWebSocketChannel::Peer::Peer):
(WebCore::WorkerThreadableWebSocketChannel::Peer::send):
(WebCore::WorkerThreadableWebSocketChannel::Peer::bufferedAmount):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didConnect):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveMessage):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveBinaryData):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didUpdateBufferedAmount):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didStartClosingHandshake):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didClose):
(WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveMessageError):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::~Bridge):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::initialize):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::connect):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::send):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::bufferedAmount):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::close):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::setMethodNotCompleted):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion):
* Modules/websockets/WorkerThreadableWebSocketChannel.h:
(WebCore::WorkerThreadableWebSocketChannel::create):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::create):

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (201836 => 201837)


--- trunk/Source/WebCore/ChangeLog	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/ChangeLog	2016-06-08 22:27:46 UTC (rev 201837)
@@ -1,3 +1,56 @@
+2016-06-08  Alex Christensen  <achristen...@webkit.org>
+
+        Modernize WebSocket code
+        https://bugs.webkit.org/show_bug.cgi?id=158539
+
+        Reviewed by Brady Eidson.
+
+        No new tests, no change in behavior.
+
+        * Modules/websockets/ThreadableWebSocketChannel.cpp:
+        (WebCore::ThreadableWebSocketChannel::create):
+        * Modules/websockets/ThreadableWebSocketChannel.h:
+        (WebCore::ThreadableWebSocketChannel::ThreadableWebSocketChannel):
+        * Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp:
+        (WebCore::ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper):
+        (WebCore::ThreadableWebSocketChannelClientWrapper::create):
+        (WebCore::ThreadableWebSocketChannelClientWrapper::processPendingTasks):
+        * Modules/websockets/ThreadableWebSocketChannelClientWrapper.h:
+        * Modules/websockets/WebSocket.cpp:
+        (WebCore::WebSocket::connect):
+        * Modules/websockets/WebSocketChannel.cpp:
+        (WebCore::WebSocketChannel::WebSocketChannel):
+        * Modules/websockets/WebSocketChannel.h:
+        (WebCore::WebSocketChannel::create):
+        * Modules/websockets/WorkerThreadableWebSocketChannel.cpp:
+        (WebCore::WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel):
+        (WebCore::WorkerThreadableWebSocketChannel::subprotocol):
+        (WebCore::WorkerThreadableWebSocketChannel::extensions):
+        (WebCore::WorkerThreadableWebSocketChannel::resume):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::Peer):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::send):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::bufferedAmount):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didConnect):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveMessage):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveBinaryData):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didUpdateBufferedAmount):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didStartClosingHandshake):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didClose):
+        (WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveMessageError):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::~Bridge):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::initialize):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::connect):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::send):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::bufferedAmount):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::close):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::setMethodNotCompleted):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion):
+        * Modules/websockets/WorkerThreadableWebSocketChannel.h:
+        (WebCore::WorkerThreadableWebSocketChannel::create):
+        (WebCore::WorkerThreadableWebSocketChannel::Bridge::create):
+
 2016-06-08  Chris Dumez  <cdu...@apple.com>
 
         First parameter to MessagePort / DedicatedWorkerGlobalScope.postMessage() should be mandatory

Modified: trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.cpp (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.cpp	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.cpp	2016-06-08 22:27:46 UTC (rev 201837)
@@ -43,25 +43,21 @@
 #include "WorkerRunLoop.h"
 #include "WorkerThread.h"
 #include "WorkerThreadableWebSocketChannel.h"
-#include <wtf/PassRefPtr.h>
 #include <wtf/text/StringBuilder.h>
 
 namespace WebCore {
 
 static const char webSocketChannelMode[] = "webSocketChannelMode";
 
-PassRefPtr<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
+Ref<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext& context, WebSocketChannelClient& client)
 {
-    ASSERT(context);
-    ASSERT(client);
-
-    if (is<WorkerGlobalScope>(*context)) {
-        WorkerGlobalScope& workerGlobalScope = downcast<WorkerGlobalScope>(*context);
+    if (is<WorkerGlobalScope>(context)) {
+        WorkerGlobalScope& workerGlobalScope = downcast<WorkerGlobalScope>(context);
         WorkerRunLoop& runLoop = workerGlobalScope.thread().runLoop();
         StringBuilder mode;
         mode.appendLiteral(webSocketChannelMode);
         mode.appendNumber(runLoop.createUniqueId());
-        return WorkerThreadableWebSocketChannel::create(&workerGlobalScope, client, mode.toString());
+        return WorkerThreadableWebSocketChannel::create(workerGlobalScope, client, mode.toString());
     }
 
     return WebSocketChannel::create(downcast<Document>(context), client);

Modified: trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h	2016-06-08 22:27:46 UTC (rev 201837)
@@ -28,14 +28,12 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef ThreadableWebSocketChannel_h
-#define ThreadableWebSocketChannel_h
+#pragma once
 
 #if ENABLE(WEB_SOCKETS)
 
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
-#include <wtf/PassRefPtr.h>
 
 namespace JSC {
 class ArrayBuffer;
@@ -53,7 +51,7 @@
     WTF_MAKE_NONCOPYABLE(ThreadableWebSocketChannel);
 public:
     ThreadableWebSocketChannel() { }
-    static PassRefPtr<ThreadableWebSocketChannel> create(ScriptExecutionContext*, WebSocketChannelClient*);
+    static Ref<ThreadableWebSocketChannel> create(ScriptExecutionContext&, WebSocketChannelClient&);
 
     enum SendResult {
         SendSuccess,
@@ -88,5 +86,3 @@
 } // namespace WebCore
 
 #endif // ENABLE(WEB_SOCKETS)
-
-#endif // ThreadableWebSocketChannel_h

Modified: trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp	2016-06-08 22:27:46 UTC (rev 201837)
@@ -34,15 +34,14 @@
 
 #include "ScriptExecutionContext.h"
 #include "WebSocketChannelClient.h"
-#include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 #include <wtf/text/StringView.h>
 
 namespace WebCore {
 
-ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext* context, WebSocketChannelClient* client)
+ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext& context, WebSocketChannelClient& client)
     : m_context(context)
-    , m_client(client)
+    , m_client(&client)
     , m_peer(nullptr)
     , m_failedWebSocketChannelCreation(false)
     , m_syncMethodDone(true)
@@ -52,7 +51,7 @@
 {
 }
 
-Ref<ThreadableWebSocketChannelClientWrapper> ThreadableWebSocketChannelClientWrapper::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
+Ref<ThreadableWebSocketChannelClientWrapper> ThreadableWebSocketChannelClientWrapper::create(ScriptExecutionContext& context, WebSocketChannelClient& client)
 {
     return adoptRef(*new ThreadableWebSocketChannelClientWrapper(context, client));
 }
@@ -248,7 +247,7 @@
     if (!m_syncMethodDone) {
         // When a synchronous operation is in progress (i.e. the execution stack contains
         // WorkerThreadableWebSocketChannel::waitForMethodCompletion()), we cannot invoke callbacks in this run loop.
-        m_context->postTask([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext& context) {
+        m_context.postTask([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext& context) {
             ASSERT_UNUSED(context, context.isWorkerGlobalScope());
             processPendingTasks();
         });
@@ -257,7 +256,7 @@
 
     Vector<std::unique_ptr<ScriptExecutionContext::Task>> pendingTasks = WTFMove(m_pendingTasks);
     for (auto& task : pendingTasks)
-        task->performTask(*m_context);
+        task->performTask(m_context);
 }
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.h (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.h	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.h	2016-06-08 22:27:46 UTC (rev 201837)
@@ -28,8 +28,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef ThreadableWebSocketChannelClientWrapper_h
-#define ThreadableWebSocketChannelClientWrapper_h
+#pragma once
 
 #if ENABLE(WEB_SOCKETS)
 
@@ -50,7 +49,7 @@
 
 class ThreadableWebSocketChannelClientWrapper : public ThreadSafeRefCounted<ThreadableWebSocketChannelClientWrapper> {
 public:
-    static Ref<ThreadableWebSocketChannelClientWrapper> create(ScriptExecutionContext*, WebSocketChannelClient*);
+    static Ref<ThreadableWebSocketChannelClientWrapper> create(ScriptExecutionContext&, WebSocketChannelClient&);
 
     void clearSyncMethodDone();
     void setSyncMethodDone();
@@ -89,11 +88,11 @@
     void resume();
 
 private:
-    ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext*, WebSocketChannelClient*);
+    ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext&, WebSocketChannelClient&);
 
     void processPendingTasks();
 
-    ScriptExecutionContext* m_context;
+    ScriptExecutionContext& m_context;
     WebSocketChannelClient* m_client;
     WorkerThreadableWebSocketChannel::Peer* m_peer;
     bool m_failedWebSocketChannelCreation;
@@ -110,5 +109,3 @@
 } // namespace WebCore
 
 #endif // ENABLE(WEB_SOCKETS)
-
-#endif // ThreadableWebSocketChannelClientWrapper_h

Modified: trunk/Source/WebCore/Modules/websockets/WebSocket.cpp (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/WebSocket.cpp	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/WebSocket.cpp	2016-06-08 22:27:46 UTC (rev 201837)
@@ -250,7 +250,7 @@
         return;
     }
 
-    m_channel = ThreadableWebSocketChannel::create(scriptExecutionContext(), this);
+    m_channel = ThreadableWebSocketChannel::create(*scriptExecutionContext(), *this);
 
     // FIXME: There is a disagreement about restriction of subprotocols between WebSocket API and hybi-10 protocol
     // draft. The former simply says "only characters in the range U+0021 to U+007E are allowed," while the latter

Modified: trunk/Source/WebCore/Modules/websockets/WebSocketChannel.cpp (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/WebSocketChannel.cpp	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/WebSocketChannel.cpp	2016-06-08 22:27:46 UTC (rev 201837)
@@ -64,9 +64,9 @@
 
 const double TCPMaximumSegmentLifetime = 2 * 60.0;
 
-WebSocketChannel::WebSocketChannel(Document* document, WebSocketChannelClient* client)
-    : m_document(document)
-    , m_client(client)
+WebSocketChannel::WebSocketChannel(Document& document, WebSocketChannelClient& client)
+    : m_document(&document)
+    , m_client(&client)
     , m_resumeTimer(*this, &WebSocketChannel::resumeTimerFired)
     , m_suspended(false)
     , m_closing(false)
@@ -81,9 +81,7 @@
     , m_outgoingFrameQueueStatus(OutgoingFrameQueueOpen)
     , m_blobLoaderStatus(BlobLoaderNotStarted)
 {
-    ASSERT(m_document);
-
-    if (Page* page = m_document->page())
+    if (Page* page = document.page())
         m_identifier = page->progress().createUniqueIdentifier();
 
     LOG(Network, "WebSocketChannel %p ctor, identifier %lu", this, m_identifier);

Modified: trunk/Source/WebCore/Modules/websockets/WebSocketChannel.h (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/WebSocketChannel.h	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/WebSocketChannel.h	2016-06-08 22:27:46 UTC (rev 201837)
@@ -59,7 +59,7 @@
 {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    static Ref<WebSocketChannel> create(Document* document, WebSocketChannelClient* client) { return adoptRef(*new WebSocketChannel(document, client)); }
+    static Ref<WebSocketChannel> create(Document& document, WebSocketChannelClient& client) { return adoptRef(*new WebSocketChannel(document, client)); }
     virtual ~WebSocketChannel();
 
     bool send(const char* data, int length);
@@ -122,7 +122,7 @@
     void derefThreadableWebSocketChannel() override { deref(); }
 
 private:
-    WebSocketChannel(Document*, WebSocketChannelClient*);
+    WebSocketChannel(Document&, WebSocketChannelClient&);
 
     bool appendToBuffer(const char* data, size_t len);
     void skipBuffer(size_t len);

Modified: trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp	2016-06-08 22:27:46 UTC (rev 201837)
@@ -46,15 +46,14 @@
 #include "WorkerThread.h"
 #include <runtime/ArrayBuffer.h>
 #include <wtf/MainThread.h>
-#include <wtf/PassRefPtr.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
-WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerGlobalScope* context, WebSocketChannelClient* client, const String& taskMode)
+WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerGlobalScope& context, WebSocketChannelClient& client, const String& taskMode)
     : m_workerGlobalScope(context)
     , m_workerClientWrapper(ThreadableWebSocketChannelClientWrapper::create(context, client))
-    , m_bridge(Bridge::create(m_workerClientWrapper, m_workerGlobalScope, taskMode))
+    , m_bridge(Bridge::create(m_workerClientWrapper.copyRef(), m_workerGlobalScope.copyRef(), taskMode))
 {
     m_bridge->initialize();
 }
@@ -73,13 +72,11 @@
 
 String WorkerThreadableWebSocketChannel::subprotocol()
 {
-    ASSERT(m_workerClientWrapper);
     return m_workerClientWrapper->subprotocol();
 }
 
 String WorkerThreadableWebSocketChannel::extensions()
 {
-    ASSERT(m_workerClientWrapper);
     return m_workerClientWrapper->extensions();
 }
 
@@ -143,10 +140,10 @@
         m_bridge->resume();
 }
 
-WorkerThreadableWebSocketChannel::Peer::Peer(RefPtr<ThreadableWebSocketChannelClientWrapper>&& clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode)
+WorkerThreadableWebSocketChannel::Peer::Peer(Ref<ThreadableWebSocketChannelClientWrapper>&& clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext& context, const String& taskMode)
     : m_workerClientWrapper(WTFMove(clientWrapper))
     , m_loaderProxy(loaderProxy)
-    , m_mainWebSocketChannel(WebSocketChannel::create(downcast<Document>(context), this))
+    , m_mainWebSocketChannel(WebSocketChannel::create(downcast<Document>(context), *this))
     , m_taskMode(taskMode)
 {
     ASSERT(isMainThread());
@@ -170,12 +167,11 @@
 void WorkerThreadableWebSocketChannel::Peer::send(const String& message)
 {
     ASSERT(isMainThread());
-    if (!m_mainWebSocketChannel || !m_workerClientWrapper)
+    if (!m_mainWebSocketChannel)
         return;
 
     ThreadableWebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(message);
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), sendRequestResult] (ScriptExecutionContext&) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), sendRequestResult](ScriptExecutionContext&) mutable {
         workerClientWrapper->setSendRequestResult(sendRequestResult);
     }, m_taskMode);
 }
@@ -183,12 +179,11 @@
 void WorkerThreadableWebSocketChannel::Peer::send(const ArrayBuffer& binaryData)
 {
     ASSERT(isMainThread());
-    if (!m_mainWebSocketChannel || !m_workerClientWrapper)
+    if (!m_mainWebSocketChannel)
         return;
 
     ThreadableWebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(binaryData, 0, binaryData.byteLength());
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), sendRequestResult] (ScriptExecutionContext&) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), sendRequestResult](ScriptExecutionContext&) mutable {
         workerClientWrapper->setSendRequestResult(sendRequestResult);
     }, m_taskMode);
 }
@@ -196,12 +191,11 @@
 void WorkerThreadableWebSocketChannel::Peer::send(Blob& binaryData)
 {
     ASSERT(isMainThread());
-    if (!m_mainWebSocketChannel || !m_workerClientWrapper)
+    if (!m_mainWebSocketChannel)
         return;
 
     ThreadableWebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(binaryData);
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), sendRequestResult] (ScriptExecutionContext&) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), sendRequestResult](ScriptExecutionContext&) mutable {
         workerClientWrapper->setSendRequestResult(sendRequestResult);
     }, m_taskMode);
 }
@@ -209,12 +203,11 @@
 void WorkerThreadableWebSocketChannel::Peer::bufferedAmount()
 {
     ASSERT(isMainThread());
-    if (!m_mainWebSocketChannel || !m_workerClientWrapper)
+    if (!m_mainWebSocketChannel)
         return;
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
     unsigned long bufferedAmount = m_mainWebSocketChannel->bufferedAmount();
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), bufferedAmount] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), bufferedAmount](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->setBufferedAmount(bufferedAmount);
     }, m_taskMode);
@@ -265,10 +258,9 @@
 {
     ASSERT(isMainThread());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
     String subprotocol = m_mainWebSocketChannel->subprotocol();
     String extensions = m_mainWebSocketChannel->extensions();
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), subprotocol = subprotocol.isolatedCopy(), extensions = extensions.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), subprotocol = subprotocol.isolatedCopy(), extensions = extensions.isolatedCopy()](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->setSubprotocol(subprotocol);
         workerClientWrapper->setExtensions(extensions);
@@ -280,8 +272,7 @@
 {
     ASSERT(isMainThread());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), message = message.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), message = message.isolatedCopy()](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->didReceiveMessage(message);
     }, m_taskMode);
@@ -291,8 +282,7 @@
 {
     ASSERT(isMainThread());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), binaryData = WTFMove(binaryData)] (ScriptExecutionContext& context) mutable {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), binaryData = WTFMove(binaryData)](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->didReceiveBinaryData(WTFMove(binaryData));
     }, m_taskMode);
@@ -302,8 +292,7 @@
 {
     ASSERT(isMainThread());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), bufferedAmount] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), bufferedAmount](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->didUpdateBufferedAmount(bufferedAmount);
     }, m_taskMode);
@@ -313,8 +302,7 @@
 {
     ASSERT(isMainThread());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper)] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef()](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->didStartClosingHandshake();
     }, m_taskMode);
@@ -325,8 +313,7 @@
     ASSERT(isMainThread());
     m_mainWebSocketChannel = nullptr;
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), unhandledBufferedAmount, closingHandshakeCompletion, code, reason = reason.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), unhandledBufferedAmount, closingHandshakeCompletion, code, reason = reason.isolatedCopy()](ScriptExecutionContext& context) mutable {
             ASSERT_UNUSED(context, context.isWorkerGlobalScope());
             workerClientWrapper->didClose(unhandledBufferedAmount, closingHandshakeCompletion, code, reason);
         }, m_taskMode);
@@ -336,21 +323,19 @@
 {
     ASSERT(isMainThread());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper)] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef()](ScriptExecutionContext& context) mutable {
         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
         workerClientWrapper->didReceiveMessageError();
     }, m_taskMode);
 }
 
-WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerGlobalScope> workerGlobalScope, const String& taskMode)
-    : m_workerClientWrapper(workerClientWrapper)
-    , m_workerGlobalScope(workerGlobalScope)
+WorkerThreadableWebSocketChannel::Bridge::Bridge(Ref<ThreadableWebSocketChannelClientWrapper>&& workerClientWrapper, Ref<WorkerGlobalScope>&& workerGlobalScope, const String& taskMode)
+    : m_workerClientWrapper(WTFMove(workerClientWrapper))
+    , m_workerGlobalScope(WTFMove(workerGlobalScope))
     , m_loaderProxy(m_workerGlobalScope->thread().workerLoaderProxy())
     , m_taskMode(taskMode)
     , m_peer(nullptr)
 {
-    ASSERT(m_workerClientWrapper.get());
 }
 
 WorkerThreadableWebSocketChannel::Bridge::~Bridge()
@@ -358,21 +343,18 @@
     disconnect();
 }
 
-void WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize(ScriptExecutionContext& context, WorkerLoaderProxy* loaderProxy, RefPtr<ThreadableWebSocketChannelClientWrapper>&& passedClientWrapper, const String& taskMode)
+void WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize(ScriptExecutionContext& context, WorkerLoaderProxy& loaderProxy, Ref<ThreadableWebSocketChannelClientWrapper>&& clientWrapper, const String& taskMode)
 {
     ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context.isDocument());
+    ASSERT(context.isDocument());
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper = WTFMove(passedClientWrapper);
-
-    auto peer = std::make_unique<Peer>(clientWrapper.copyRef(), *loaderProxy, &context, taskMode);
-    bool sent = loaderProxy->postTaskForModeToWorkerGlobalScope({
+    bool sent = loaderProxy.postTaskForModeToWorkerGlobalScope({
         ScriptExecutionContext::Task::CleanupTask,
-        [clientWrapper, loaderProxy, peer = WTFMove(peer)] (ScriptExecutionContext& context) mutable {
+        [clientWrapper = clientWrapper.copyRef(), &loaderProxy, peer = std::make_unique<Peer>(clientWrapper.copyRef(), loaderProxy, context, taskMode)](ScriptExecutionContext& context) mutable {
             ASSERT_UNUSED(context, context.isWorkerGlobalScope());
             if (clientWrapper->failedWebSocketChannelCreation()) {
                 // If Bridge::initialize() quitted earlier, we need to kick mainThreadDestroy() to delete the peer.
-                loaderProxy->postTaskToLoader([peer = WTFMove(peer)] (ScriptExecutionContext& context) {
+                loaderProxy.postTaskToLoader([peer = WTFMove(peer)](ScriptExecutionContext& context) {
                     ASSERT(isMainThread());
                     ASSERT_UNUSED(context, context.isDocument());
                 });
@@ -391,8 +373,7 @@
     setMethodNotCompleted();
     Ref<Bridge> protectedThis(*this);
 
-    RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
-    m_loaderProxy.postTaskToLoader([loaderProxy = &m_loaderProxy, workerClientWrapper = WTFMove(workerClientWrapper), taskMode = m_taskMode.isolatedCopy()] (ScriptExecutionContext& context) mutable {
+    m_loaderProxy.postTaskToLoader([&loaderProxy = m_loaderProxy, workerClientWrapper = m_workerClientWrapper.copyRef(), taskMode = m_taskMode.isolatedCopy()](ScriptExecutionContext& context) mutable {
         mainThreadInitialize(context, loaderProxy, WTFMove(workerClientWrapper), taskMode);
     });
     waitForMethodCompletion();
@@ -405,11 +386,10 @@
 
 void WorkerThreadableWebSocketChannel::Bridge::connect(const URL& url, const String& protocol)
 {
-    ASSERT(m_workerClientWrapper);
     if (!m_peer)
         return;
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer, url = "" protocol = protocol.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer, url = "" protocol = protocol.isolatedCopy()](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -420,11 +400,11 @@
 
 ThreadableWebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const String& message)
 {
-    if (!m_workerClientWrapper || !m_peer)
+    if (!m_peer)
         return ThreadableWebSocketChannel::SendFail;
     setMethodNotCompleted();
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer, message = message.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer, message = message.isolatedCopy()](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -434,15 +414,12 @@
 
     Ref<Bridge> protectedThis(*this);
     waitForMethodCompletion();
-    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
-    if (!clientWrapper)
-        return ThreadableWebSocketChannel::SendFail;
-    return clientWrapper->sendRequestResult();
+    return m_workerClientWrapper->sendRequestResult();
 }
 
 ThreadableWebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
 {
-    if (!m_workerClientWrapper || !m_peer)
+    if (!m_peer)
         return ThreadableWebSocketChannel::SendFail;
 
     // ArrayBuffer isn't thread-safe, hence the content of ArrayBuffer is copied into Vector<char>.
@@ -451,7 +428,7 @@
         memcpy(data.data(), static_cast<const char*>(binaryData.data()) + byteOffset, byteLength);
     setMethodNotCompleted();
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer, data = "" (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer, data = "" context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -462,19 +439,16 @@
 
     Ref<Bridge> protectedThis(*this);
     waitForMethodCompletion();
-    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
-    if (!clientWrapper)
-        return ThreadableWebSocketChannel::SendFail;
-    return clientWrapper->sendRequestResult();
+    return m_workerClientWrapper->sendRequestResult();
 }
 
 ThreadableWebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(Blob& binaryData)
 {
-    if (!m_workerClientWrapper || !m_peer)
+    if (!m_peer)
         return ThreadableWebSocketChannel::SendFail;
     setMethodNotCompleted();
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer, url = "" type = binaryData.type().isolatedCopy(), size = binaryData.size()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer, url = "" type = binaryData.type().isolatedCopy(), size = binaryData.size()](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -484,19 +458,16 @@
 
     Ref<Bridge> protectedThis(*this);
     waitForMethodCompletion();
-    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
-    if (!clientWrapper)
-        return ThreadableWebSocketChannel::SendFail;
-    return clientWrapper->sendRequestResult();
+    return m_workerClientWrapper->sendRequestResult();
 }
 
 unsigned long WorkerThreadableWebSocketChannel::Bridge::bufferedAmount()
 {
-    if (!m_workerClientWrapper || !m_peer)
+    if (!m_peer)
         return 0;
     setMethodNotCompleted();
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -506,10 +477,7 @@
 
     Ref<Bridge> protectedThis(*this);
     waitForMethodCompletion();
-    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
-    if (clientWrapper)
-        return clientWrapper->bufferedAmount();
-    return 0;
+    return m_workerClientWrapper->bufferedAmount();
 }
 
 void WorkerThreadableWebSocketChannel::Bridge::close(int code, const String& reason)
@@ -517,7 +485,7 @@
     if (!m_peer)
         return;
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer, code, reason = reason.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer, code, reason = reason.isolatedCopy()](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -531,7 +499,7 @@
     if (!m_peer)
         return;
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer, reason = reason.isolatedCopy()] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer, reason = reason.isolatedCopy()](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -544,7 +512,7 @@
 {
     clearClientWrapper();
     if (m_peer) {
-        m_loaderProxy.postTaskToLoader([peer = std::unique_ptr<Peer>(m_peer)] (ScriptExecutionContext& context) {
+        m_loaderProxy.postTaskToLoader([peer = std::unique_ptr<Peer>(m_peer)](ScriptExecutionContext& context) {
             ASSERT(isMainThread());
             ASSERT_UNUSED(context, context.isDocument());
         });
@@ -558,7 +526,7 @@
     if (!m_peer)
         return;
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -572,7 +540,7 @@
     if (!m_peer)
         return;
 
-    m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
+    m_loaderProxy.postTaskToLoader([peer = m_peer](ScriptExecutionContext& context) {
         ASSERT(isMainThread());
         ASSERT_UNUSED(context, context.isDocument());
         ASSERT(peer);
@@ -588,7 +556,6 @@
 
 void WorkerThreadableWebSocketChannel::Bridge::setMethodNotCompleted()
 {
-    ASSERT(m_workerClientWrapper);
     m_workerClientWrapper->clearSyncMethodDone();
 }
 
@@ -600,10 +567,10 @@
         return;
     WorkerRunLoop& runLoop = m_workerGlobalScope->thread().runLoop();
     MessageQueueWaitResult result = MessageQueueMessageReceived;
-    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
+    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.ptr();
     while (m_workerGlobalScope && clientWrapper && !clientWrapper->syncMethodDone() && result != MessageQueueTerminated) {
         result = runLoop.runInMode(m_workerGlobalScope.get(), m_taskMode); // May cause this bridge to get disconnected, which makes m_workerGlobalScope become null.
-        clientWrapper = m_workerClientWrapper.get();
+        clientWrapper = m_workerClientWrapper.ptr();
     }
 }
 

Modified: trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.h (201836 => 201837)


--- trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.h	2016-06-08 22:22:49 UTC (rev 201836)
+++ trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.h	2016-06-08 22:27:46 UTC (rev 201837)
@@ -28,8 +28,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WorkerThreadableWebSocketChannel_h
-#define WorkerThreadableWebSocketChannel_h
+#pragma once
 
 #if ENABLE(WEB_SOCKETS)
 
@@ -37,7 +36,6 @@
 #include "WebSocketChannelClient.h"
 #include "WorkerGlobalScope.h"
 
-#include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
 #include <wtf/Threading.h>
@@ -55,7 +53,7 @@
 class WorkerThreadableWebSocketChannel : public RefCounted<WorkerThreadableWebSocketChannel>, public ThreadableWebSocketChannel {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    static Ref<ThreadableWebSocketChannel> create(WorkerGlobalScope* workerGlobalScope, WebSocketChannelClient* client, const String& taskMode)
+    static Ref<ThreadableWebSocketChannel> create(WorkerGlobalScope& workerGlobalScope, WebSocketChannelClient& client, const String& taskMode)
     {
         return adoptRef(*new WorkerThreadableWebSocketChannel(workerGlobalScope, client, taskMode));
     }
@@ -80,7 +78,7 @@
     class Peer : public WebSocketChannelClient {
         WTF_MAKE_NONCOPYABLE(Peer); WTF_MAKE_FAST_ALLOCATED;
     public:
-        Peer(RefPtr<ThreadableWebSocketChannelClientWrapper>&&, WorkerLoaderProxy&, ScriptExecutionContext*, const String& taskMode);
+        Peer(Ref<ThreadableWebSocketChannelClientWrapper>&&, WorkerLoaderProxy&, ScriptExecutionContext&, const String& taskMode);
         ~Peer();
 
         void connect(const URL&, const String& protocol);
@@ -104,7 +102,7 @@
         void didReceiveMessageError() override;
 
     private:
-        RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
+        Ref<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
         WorkerLoaderProxy& m_loaderProxy;
         RefPtr<ThreadableWebSocketChannel> m_mainWebSocketChannel;
         String m_taskMode;
@@ -121,9 +119,9 @@
     // Bridge for Peer.  Running on the worker thread.
     class Bridge : public RefCounted<Bridge> {
     public:
-        static Ref<Bridge> create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerGlobalScope> workerGlobalScope, const String& taskMode)
+        static Ref<Bridge> create(Ref<ThreadableWebSocketChannelClientWrapper>&& workerClientWrapper, Ref<WorkerGlobalScope>&& workerGlobalScope, const String& taskMode)
         {
-            return adoptRef(*new Bridge(workerClientWrapper, workerGlobalScope, taskMode));
+            return adoptRef(*new Bridge(WTFMove(workerClientWrapper), WTFMove(workerGlobalScope), taskMode));
         }
         ~Bridge();
         void initialize();
@@ -142,12 +140,12 @@
         using RefCounted<Bridge>::deref;
 
     private:
-        Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, PassRefPtr<WorkerGlobalScope>, const String& taskMode);
+        Bridge(Ref<ThreadableWebSocketChannelClientWrapper>&&, Ref<WorkerGlobalScope>&&, const String& taskMode);
 
-        static void setWebSocketChannel(ScriptExecutionContext*, Bridge* thisPtr, Peer*, PassRefPtr<ThreadableWebSocketChannelClientWrapper>);
+        static void setWebSocketChannel(ScriptExecutionContext*, Bridge* thisPtr, Peer*, Ref<ThreadableWebSocketChannelClientWrapper>&&);
 
         // Executed on the main thread to create a Peer for this bridge.
-        static void mainThreadInitialize(ScriptExecutionContext&, WorkerLoaderProxy*, RefPtr<ThreadableWebSocketChannelClientWrapper>&&, const String& taskMode);
+        static void mainThreadInitialize(ScriptExecutionContext&, WorkerLoaderProxy&, Ref<ThreadableWebSocketChannelClientWrapper>&&, const String& taskMode);
 
         // Executed on the worker context's thread.
         void clearClientWrapper();
@@ -155,24 +153,22 @@
         void setMethodNotCompleted();
         void waitForMethodCompletion();
 
-        RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
+        Ref<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
         RefPtr<WorkerGlobalScope> m_workerGlobalScope;
         WorkerLoaderProxy& m_loaderProxy;
         String m_taskMode;
         Peer* m_peer;
     };
 
-    WorkerThreadableWebSocketChannel(WorkerGlobalScope*, WebSocketChannelClient*, const String& taskMode);
+    WorkerThreadableWebSocketChannel(WorkerGlobalScope&, WebSocketChannelClient&, const String& taskMode);
 
     class WorkerGlobalScopeDidInitializeTask;
 
-    RefPtr<WorkerGlobalScope> m_workerGlobalScope;
-    RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
+    Ref<WorkerGlobalScope> m_workerGlobalScope;
+    Ref<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
     RefPtr<Bridge> m_bridge;
 };
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_SOCKETS)
-
-#endif // WorkerThreadableWebSocketChannel_h
_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to