⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 201837 in webkit


Ignore:
Timestamp:
Jun 8, 2016, 3:27:46 PM (10 years ago)
Author:
achristensen@apple.com
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):

Location:
trunk/Source/WebCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r201835 r201837  
     12016-06-08  Alex Christensen  <achristensen@webkit.org>
     2
     3        Modernize WebSocket code
     4        https://bugs.webkit.org/show_bug.cgi?id=158539
     5
     6        Reviewed by Brady Eidson.
     7
     8        No new tests, no change in behavior.
     9
     10        * Modules/websockets/ThreadableWebSocketChannel.cpp:
     11        (WebCore::ThreadableWebSocketChannel::create):
     12        * Modules/websockets/ThreadableWebSocketChannel.h:
     13        (WebCore::ThreadableWebSocketChannel::ThreadableWebSocketChannel):
     14        * Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp:
     15        (WebCore::ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper):
     16        (WebCore::ThreadableWebSocketChannelClientWrapper::create):
     17        (WebCore::ThreadableWebSocketChannelClientWrapper::processPendingTasks):
     18        * Modules/websockets/ThreadableWebSocketChannelClientWrapper.h:
     19        * Modules/websockets/WebSocket.cpp:
     20        (WebCore::WebSocket::connect):
     21        * Modules/websockets/WebSocketChannel.cpp:
     22        (WebCore::WebSocketChannel::WebSocketChannel):
     23        * Modules/websockets/WebSocketChannel.h:
     24        (WebCore::WebSocketChannel::create):
     25        * Modules/websockets/WorkerThreadableWebSocketChannel.cpp:
     26        (WebCore::WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel):
     27        (WebCore::WorkerThreadableWebSocketChannel::subprotocol):
     28        (WebCore::WorkerThreadableWebSocketChannel::extensions):
     29        (WebCore::WorkerThreadableWebSocketChannel::resume):
     30        (WebCore::WorkerThreadableWebSocketChannel::Peer::Peer):
     31        (WebCore::WorkerThreadableWebSocketChannel::Peer::send):
     32        (WebCore::WorkerThreadableWebSocketChannel::Peer::bufferedAmount):
     33        (WebCore::WorkerThreadableWebSocketChannel::Peer::didConnect):
     34        (WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveMessage):
     35        (WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveBinaryData):
     36        (WebCore::WorkerThreadableWebSocketChannel::Peer::didUpdateBufferedAmount):
     37        (WebCore::WorkerThreadableWebSocketChannel::Peer::didStartClosingHandshake):
     38        (WebCore::WorkerThreadableWebSocketChannel::Peer::didClose):
     39        (WebCore::WorkerThreadableWebSocketChannel::Peer::didReceiveMessageError):
     40        (WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
     41        (WebCore::WorkerThreadableWebSocketChannel::Bridge::~Bridge):
     42        (WebCore::WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize):
     43        (WebCore::WorkerThreadableWebSocketChannel::Bridge::initialize):
     44        (WebCore::WorkerThreadableWebSocketChannel::Bridge::connect):
     45        (WebCore::WorkerThreadableWebSocketChannel::Bridge::send):
     46        (WebCore::WorkerThreadableWebSocketChannel::Bridge::bufferedAmount):
     47        (WebCore::WorkerThreadableWebSocketChannel::Bridge::close):
     48        (WebCore::WorkerThreadableWebSocketChannel::Bridge::setMethodNotCompleted):
     49        (WebCore::WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion):
     50        * Modules/websockets/WorkerThreadableWebSocketChannel.h:
     51        (WebCore::WorkerThreadableWebSocketChannel::create):
     52        (WebCore::WorkerThreadableWebSocketChannel::Bridge::create):
     53
    1542016-06-08  Chris Dumez  <cdumez@apple.com>
    255

  • trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.cpp

    r174225 r201837  
    4444#include "WorkerThread.h"
    4545#include "WorkerThreadableWebSocketChannel.h"
    46 #include <wtf/PassRefPtr.h>
    4746#include <wtf/text/StringBuilder.h>
    4847
    … …  
    5150static const char webSocketChannelMode[] = "webSocketChannelMode";
    5251
    53 PassRefPtr<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
     52Ref<ThreadableWebSocketChannel> ThreadableWebSocketChannel::create(ScriptExecutionContext& context, WebSocketChannelClient& client)
    5453{
    55     ASSERT(context);
    56     ASSERT(client);
    57 
    58     if (is<WorkerGlobalScope>(*context)) {
    59         WorkerGlobalScope& workerGlobalScope = downcast<WorkerGlobalScope>(*context);
     54    if (is<WorkerGlobalScope>(context)) {
     55        WorkerGlobalScope& workerGlobalScope = downcast<WorkerGlobalScope>(context);
    6056        WorkerRunLoop& runLoop = workerGlobalScope.thread().runLoop();
    6157        StringBuilder mode;
    6258        mode.appendLiteral(webSocketChannelMode);
    6359        mode.appendNumber(runLoop.createUniqueId());
    64         return WorkerThreadableWebSocketChannel::create(&workerGlobalScope, client, mode.toString());
     60        return WorkerThreadableWebSocketChannel::create(workerGlobalScope, client, mode.toString());
    6561    }
    6662

  • trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h

    r168183 r201837  
    2929 */
    3030
    31 #ifndef ThreadableWebSocketChannel_h
    32 #define ThreadableWebSocketChannel_h
     31#pragma once
    3332
    3433#if ENABLE(WEB_SOCKETS)
    … …  
    3635#include <wtf/Forward.h>
    3736#include <wtf/Noncopyable.h>
    38 #include <wtf/PassRefPtr.h>
    3937
    4038namespace JSC {
    … …  
    5452public:
    5553    ThreadableWebSocketChannel() { }
    56     static PassRefPtr<ThreadableWebSocketChannel> create(ScriptExecutionContext*, WebSocketChannelClient*);
     54    static Ref<ThreadableWebSocketChannel> create(ScriptExecutionContext&, WebSocketChannelClient&);
    5755
    5856    enum SendResult {
    … …  
    8987
    9088#endif // ENABLE(WEB_SOCKETS)
    91 
    92 #endif // ThreadableWebSocketChannel_h

  • trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.cpp

    r201602 r201837  
    3535#include "ScriptExecutionContext.h"
    3636#include "WebSocketChannelClient.h"
    37 #include <wtf/PassRefPtr.h>
    3837#include <wtf/RefPtr.h>
    3938#include <wtf/text/StringView.h>
    … …  
    4140namespace WebCore {
    4241
    43 ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext* context, WebSocketChannelClient* client)
     42ThreadableWebSocketChannelClientWrapper::ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext& context, WebSocketChannelClient& client)
    4443    : m_context(context)
    45     , m_client(client)
     44    , m_client(&client)
    4645    , m_peer(nullptr)
    4746    , m_failedWebSocketChannelCreation(false)
    … …  
    5352}
    5453
    55 Ref<ThreadableWebSocketChannelClientWrapper> ThreadableWebSocketChannelClientWrapper::create(ScriptExecutionContext* context, WebSocketChannelClient* client)
     54Ref<ThreadableWebSocketChannelClientWrapper> ThreadableWebSocketChannelClientWrapper::create(ScriptExecutionContext& context, WebSocketChannelClient& client)
    5655{
    5756    return adoptRef(*new ThreadableWebSocketChannelClientWrapper(context, client));
    … …  
    249248        // When a synchronous operation is in progress (i.e. the execution stack contains
    250249        // WorkerThreadableWebSocketChannel::waitForMethodCompletion()), we cannot invoke callbacks in this run loop.
    251         m_context->postTask([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext& context) {
     250        m_context.postTask([this, protectedThis = Ref<ThreadableWebSocketChannelClientWrapper>(*this)] (ScriptExecutionContext& context) {
    252251            ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    253252            processPendingTasks();
    … …  
    258257    Vector<std::unique_ptr<ScriptExecutionContext::Task>> pendingTasks = WTFMove(m_pendingTasks);
    259258    for (auto& task : pendingTasks)
    260         task->performTask(*m_context);
     259        task->performTask(m_context);
    261260}
    262261

  • trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannelClientWrapper.h

    r198869 r201837  
    2929 */
    3030
    31 #ifndef ThreadableWebSocketChannelClientWrapper_h
    32 #define ThreadableWebSocketChannelClientWrapper_h
     31#pragma once
    3332
    3433#if ENABLE(WEB_SOCKETS)
    … …  
    5150class ThreadableWebSocketChannelClientWrapper : public ThreadSafeRefCounted<ThreadableWebSocketChannelClientWrapper> {
    5251public:
    53     static Ref<ThreadableWebSocketChannelClientWrapper> create(ScriptExecutionContext*, WebSocketChannelClient*);
     52    static Ref<ThreadableWebSocketChannelClientWrapper> create(ScriptExecutionContext&, WebSocketChannelClient&);
    5453
    5554    void clearSyncMethodDone();
    … …  
    9089
    9190private:
    92     ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext*, WebSocketChannelClient*);
     91    ThreadableWebSocketChannelClientWrapper(ScriptExecutionContext&, WebSocketChannelClient&);
    9392
    9493    void processPendingTasks();
    9594
    96     ScriptExecutionContext* m_context;
     95    ScriptExecutionContext& m_context;
    9796    WebSocketChannelClient* m_client;
    9897    WorkerThreadableWebSocketChannel::Peer* m_peer;
    … …  
    111110
    112111#endif // ENABLE(WEB_SOCKETS)
    113 
    114 #endif // ThreadableWebSocketChannelClientWrapper_h

  • trunk/Source/WebCore/Modules/websockets/WebSocket.cpp

    r201753 r201837  
    251251    }
    252252
    253     m_channel = ThreadableWebSocketChannel::create(scriptExecutionContext(), this);
     253    m_channel = ThreadableWebSocketChannel::create(*scriptExecutionContext(), *this);
    254254
    255255    // FIXME: There is a disagreement about restriction of subprotocols between WebSocket API and hybi-10 protocol

  • trunk/Source/WebCore/Modules/websockets/WebSocketChannel.cpp

    r200895 r201837  
    6565const double TCPMaximumSegmentLifetime = 2 * 60.0;
    6666
    67 WebSocketChannel::WebSocketChannel(Document* document, WebSocketChannelClient* client)
    68     : m_document(document)
    69     , m_client(client)
     67WebSocketChannel::WebSocketChannel(Document& document, WebSocketChannelClient& client)
     68    : m_document(&document)
     69    , m_client(&client)
    7070    , m_resumeTimer(*this, &WebSocketChannel::resumeTimerFired)
    7171    , m_suspended(false)
    … …  
    8282    , m_blobLoaderStatus(BlobLoaderNotStarted)
    8383{
    84     ASSERT(m_document);
    85 
    86     if (Page* page = m_document->page())
     84    if (Page* page = document.page())
    8785        m_identifier = page->progress().createUniqueIdentifier();
    8886

  • trunk/Source/WebCore/Modules/websockets/WebSocketChannel.h

    r198869 r201837  
    6060    WTF_MAKE_FAST_ALLOCATED;
    6161public:
    62     static Ref<WebSocketChannel> create(Document* document, WebSocketChannelClient* client) { return adoptRef(*new WebSocketChannel(document, client)); }
     62    static Ref<WebSocketChannel> create(Document& document, WebSocketChannelClient& client) { return adoptRef(*new WebSocketChannel(document, client)); }
    6363    virtual ~WebSocketChannel();
    6464
    … …  
    123123
    124124private:
    125     WebSocketChannel(Document*, WebSocketChannelClient*);
     125    WebSocketChannel(Document&, WebSocketChannelClient&);
    126126
    127127    bool appendToBuffer(const char* data, size_t len);

  • trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp

    r201602 r201837  
    4747#include <runtime/ArrayBuffer.h>
    4848#include <wtf/MainThread.h>
    49 #include <wtf/PassRefPtr.h>
    5049#include <wtf/text/WTFString.h>
    5150
    5251namespace WebCore {
    5352
    54 WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerGlobalScope* context, WebSocketChannelClient* client, const String& taskMode)
     53WorkerThreadableWebSocketChannel::WorkerThreadableWebSocketChannel(WorkerGlobalScope& context, WebSocketChannelClient& client, const String& taskMode)
    5554    : m_workerGlobalScope(context)
    5655    , m_workerClientWrapper(ThreadableWebSocketChannelClientWrapper::create(context, client))
    57     , m_bridge(Bridge::create(m_workerClientWrapper, m_workerGlobalScope, taskMode))
     56    , m_bridge(Bridge::create(m_workerClientWrapper.copyRef(), m_workerGlobalScope.copyRef(), taskMode))
    5857{
    5958    m_bridge->initialize();
    … …  
    7473String WorkerThreadableWebSocketChannel::subprotocol()
    7574{
    76     ASSERT(m_workerClientWrapper);
    7775    return m_workerClientWrapper->subprotocol();
    7876}
    … …  
    8078String WorkerThreadableWebSocketChannel::extensions()
    8179{
    82     ASSERT(m_workerClientWrapper);
    8380    return m_workerClientWrapper->extensions();
    8481}
    … …  
    144141}
    145142
    146 WorkerThreadableWebSocketChannel::Peer::Peer(RefPtr<ThreadableWebSocketChannelClientWrapper>&& clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext* context, const String& taskMode)
     143WorkerThreadableWebSocketChannel::Peer::Peer(Ref<ThreadableWebSocketChannelClientWrapper>&& clientWrapper, WorkerLoaderProxy& loaderProxy, ScriptExecutionContext& context, const String& taskMode)
    147144    : m_workerClientWrapper(WTFMove(clientWrapper))
    148145    , m_loaderProxy(loaderProxy)
    149     , m_mainWebSocketChannel(WebSocketChannel::create(downcast<Document>(context), this))
     146    , m_mainWebSocketChannel(WebSocketChannel::create(downcast<Document>(context), *this))
    150147    , m_taskMode(taskMode)
    151148{
    … …  
    171168{
    172169    ASSERT(isMainThread());
    173     if (!m_mainWebSocketChannel || !m_workerClientWrapper)
     170    if (!m_mainWebSocketChannel)
    174171        return;
    175172
    176173    ThreadableWebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(message);
    177     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    178     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), sendRequestResult] (ScriptExecutionContext&) {
     174    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), sendRequestResult](ScriptExecutionContext&) mutable {
    179175        workerClientWrapper->setSendRequestResult(sendRequestResult);
    180176    }, m_taskMode);
    … …  
    184180{
    185181    ASSERT(isMainThread());
    186     if (!m_mainWebSocketChannel || !m_workerClientWrapper)
     182    if (!m_mainWebSocketChannel)
    187183        return;
    188184
    189185    ThreadableWebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(binaryData, 0, binaryData.byteLength());
    190     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    191     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), sendRequestResult] (ScriptExecutionContext&) {
     186    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), sendRequestResult](ScriptExecutionContext&) mutable {
    192187        workerClientWrapper->setSendRequestResult(sendRequestResult);
    193188    }, m_taskMode);
    … …  
    197192{
    198193    ASSERT(isMainThread());
    199     if (!m_mainWebSocketChannel || !m_workerClientWrapper)
     194    if (!m_mainWebSocketChannel)
    200195        return;
    201196
    202197    ThreadableWebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(binaryData);
    203     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    204     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), sendRequestResult] (ScriptExecutionContext&) {
     198    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), sendRequestResult](ScriptExecutionContext&) mutable {
    205199        workerClientWrapper->setSendRequestResult(sendRequestResult);
    206200    }, m_taskMode);
    … …  
    210204{
    211205    ASSERT(isMainThread());
    212     if (!m_mainWebSocketChannel || !m_workerClientWrapper)
    213         return;
    214 
    215     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
     206    if (!m_mainWebSocketChannel)
     207        return;
     208
    216209    unsigned long bufferedAmount = m_mainWebSocketChannel->bufferedAmount();
    217     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), bufferedAmount] (ScriptExecutionContext& context) {
     210    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), bufferedAmount](ScriptExecutionContext& context) mutable {
    218211        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    219212        workerClientWrapper->setBufferedAmount(bufferedAmount);
    … …  
    266259    ASSERT(isMainThread());
    267260
    268     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    269261    String subprotocol = m_mainWebSocketChannel->subprotocol();
    270262    String extensions = m_mainWebSocketChannel->extensions();
    271     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), subprotocol = subprotocol.isolatedCopy(), extensions = extensions.isolatedCopy()] (ScriptExecutionContext& context) {
     263    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), subprotocol = subprotocol.isolatedCopy(), extensions = extensions.isolatedCopy()](ScriptExecutionContext& context) mutable {
    272264        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    273265        workerClientWrapper->setSubprotocol(subprotocol);
    … …  
    281273    ASSERT(isMainThread());
    282274
    283     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    284     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), message = message.isolatedCopy()] (ScriptExecutionContext& context) {
     275    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), message = message.isolatedCopy()](ScriptExecutionContext& context) mutable {
    285276        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    286277        workerClientWrapper->didReceiveMessage(message);
    … …  
    292283    ASSERT(isMainThread());
    293284
    294     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    295     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), binaryData = WTFMove(binaryData)] (ScriptExecutionContext& context) mutable {
     285    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), binaryData = WTFMove(binaryData)](ScriptExecutionContext& context) mutable {
    296286        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    297287        workerClientWrapper->didReceiveBinaryData(WTFMove(binaryData));
    … …  
    303293    ASSERT(isMainThread());
    304294
    305     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    306     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), bufferedAmount] (ScriptExecutionContext& context) {
     295    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), bufferedAmount](ScriptExecutionContext& context) mutable {
    307296        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    308297        workerClientWrapper->didUpdateBufferedAmount(bufferedAmount);
    … …  
    314303    ASSERT(isMainThread());
    315304
    316     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    317     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper)] (ScriptExecutionContext& context) {
     305    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef()](ScriptExecutionContext& context) mutable {
    318306        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    319307        workerClientWrapper->didStartClosingHandshake();
    … …  
    326314    m_mainWebSocketChannel = nullptr;
    327315
    328     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    329     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper), unhandledBufferedAmount, closingHandshakeCompletion, code, reason = reason.isolatedCopy()] (ScriptExecutionContext& context) {
     316    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef(), unhandledBufferedAmount, closingHandshakeCompletion, code, reason = reason.isolatedCopy()](ScriptExecutionContext& context) mutable {
    330317            ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    331318            workerClientWrapper->didClose(unhandledBufferedAmount, closingHandshakeCompletion, code, reason);
    … …  
    337324    ASSERT(isMainThread());
    338325
    339     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    340     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = WTFMove(workerClientWrapper)] (ScriptExecutionContext& context) {
     326    m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = m_workerClientWrapper.copyRef()](ScriptExecutionContext& context) mutable {
    341327        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    342328        workerClientWrapper->didReceiveMessageError();
    … …  
    344330}
    345331
    346 WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerGlobalScope> workerGlobalScope, const String& taskMode)
    347     : m_workerClientWrapper(workerClientWrapper)
    348     , m_workerGlobalScope(workerGlobalScope)
     332WorkerThreadableWebSocketChannel::Bridge::Bridge(Ref<ThreadableWebSocketChannelClientWrapper>&& workerClientWrapper, Ref<WorkerGlobalScope>&& workerGlobalScope, const String& taskMode)
     333    : m_workerClientWrapper(WTFMove(workerClientWrapper))
     334    , m_workerGlobalScope(WTFMove(workerGlobalScope))
    349335    , m_loaderProxy(m_workerGlobalScope->thread().workerLoaderProxy())
    350336    , m_taskMode(taskMode)
    351337    , m_peer(nullptr)
    352338{
    353     ASSERT(m_workerClientWrapper.get());
    354339}
    355340
    … …  
    359344}
    360345
    361 void WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize(ScriptExecutionContext& context, WorkerLoaderProxy* loaderProxy, RefPtr<ThreadableWebSocketChannelClientWrapper>&& passedClientWrapper, const String& taskMode)
    362 {
    363     ASSERT(isMainThread());
    364     ASSERT_UNUSED(context, context.isDocument());
    365 
    366     RefPtr<ThreadableWebSocketChannelClientWrapper> clientWrapper = WTFMove(passedClientWrapper);
    367 
    368     auto peer = std::make_unique<Peer>(clientWrapper.copyRef(), *loaderProxy, &context, taskMode);
    369     bool sent = loaderProxy->postTaskForModeToWorkerGlobalScope({
     346void WorkerThreadableWebSocketChannel::Bridge::mainThreadInitialize(ScriptExecutionContext& context, WorkerLoaderProxy& loaderProxy, Ref<ThreadableWebSocketChannelClientWrapper>&& clientWrapper, const String& taskMode)
     347{
     348    ASSERT(isMainThread());
     349    ASSERT(context.isDocument());
     350
     351    bool sent = loaderProxy.postTaskForModeToWorkerGlobalScope({
    370352        ScriptExecutionContext::Task::CleanupTask,
    371         [clientWrapper, loaderProxy, peer = WTFMove(peer)] (ScriptExecutionContext& context) mutable {
     353        [clientWrapper = clientWrapper.copyRef(), &loaderProxy, peer = std::make_unique<Peer>(clientWrapper.copyRef(), loaderProxy, context, taskMode)](ScriptExecutionContext& context) mutable {
    372354            ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    373355            if (clientWrapper->failedWebSocketChannelCreation()) {
    374356                // If Bridge::initialize() quitted earlier, we need to kick mainThreadDestroy() to delete the peer.
    375                 loaderProxy->postTaskToLoader([peer = WTFMove(peer)] (ScriptExecutionContext& context) {
     357                loaderProxy.postTaskToLoader([peer = WTFMove(peer)](ScriptExecutionContext& context) {
    376358                    ASSERT(isMainThread());
    377359                    ASSERT_UNUSED(context, context.isDocument());
    … …  
    392374    Ref<Bridge> protectedThis(*this);
    393375
    394     RefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper = m_workerClientWrapper;
    395     m_loaderProxy.postTaskToLoader([loaderProxy = &m_loaderProxy, workerClientWrapper = WTFMove(workerClientWrapper), taskMode = m_taskMode.isolatedCopy()] (ScriptExecutionContext& context) mutable {
     376    m_loaderProxy.postTaskToLoader([&loaderProxy = m_loaderProxy, workerClientWrapper = m_workerClientWrapper.copyRef(), taskMode = m_taskMode.isolatedCopy()](ScriptExecutionContext& context) mutable {
    396377        mainThreadInitialize(context, loaderProxy, WTFMove(workerClientWrapper), taskMode);
    397378    });
    … …  
    406387void WorkerThreadableWebSocketChannel::Bridge::connect(const URL& url, const String& protocol)
    407388{
    408     ASSERT(m_workerClientWrapper);
    409     if (!m_peer)
    410         return;
    411 
    412     m_loaderProxy.postTaskToLoader([peer = m_peer, url = url.isolatedCopy(), protocol = protocol.isolatedCopy()] (ScriptExecutionContext& context) {
     389    if (!m_peer)
     390        return;
     391
     392    m_loaderProxy.postTaskToLoader([peer = m_peer, url = url.isolatedCopy(), protocol = protocol.isolatedCopy()](ScriptExecutionContext& context) {
    413393        ASSERT(isMainThread());
    414394        ASSERT_UNUSED(context, context.isDocument());
    … …  
    421401ThreadableWebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const String& message)
    422402{
    423     if (!m_workerClientWrapper || !m_peer)
     403    if (!m_peer)
    424404        return ThreadableWebSocketChannel::SendFail;
    425405    setMethodNotCompleted();
    426406
    427     m_loaderProxy.postTaskToLoader([peer = m_peer, message = message.isolatedCopy()] (ScriptExecutionContext& context) {
     407    m_loaderProxy.postTaskToLoader([peer = m_peer, message = message.isolatedCopy()](ScriptExecutionContext& context) {
    428408        ASSERT(isMainThread());
    429409        ASSERT_UNUSED(context, context.isDocument());
    … …  
    435415    Ref<Bridge> protectedThis(*this);
    436416    waitForMethodCompletion();
    437     ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
    438     if (!clientWrapper)
    439         return ThreadableWebSocketChannel::SendFail;
    440     return clientWrapper->sendRequestResult();
     417    return m_workerClientWrapper->sendRequestResult();
    441418}
    442419
    443420ThreadableWebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
    444421{
    445     if (!m_workerClientWrapper || !m_peer)
     422    if (!m_peer)
    446423        return ThreadableWebSocketChannel::SendFail;
    447424
    … …  
    452429    setMethodNotCompleted();
    453430
    454     m_loaderProxy.postTaskToLoader([peer = m_peer, data = WTFMove(data)] (ScriptExecutionContext& context) {
     431    m_loaderProxy.postTaskToLoader([peer = m_peer, data = WTFMove(data)](ScriptExecutionContext& context) {
    455432        ASSERT(isMainThread());
    456433        ASSERT_UNUSED(context, context.isDocument());
    … …  
    463440    Ref<Bridge> protectedThis(*this);
    464441    waitForMethodCompletion();
    465     ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
    466     if (!clientWrapper)
    467         return ThreadableWebSocketChannel::SendFail;
    468     return clientWrapper->sendRequestResult();
     442    return m_workerClientWrapper->sendRequestResult();
    469443}
    470444
    471445ThreadableWebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(Blob& binaryData)
    472446{
    473     if (!m_workerClientWrapper || !m_peer)
     447    if (!m_peer)
    474448        return ThreadableWebSocketChannel::SendFail;
    475449    setMethodNotCompleted();
    476450
    477     m_loaderProxy.postTaskToLoader([peer = m_peer, url = binaryData.url().isolatedCopy(), type = binaryData.type().isolatedCopy(), size = binaryData.size()] (ScriptExecutionContext& context) {
     451    m_loaderProxy.postTaskToLoader([peer = m_peer, url = binaryData.url().isolatedCopy(), type = binaryData.type().isolatedCopy(), size = binaryData.size()](ScriptExecutionContext& context) {
    478452        ASSERT(isMainThread());
    479453        ASSERT_UNUSED(context, context.isDocument());
    … …  
    485459    Ref<Bridge> protectedThis(*this);
    486460    waitForMethodCompletion();
    487     ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
    488     if (!clientWrapper)
    489         return ThreadableWebSocketChannel::SendFail;
    490     return clientWrapper->sendRequestResult();
     461    return m_workerClientWrapper->sendRequestResult();
    491462}
    492463
    493464unsigned long WorkerThreadableWebSocketChannel::Bridge::bufferedAmount()
    494465{
    495     if (!m_workerClientWrapper || !m_peer)
     466    if (!m_peer)
    496467        return 0;
    497468    setMethodNotCompleted();
    498469
    499     m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
     470    m_loaderProxy.postTaskToLoader([peer = m_peer](ScriptExecutionContext& context) {
    500471        ASSERT(isMainThread());
    501472        ASSERT_UNUSED(context, context.isDocument());
    … …  
    507478    Ref<Bridge> protectedThis(*this);
    508479    waitForMethodCompletion();
    509     ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
    510     if (clientWrapper)
    511         return clientWrapper->bufferedAmount();
    512     return 0;
     480    return m_workerClientWrapper->bufferedAmount();
    513481}
    514482
    … …  
    518486        return;
    519487
    520     m_loaderProxy.postTaskToLoader([peer = m_peer, code, reason = reason.isolatedCopy()] (ScriptExecutionContext& context) {
     488    m_loaderProxy.postTaskToLoader([peer = m_peer, code, reason = reason.isolatedCopy()](ScriptExecutionContext& context) {
    521489        ASSERT(isMainThread());
    522490        ASSERT_UNUSED(context, context.isDocument());
    … …  
    532500        return;
    533501
    534     m_loaderProxy.postTaskToLoader([peer = m_peer, reason = reason.isolatedCopy()] (ScriptExecutionContext& context) {
     502    m_loaderProxy.postTaskToLoader([peer = m_peer, reason = reason.isolatedCopy()](ScriptExecutionContext& context) {
    535503        ASSERT(isMainThread());
    536504        ASSERT_UNUSED(context, context.isDocument());
    … …  
    545513    clearClientWrapper();
    546514    if (m_peer) {
    547         m_loaderProxy.postTaskToLoader([peer = std::unique_ptr<Peer>(m_peer)] (ScriptExecutionContext& context) {
     515        m_loaderProxy.postTaskToLoader([peer = std::unique_ptr<Peer>(m_peer)](ScriptExecutionContext& context) {
    548516            ASSERT(isMainThread());
    549517            ASSERT_UNUSED(context, context.isDocument());
    … …  
    559527        return;
    560528
    561     m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
     529    m_loaderProxy.postTaskToLoader([peer = m_peer](ScriptExecutionContext& context) {
    562530        ASSERT(isMainThread());
    563531        ASSERT_UNUSED(context, context.isDocument());
    … …  
    573541        return;
    574542
    575     m_loaderProxy.postTaskToLoader([peer = m_peer] (ScriptExecutionContext& context) {
     543    m_loaderProxy.postTaskToLoader([peer = m_peer](ScriptExecutionContext& context) {
    576544        ASSERT(isMainThread());
    577545        ASSERT_UNUSED(context, context.isDocument());
    … …  
    589557void WorkerThreadableWebSocketChannel::Bridge::setMethodNotCompleted()
    590558{
    591     ASSERT(m_workerClientWrapper);
    592559    m_workerClientWrapper->clearSyncMethodDone();
    593560}
    … …  
    601568    WorkerRunLoop& runLoop = m_workerGlobalScope->thread().runLoop();
    602569    MessageQueueWaitResult result = MessageQueueMessageReceived;
    603     ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
     570    ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.ptr();
    604571    while (m_workerGlobalScope && clientWrapper && !clientWrapper->syncMethodDone() && result != MessageQueueTerminated) {
    605572        result = runLoop.runInMode(m_workerGlobalScope.get(), m_taskMode); // May cause this bridge to get disconnected, which makes m_workerGlobalScope become null.
    606         clientWrapper = m_workerClientWrapper.get();
     573        clientWrapper = m_workerClientWrapper.ptr();
    607574    }
    608575}

  • trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.h

    r201543 r201837  
    2929 */
    3030
    31 #ifndef WorkerThreadableWebSocketChannel_h
    32 #define WorkerThreadableWebSocketChannel_h
     31#pragma once
    3332
    3433#if ENABLE(WEB_SOCKETS)
    … …  
    3837#include "WorkerGlobalScope.h"
    3938
    40 #include <wtf/PassRefPtr.h>
    4139#include <wtf/RefCounted.h>
    4240#include <wtf/RefPtr.h>
    … …  
    5654    WTF_MAKE_FAST_ALLOCATED;
    5755public:
    58     static Ref<ThreadableWebSocketChannel> create(WorkerGlobalScope* workerGlobalScope, WebSocketChannelClient* client, const String& taskMode)
     56    static Ref<ThreadableWebSocketChannel> create(WorkerGlobalScope& workerGlobalScope, WebSocketChannelClient& client, const String& taskMode)
    5957    {
    6058        return adoptRef(*new WorkerThreadableWebSocketChannel(workerGlobalScope, client, taskMode));
    … …  
    8179        WTF_MAKE_NONCOPYABLE(Peer); WTF_MAKE_FAST_ALLOCATED;
    8280    public:
    83         Peer(RefPtr<ThreadableWebSocketChannelClientWrapper>&&, WorkerLoaderProxy&, ScriptExecutionContext*, const String& taskMode);
     81        Peer(Ref<ThreadableWebSocketChannelClientWrapper>&&, WorkerLoaderProxy&, ScriptExecutionContext&, const String& taskMode);
    8482        ~Peer();
    8583
    … …  
    105103
    106104    private:
    107         RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
     105        Ref<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
    108106        WorkerLoaderProxy& m_loaderProxy;
    109107        RefPtr<ThreadableWebSocketChannel> m_mainWebSocketChannel;
    … …  
    122120    class Bridge : public RefCounted<Bridge> {
    123121    public:
    124         static Ref<Bridge> create(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerGlobalScope> workerGlobalScope, const String& taskMode)
     122        static Ref<Bridge> create(Ref<ThreadableWebSocketChannelClientWrapper>&& workerClientWrapper, Ref<WorkerGlobalScope>&& workerGlobalScope, const String& taskMode)
    125123        {
    126             return adoptRef(*new Bridge(workerClientWrapper, workerGlobalScope, taskMode));
     124            return adoptRef(*new Bridge(WTFMove(workerClientWrapper), WTFMove(workerGlobalScope), taskMode));
    127125        }
    128126        ~Bridge();
    … …  
    143141
    144142    private:
    145         Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper>, PassRefPtr<WorkerGlobalScope>, const String& taskMode);
     143        Bridge(Ref<ThreadableWebSocketChannelClientWrapper>&&, Ref<WorkerGlobalScope>&&, const String& taskMode);
    146144
    147         static void setWebSocketChannel(ScriptExecutionContext*, Bridge* thisPtr, Peer*, PassRefPtr<ThreadableWebSocketChannelClientWrapper>);
     145        static void setWebSocketChannel(ScriptExecutionContext*, Bridge* thisPtr, Peer*, Ref<ThreadableWebSocketChannelClientWrapper>&&);
    148146
    149147        // Executed on the main thread to create a Peer for this bridge.
    150         static void mainThreadInitialize(ScriptExecutionContext&, WorkerLoaderProxy*, RefPtr<ThreadableWebSocketChannelClientWrapper>&&, const String& taskMode);
     148        static void mainThreadInitialize(ScriptExecutionContext&, WorkerLoaderProxy&, Ref<ThreadableWebSocketChannelClientWrapper>&&, const String& taskMode);
    151149
    152150        // Executed on the worker context's thread.
    … …  
    156154        void waitForMethodCompletion();
    157155
    158         RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
     156        Ref<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
    159157        RefPtr<WorkerGlobalScope> m_workerGlobalScope;
    160158        WorkerLoaderProxy& m_loaderProxy;
    … …  
    163161    };
    164162
    165     WorkerThreadableWebSocketChannel(WorkerGlobalScope*, WebSocketChannelClient*, const String& taskMode);
     163    WorkerThreadableWebSocketChannel(WorkerGlobalScope&, WebSocketChannelClient&, const String& taskMode);
    166164
    167165    class WorkerGlobalScopeDidInitializeTask;
    168166
    169     RefPtr<WorkerGlobalScope> m_workerGlobalScope;
    170     RefPtr<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
     167    Ref<WorkerGlobalScope> m_workerGlobalScope;
     168    Ref<ThreadableWebSocketChannelClientWrapper> m_workerClientWrapper;
    171169    RefPtr<Bridge> m_bridge;
    172170};
    … …  
    175173
    176174#endif // ENABLE(WEB_SOCKETS)
    177 
    178 #endif // WorkerThreadableWebSocketChannel_h
Note: See TracChangeset for help on using the changeset viewer.