WorkerLoaderProxy: stop accessing cross-thread execution context

third_party/WebKit/Source/modules/websockets/WorkerWebSocketChannel.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/websockets/WorkerWebSocketChannel.h"
 
+#include <memory>
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
-#include "core/dom/ExecutionContextTask.h"
 #include "core/fileapi/Blob.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/websockets/DocumentWebSocketChannel.h"
+#include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/SafePoint.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
-#include <memory>
 
 namespace blink {
 
 typedef WorkerWebSocketChannel::Bridge Bridge;
 typedef WorkerWebSocketChannel::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 WebSocketChannelSyncHelper {
@@ skipping 296 matching lines @@
     : m_client(client),
       m_workerGlobalScope(workerGlobalScope),
       m_loaderProxy(m_workerGlobalScope->thread()->workerLoaderProxy()) {}
 
 Bridge::~Bridge() {
   DCHECK(!m_peer);
 }
 
 void Bridge::connectOnMainThread(
     std::unique_ptr<SourceLocation> location,
+    RefPtr<WorkerLoaderProxy> loaderProxy,
     WorkerThreadLifecycleContext* workerThreadLifecycleContext,
     const KURL& url,
     const String& protocol,
-    WebSocketChannelSyncHelper* syncHelper,
-    ExecutionContext* context) {
+    WebSocketChannelSyncHelper* syncHelper) {
   DCHECK(isMainThread());
   DCHECK(!m_peer);
+  ExecutionContext* loaderContext = loaderProxy->getLoaderExecutionContext();
+  if (!loaderContext)
+    return;
   Peer* peer = new Peer(this, m_loaderProxy, workerThreadLifecycleContext);
-  if (peer->initialize(std::move(location), context)) {
+  if (peer->initialize(std::move(location), loaderContext)) {
     m_peer = peer;
     syncHelper->setConnectRequestResult(m_peer->connect(url, protocol));
   }
   syncHelper->signalWorkerThread();
 }
 
 bool Bridge::connect(std::unique_ptr<SourceLocation> location,
                      const KURL& url,
                      const String& protocol) {
   // Wait for completion of the task on the main thread because the mixed
   // content check must synchronously be conducted.
   WebSocketChannelSyncHelper syncHelper;
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
-      createCrossThreadTask(
+      crossThreadBind(
           &Bridge::connectOnMainThread, wrapCrossThreadPersistent(this),
-          WTF::passed(location->clone()),
+          WTF::passed(location->clone()), m_loaderProxy,
           wrapCrossThreadPersistent(
               m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()),
           url, protocol, crossThreadUnretained(&syncHelper)));
   syncHelper.wait();
   return syncHelper.connectRequestResult();
 }
 
 void Bridge::send(const CString& message) {
   DCHECK(m_peer);
   std::unique_ptr<Vector<char>> data =
       WTF::wrapUnique(new Vector<char>(message.length()));
   if (message.length())
     memcpy(data->data(), static_cast<const char*>(message.data()),
            message.length());
 
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&Peer::sendTextAsCharVector, m_peer,
-                            WTF::passed(std::move(data))));
+      crossThreadBind(&Peer::sendTextAsCharVector, m_peer,
+                      WTF::passed(std::move(data))));
 }
 
 void Bridge::send(const DOMArrayBuffer& binaryData,
                   unsigned byteOffset,
                   unsigned byteLength) {
   DCHECK(m_peer);
   // ArrayBuffer isn't thread-safe, hence the content of ArrayBuffer is copied
   // into Vector<char>.
   std::unique_ptr<Vector<char>> data =
       WTF::makeUnique<Vector<char>>(byteLength);
   if (binaryData.byteLength())
     memcpy(data->data(),
            static_cast<const char*>(binaryData.data()) + byteOffset,
            byteLength);
 
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&Peer::sendBinaryAsCharVector, m_peer,
-                            WTF::passed(std::move(data))));
+      crossThreadBind(&Peer::sendBinaryAsCharVector, m_peer,
+                      WTF::passed(std::move(data))));
 }
 
 void Bridge::send(PassRefPtr<BlobDataHandle> data) {
   DCHECK(m_peer);
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
-      createCrossThreadTask(&Peer::sendBlob, m_peer, std::move(data)));
+      crossThreadBind(&Peer::sendBlob, m_peer, std::move(data)));
 }
 
 void Bridge::close(int code, const String& reason) {
   DCHECK(m_peer);
   m_loaderProxy->postTaskToLoader(
-      BLINK_FROM_HERE,
-      createCrossThreadTask(&Peer::close, m_peer, code, reason));
+      BLINK_FROM_HERE, crossThreadBind(&Peer::close, m_peer, code, reason));
 }
 
 void Bridge::fail(const String& reason,
                   MessageLevel level,
                   std::unique_ptr<SourceLocation> location) {
   DCHECK(m_peer);
   m_loaderProxy->postTaskToLoader(
-      BLINK_FROM_HERE, createCrossThreadTask(&Peer::fail, m_peer, reason, level,
-                                             WTF::passed(location->clone())));
+      BLINK_FROM_HERE,
+      crossThreadBind(&Peer::fail, m_peer, reason, level,
+                      WTF::passed(location->clone())));
 }
 
 void Bridge::disconnect() {
   if (!m_peer)
     return;
 
-  m_loaderProxy->postTaskToLoader(
-      BLINK_FROM_HERE, createCrossThreadTask(&Peer::disconnect, m_peer));
+  m_loaderProxy->postTaskToLoader(BLINK_FROM_HERE,
+                                  crossThreadBind(&Peer::disconnect, m_peer));
 
   m_client = nullptr;
   m_peer = nullptr;
   m_workerGlobalScope.clear();
 }
 
 DEFINE_TRACE(Bridge) {
   visitor->trace(m_client);
   visitor->trace(m_workerGlobalScope);
 }
 
 }  // namespace blink