Replace CallClosureTask::create(bind()) with createCrossThreadTask()

Source/modules/websockets/WorkerThreadableWebSocketChannel.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 18 matching lines @@
  */
 
 #include "config.h"
 
 #include "modules/websockets/WorkerThreadableWebSocketChannel.h"
 
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
+#include "core/dom/ExecutionContextTask.h"
 #include "core/fileapi/Blob.h"
 #include "core/inspector/ScriptCallFrame.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerRunLoop.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/websockets/MainThreadWebSocketChannel.h"
 #include "modules/websockets/NewWebSocketChannelImpl.h"
 #include "modules/websockets/ThreadableWebSocketChannelClientWrapper.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 441 matching lines @@
         disconnect();
     }
 }
 
 bool WorkerThreadableWebSocketChannel::Bridge::connect(const KURL& url, const String& protocol)
 {
     if (hasTerminatedPeer())
         return false;
 
     RefPtrWillBeRawPtr<Bridge> protect(this);
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::connect, m_peer, url.copy(), protocol.isolatedCopy()));
-    if (!waitForMethodCompletion(task.release()))
+    if (!waitForMethodCompletion(createCallClosureTask(&Peer::connect, m_peer, url, protocol)))
         return false;
 
     return m_syncHelper->connectRequestResult();
 }
 
 WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const String& message)
 {
     if (hasTerminatedPeer())
         return WebSocketChannel::SendFail;
 
     RefPtrWillBeRawPtr<Bridge> protect(this);
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::send, m_peer, message.isolatedCopy()));
-    if (!waitForMethodCompletion(task.release()))
+    if (!waitForMethodCompletion(createCallClosureTask(&Peer::send, m_peer, message)))
         return WebSocketChannel::SendFail;
 
     return m_syncHelper->sendRequestResult();
 }
 
 WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(const ArrayBuffer& binaryData, unsigned byteOffset, unsigned byteLength)
 {
     if (hasTerminatedPeer())
         return WebSocketChannel::SendFail;
 
     // ArrayBuffer isn't thread-safe, hence the content of ArrayBuffer is copied into Vector<char>.
     OwnPtr<Vector<char> > data = adoptPtr(new Vector<char>(byteLength));
     if (binaryData.byteLength())
         memcpy(data->data(), static_cast<const char*>(binaryData.data()) + byteOffset, byteLength);
 
     RefPtrWillBeRawPtr<Bridge> protect(this);
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::sendArrayBuffer, m_peer, data.release()));
-    if (!waitForMethodCompletion(task.release()))
+    if (!waitForMethodCompletion(createCallClosureTask(&Peer::sendArrayBuffer, m_peer, data.release())))
         return WebSocketChannel::SendFail;
 
     return m_syncHelper->sendRequestResult();
 }
 
 WebSocketChannel::SendResult WorkerThreadableWebSocketChannel::Bridge::send(PassRefPtr<BlobDataHandle> data)
 {
     if (hasTerminatedPeer())
         return WebSocketChannel::SendFail;
 
     RefPtrWillBeRawPtr<Bridge> protect(this);
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::sendBlob, m_peer, data));
-    if (!waitForMethodCompletion(task.release()))
+    if (!waitForMethodCompletion(createCallClosureTask(&Peer::sendBlob, m_peer, data)))
         return WebSocketChannel::SendFail;
 
     return m_syncHelper->sendRequestResult();
 }
 
 void WorkerThreadableWebSocketChannel::Bridge::close(int code, const String& reason)
 {
     if (hasTerminatedPeer())
         return;
 
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::close, m_peer, code, reason.isolatedCopy()));
-    m_loaderProxy.postTaskToLoader(task.release());
+    m_loaderProxy.postTaskToLoader(createCallClosureTask(&Peer::close, m_peer, code, reason));
 }
 
 void WorkerThreadableWebSocketChannel::Bridge::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
 {
     if (hasTerminatedPeer())
         return;
 
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::fail, m_peer, reason.isolatedCopy(), level, sourceURL.isolatedCopy(), lineNumber));
-    m_loaderProxy.postTaskToLoader(task.release());
+    m_loaderProxy.postTaskToLoader(createCallClosureTask(&Peer::fail, m_peer, reason, level, sourceURL, lineNumber));
 }
 
 void WorkerThreadableWebSocketChannel::Bridge::disconnect()
 {
     if (hasTerminatedPeer())
         return;
 
     clearClientWrapper();
     terminatePeer();
 }
@@ skipping 19 matching lines @@
     ThreadState::SafePointScope scope(ThreadState::HeapPointersOnStack);
     blink::Platform::current()->waitMultipleEvents(events);
     // This is checking whether a shutdown event is fired or not.
     return !m_workerGlobalScope->thread()->runLoop().terminated();
 }
 
 void WorkerThreadableWebSocketChannel::Bridge::terminatePeer()
 {
     ASSERT(!hasTerminatedPeer());
 
-    // It is important to seprate task creation from calling
-    // waitForMethodCompletion. See the above comment.
-    OwnPtr<ExecutionContextTask> task = CallClosureTask::create(bind(&Peer::destroy, m_peer));
 #if ENABLE(OILPAN)
     // The worker thread has to wait for the main thread to complete Peer::destroy,
     // because the worker thread has to make sure that the main thread does not have any
     // references to on-heap objects allocated in the thread heap of the worker thread
     // before the worker thread shuts down.
-    waitForMethodCompletion(task.release());
+    waitForMethodCompletion(createCallClosureTask(&Peer::destroy, m_peer));
 #else
-    m_loaderProxy.postTaskToLoader(task.release());
+    m_loaderProxy.postTaskToLoader(createCallClosureTask(&Peer::destroy, m_peer));
 #endif
 
     // Peer::destroy() deletes m_peer and then m_syncHelper will be released.
     // We must not touch m_syncHelper any more.
     m_syncHelper = nullptr;
 
     // We won't use this any more.
     m_workerGlobalScope = nullptr;
 }
 
 void WorkerThreadableWebSocketChannel::Bridge::trace(Visitor* visitor)
 {
     visitor->trace(m_workerClientWrapper);
     visitor->trace(m_workerGlobalScope);
     visitor->trace(m_syncHelper);
     visitor->trace(m_peer);
 }
 
 } // namespace WebCore