Move WorkerThreadable internal classes to Oilpan heap

third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp

Index: third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
diff --git a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
index ba8f1427a912edba0dc49c6a53572564871a47bf..4b4c967464338d900435d07da49e0c2cfc004a20 100644
--- a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
@@ -36,38 +36,38 @@
 #include "core/timing/WorkerGlobalScopePerformance.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
-#include "core/workers/WorkerThread.h"
 #include "platform/CrossThreadFunctional.h"
-#include "platform/WaitableEvent.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/weborigin/SecurityPolicy.h"
-#include "public/platform/Platform.h"
-#include "wtf/PtrUtil.h"
-#include "wtf/Vector.h"
 #include <memory>
 
 namespace blink {
 
-static std::unique_ptr<Vector<char>> createVectorFromMemoryRegion(const char* data, unsigned dataLength)
+namespace {
+
+std::unique_ptr<Vector<char>> createVectorFromMemoryRegion(const char* data, unsigned dataLength)
 {
     std::unique_ptr<Vector<char>> buffer = wrapUnique(new Vector<char>(dataLength));
     memcpy(buffer->data(), data, dataLength);
     return buffer;
 }
 
-WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope& workerGlobalScope, ThreadableLoaderClient* client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions, BlockingBehavior blockingBehavior)
+} // namespace
+
+WorkerThreadableLoader::WorkerThreadableLoader(
+    WorkerGlobalScope& workerGlobalScope,
+    ThreadableLoaderClient* client,
+    const ThreadableLoaderOptions& options,
+    const ResourceLoaderOptions& resourceLoaderOptions,
+    BlockingBehavior blockingBehavior)
     : m_workerGlobalScope(&workerGlobalScope)
     , m_workerClientWrapper(new ThreadableLoaderClientWrapper(workerGlobalScope, client))
+    , m_bridge(new Bridge(m_workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy(), options, resourceLoaderOptions, blockingBehavior))
 {
-    if (blockingBehavior == LoadAsynchronously) {
-        m_bridge = new MainThreadAsyncBridge(workerGlobalScope, m_workerClientWrapper, options, resourceLoaderOptions);
-    } else {
-        m_bridge = new MainThreadSyncBridge(workerGlobalScope, m_workerClientWrapper, options, resourceLoaderOptions);
-    }
 }
 
 void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
@@ -80,7 +80,6 @@ WorkerThreadableLoader::~WorkerThreadableLoader()
 {
     DCHECK(m_workerClientWrapper->done());
     m_bridge->destroy();
-    m_bridge = nullptr;
 }
 
 void WorkerThreadableLoader::start(const ResourceRequest& request)
@@ -93,279 +92,419 @@ void WorkerThreadableLoader::start(const ResourceRequest& request)
 
 void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
 {
-    ASSERT(m_bridge);
     m_bridge->overrideTimeout(timeoutMilliseconds);
 }
 
 void WorkerThreadableLoader::cancel()
 {
-    ASSERT(m_bridge);
     m_bridge->cancel();
 }
 
-WorkerThreadableLoader::MainThreadBridgeBase::MainThreadBridgeBase(
-    ThreadableLoaderClientWrapper* workerClientWrapper,
-    PassRefPtr<WorkerLoaderProxy> loaderProxy)
-    : m_workerClientWrapper(workerClientWrapper)
-    , m_loaderProxy(loaderProxy)
+WorkerThreadableLoader::AsyncTaskForwarder::AsyncTaskForwarder(PassRefPtr<WorkerLoaderProxy> loaderProxy)
+    : m_loaderProxy(loaderProxy)
 {
-    ASSERT(m_workerClientWrapper.get());
-    ASSERT(m_loaderProxy.get());
+    DCHECK(isMainThread());
 }
 
-WorkerThreadableLoader::MainThreadBridgeBase::~MainThreadBridgeBase()
+WorkerThreadableLoader::AsyncTaskForwarder::~AsyncTaskForwarder()
 {
+    DCHECK(isMainThread());
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadCreateLoader(ThreadableLoaderOptions options, ResourceLoaderOptions resourceLoaderOptions, ExecutionContext* context)
+void WorkerThreadableLoader::AsyncTaskForwarder::forwardTask(std::unique_ptr<ExecutionContextTask> task)
 {
-    ASSERT(isMainThread());
-    Document* document = toDocument(context);
-
-    resourceLoaderOptions.requestInitiatorContext = WorkerContext;
-    m_mainThreadLoader = DocumentThreadableLoader::create(*document, this, options, resourceLoaderOptions);
-    ASSERT(m_mainThreadLoader);
+    DCHECK(isMainThread());
+    m_loaderProxy->postTaskToWorkerGlobalScope(std::move(task));
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadStart(std::unique_ptr<CrossThreadResourceRequestData> requestData)
+void WorkerThreadableLoader::AsyncTaskForwarder::forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask> task)
 {
-    ASSERT(isMainThread());
-    ASSERT(m_mainThreadLoader);
-    m_mainThreadLoader->start(ResourceRequest(requestData.get()));
+    DCHECK(isMainThread());
+    m_loaderProxy->postTaskToWorkerGlobalScope(std::move(task));
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::createLoaderInMainThread(const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
+void WorkerThreadableLoader::AsyncTaskForwarder::abort()
 {
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadCreateLoader, crossThreadUnretained(this), options, resourceLoaderOptions));
+    DCHECK(isMainThread());
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::startInMainThread(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
+WorkerThreadableLoader::WaitableEventWithTasks::~WaitableEventWithTasks() {}
+
+void WorkerThreadableLoader::WaitableEventWithTasks::signal()
 {
-    loaderProxy()->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadStart, crossThreadUnretained(this), request));
+    DCHECK(isMainThread());
+    CHECK(!m_isSignalCalled);
+    m_isSignalCalled = true;
+    m_event.signal();
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadDestroy(ExecutionContext* context)
+void WorkerThreadableLoader::WaitableEventWithTasks::wait()
 {
-    ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context->isDocument());
-    delete this;
+    DCHECK(!isMainThread());
+    CHECK(!m_isWaitDone);
+    m_event.wait();
+    m_isWaitDone = true;
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::destroy()
+bool WorkerThreadableLoader::WaitableEventWithTasks::isAborted() const
 {
-    // Ensure that no more client callbacks are done in the worker context's
-    // thread.
-    // ThreadableLoaderClientWrapper is an on-heap class and this function can
-    // be called in the finalization step but it is safe because
-    // m_workerClientWrapper is a CrossThreadPersistent.
-    m_workerClientWrapper->clearClient();
+    DCHECK(!isMainThread());
+    CHECK(m_isWaitDone);
+    return m_isAborted;
+}
 
-    // "delete this" and m_mainThreadLoader::deref() on the worker object's
-    // thread.
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadDestroy, crossThreadUnretained(this)));
+Vector<std::unique_ptr<ExecutionContextTask>> WorkerThreadableLoader::WaitableEventWithTasks::take()
+{
+    DCHECK(!isMainThread());
+    CHECK(m_isWaitDone);
+    return std::move(m_tasks);
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadOverrideTimeout(unsigned long timeoutMilliseconds, ExecutionContext* context)
+void WorkerThreadableLoader::WaitableEventWithTasks::setIsAborted()
 {
-    ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context->isDocument());
+    DCHECK(isMainThread());
+    CHECK(!m_isSignalCalled);
+    m_isAborted = true;
+}
 
-    if (!m_mainThreadLoader)
-        return;
-    m_mainThreadLoader->overrideTimeout(timeoutMilliseconds);
+void WorkerThreadableLoader::WaitableEventWithTasks::append(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    CHECK(!m_isSignalCalled);
+    m_tasks.append(std::move(task));
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::overrideTimeout(unsigned long timeoutMilliseconds)
+WorkerThreadableLoader::SyncTaskForwarder::SyncTaskForwarder(PassRefPtr<WaitableEventWithTasks> eventWithTasks)
+    : m_eventWithTasks(eventWithTasks)
 {
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadOverrideTimeout, crossThreadUnretained(this), timeoutMilliseconds));
+    DCHECK(isMainThread());
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadCancel(ExecutionContext* context)
+WorkerThreadableLoader::SyncTaskForwarder::~SyncTaskForwarder()
 {
-    ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context->isDocument());
+    DCHECK(isMainThread());
+}
 
-    if (!m_mainThreadLoader)
-        return;
-    m_mainThreadLoader->cancel();
-    m_mainThreadLoader = nullptr;
+void WorkerThreadableLoader::SyncTaskForwarder::forwardTask(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    m_eventWithTasks->append(std::move(task));
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::cancel()
+void WorkerThreadableLoader::SyncTaskForwarder::forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask> task)
 {
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadCancel, crossThreadUnretained(this)));
-    ThreadableLoaderClientWrapper* clientWrapper = m_workerClientWrapper;
-    if (!clientWrapper->done()) {
-        // If the client hasn't reached a termination state, then transition it
-        // by sending a cancellation error.
-        // Note: no more client callbacks will be done after this method -- the
-        // m_workerClientWrapper->clearClient() call ensures that.
-        ResourceError error(String(), 0, String(), String());
-        error.setIsCancellation(true);
-        clientWrapper->didFail(error);
-    }
-    // |this| might be already destructed here because didFail() might
-    // clear a reference to ThreadableLoader, which might destruct
-    // WorkerThreadableLoader and then MainThreadBridge.
-    // Therefore we call clearClient() directly, rather than calling
-    // this->m_workerClientWrapper->clearClient().
-    clientWrapper->clearClient();
+    DCHECK(isMainThread());
+    m_eventWithTasks->append(std::move(task));
+    m_eventWithTasks->signal();
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
+void WorkerThreadableLoader::SyncTaskForwarder::abort()
 {
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didSendData, m_workerClientWrapper, bytesSent, totalBytesToBeSent));
+    DCHECK(isMainThread());
+    m_eventWithTasks->setIsAborted();
+    m_eventWithTasks->signal();
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
+WorkerThreadableLoader::Bridge::Bridge(
+    ThreadableLoaderClientWrapper* clientWrapper,
+    PassRefPtr<WorkerLoaderProxy> loaderProxy,
+    const ThreadableLoaderOptions& threadableLoaderOptions,
+    const ResourceLoaderOptions& resourceLoaderOptions,
+    BlockingBehavior blockingBehavior)
+    : m_clientWrapper(clientWrapper)
+    , m_loaderProxy(loaderProxy)
+    , m_threadableLoaderOptions(threadableLoaderOptions)
+    , m_resourceLoaderOptions(resourceLoaderOptions)
+    , m_blockingBehavior(blockingBehavior)
 {
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResponse, m_workerClientWrapper, identifier, response, passed(std::move(handle))));
+    DCHECK(!isMainThread());
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveData(const char* data, unsigned dataLength)
+WorkerThreadableLoader::Bridge::~Bridge()
 {
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveData, m_workerClientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+    DCHECK(!isMainThread());
+    DCHECK(!m_peer);
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didDownloadData(int dataLength)
+void WorkerThreadableLoader::Bridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
 {
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didDownloadData, m_workerClientWrapper, dataLength));
+    DCHECK(!isMainThread());
+    RefPtr<WaitableEventWithTasks> eventWithTasks;
+    if (m_blockingBehavior == LoadSynchronously)
+        eventWithTasks = WaitableEventWithTasks::create();
+
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(
+        &Peer::createAndStart,
+        wrapCrossThreadPersistent(this),
+        m_loaderProxy,
+        wrapCrossThreadPersistent(workerGlobalScope.thread()->getWorkerThreadLifecycleContext()),
+        request,
+        m_threadableLoaderOptions,
+        m_resourceLoaderOptions,
+        eventWithTasks));
+
+    if (m_blockingBehavior == LoadAsynchronously)
+        return;
+
+    {
+        SafePointScope scope(BlinkGC::HeapPointersOnStack);
+        eventWithTasks->wait();
+    }
+
+    if (eventWithTasks->isAborted()) {
+        // This thread is going to terminate.
+        cancel();
+        return;
+    }
+
+    for (const auto& task : eventWithTasks->take()) {
+        // m_clientTask contains only CallClosureTasks. So, it's ok to pass
+        // the nullptr.
+        task->performTask(nullptr);
+    }
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveCachedMetadata(const char* data, int dataLength)
+void WorkerThreadableLoader::Bridge::overrideTimeout(unsigned long timeoutMilliseconds)
 {
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveCachedMetadata, m_workerClientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+    DCHECK(!isMainThread());
+    if (!m_peer)
+        return;
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didFinishLoading(unsigned long identifier, double finishTime)
+void WorkerThreadableLoader::Bridge::cancel()
 {
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFinishLoading, m_workerClientWrapper, identifier, finishTime));
+    DCHECK(!isMainThread());
+    cancelPeer();
+
+    if (m_clientWrapper->done())
+        return;
+    // If the client hasn't reached a termination state, then transition it
+    // by sending a cancellation error.
+    // Note: no more client callbacks will be done after this method -- the
+    // clearClient() call ensures that.
+    ResourceError error(String(), 0, String(), String());
+    error.setIsCancellation(true);
+    m_clientWrapper->didFail(error);
+    m_clientWrapper->clearClient();
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didFail(const ResourceError& error)
+void WorkerThreadableLoader::Bridge::destroy()
 {
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFail, m_workerClientWrapper, error));
+    DCHECK(!isMainThread());
+    cancelPeer();
+    m_clientWrapper->clearClient();
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didFailAccessControlCheck(const ResourceError& error)
+void WorkerThreadableLoader::Bridge::didStart(Peer* peer)
 {
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailAccessControlCheck, m_workerClientWrapper, error));
+    DCHECK(!isMainThread());
+    DCHECK(!m_peer);
+    DCHECK(peer);
+    if (m_clientWrapper->done()) {
+        // The loading is already cancelled.
+        return;
+    }
+
+    m_peer = peer;
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didFailRedirectCheck()
+DEFINE_TRACE(WorkerThreadableLoader::Bridge)
 {
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailRedirectCheck, m_workerClientWrapper));
+    visitor->trace(m_clientWrapper);
 }
 
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveResourceTiming(const ResourceTimingInfo& info)
+void WorkerThreadableLoader::Bridge::cancelPeer()
 {
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResourceTiming, m_workerClientWrapper, info));
+    DCHECK(!isMainThread());
+    if (!m_peer)
+        return;
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::cancel, m_peer));
+    m_peer = nullptr;
 }
 
-WorkerThreadableLoader::MainThreadAsyncBridge::MainThreadAsyncBridge(
-    WorkerGlobalScope& workerGlobalScope,
-    ThreadableLoaderClientWrapper* workerClientWrapper,
+void WorkerThreadableLoader::Peer::createAndStart(
+    Bridge* bridge,
+    PassRefPtr<WorkerLoaderProxy> passLoaderProxy,
+    WorkerThreadLifecycleContext* workerThreadLifecycleContext,
+    std::unique_ptr<CrossThreadResourceRequestData> request,
     const ThreadableLoaderOptions& options,
-    const ResourceLoaderOptions& resourceLoaderOptions)
-    : MainThreadBridgeBase(workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy())
-{
-    createLoaderInMainThread(options, resourceLoaderOptions);
+    const ResourceLoaderOptions& resourceLoaderOptions,
+    PassRefPtr<WaitableEventWithTasks> eventWithTasks,
+    ExecutionContext* executionContext)
+{
+    DCHECK(isMainThread());
+    TaskForwarder* forwarder;
+    RefPtr<WorkerLoaderProxy> loaderProxy = passLoaderProxy;
+    if (eventWithTasks)
+        forwarder = new SyncTaskForwarder(eventWithTasks);
+    else
+        forwarder = new AsyncTaskForwarder(loaderProxy);
+
+    Peer* peer = new Peer(forwarder, workerThreadLifecycleContext);
+    if (peer->wasContextDestroyedBeforeObserverCreation()) {
+        // The thread is already terminating.
+        forwarder->abort();
+        peer->m_forwarder = nullptr;
+        return;
+    }
+    peer->m_clientWrapper = bridge->clientWrapper();
+    peer->start(*toDocument(executionContext), std::move(request), options, resourceLoaderOptions);
+    forwarder->forwardTask(createCrossThreadTask(&Bridge::didStart, wrapCrossThreadPersistent(bridge), wrapCrossThreadPersistent(peer)));
 }
 
-void WorkerThreadableLoader::MainThreadAsyncBridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
+WorkerThreadableLoader::Peer::~Peer()
 {
-    startInMainThread(request, workerGlobalScope);
+    DCHECK(isMainThread());
+    DCHECK(!m_mainThreadLoader);
 }
 
-WorkerThreadableLoader::MainThreadAsyncBridge::~MainThreadAsyncBridge()
+void WorkerThreadableLoader::Peer::overrideTimeout(unsigned long timeoutMilliseconds)
 {
+    DCHECK(isMainThread());
+    if (!m_mainThreadLoader)
+        return;
+    m_mainThreadLoader->overrideTimeout(timeoutMilliseconds);
 }
 
-void WorkerThreadableLoader::MainThreadAsyncBridge::forwardTaskToWorker(std::unique_ptr<ExecutionContextTask> task)
+void WorkerThreadableLoader::Peer::cancel()
 {
-    loaderProxy()->postTaskToWorkerGlobalScope(std::move(task));
+    DCHECK(isMainThread());
+    if (!m_mainThreadLoader)
+        return;
+    m_mainThreadLoader->cancel();
+    m_mainThreadLoader = nullptr;
 }
 
-void WorkerThreadableLoader::MainThreadAsyncBridge::forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask> task)
+void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
-    loaderProxy()->postTaskToWorkerGlobalScope(std::move(task));
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didSendData, clientWrapper, bytesSent, totalBytesToBeSent));
 }
 
-WorkerThreadableLoader::MainThreadSyncBridge::MainThreadSyncBridge(
-    WorkerGlobalScope& workerGlobalScope,
-    ThreadableLoaderClientWrapper* workerClientWrapper,
-    const ThreadableLoaderOptions& options,
-    const ResourceLoaderOptions& resourceLoaderOptions)
-    : MainThreadBridgeBase(workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy())
-    , m_done(false)
+void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
-    createLoaderInMainThread(options, resourceLoaderOptions);
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResponse, clientWrapper, identifier, response, passed(std::move(handle))));
 }
 
-void WorkerThreadableLoader::MainThreadSyncBridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
+void WorkerThreadableLoader::Peer::didReceiveData(const char* data, unsigned dataLength)
 {
-    WaitableEvent* terminationEvent = workerGlobalScope.thread()->terminationEvent();
-    m_loaderDoneEvent = wrapUnique(new WaitableEvent());
-
-    startInMainThread(request, workerGlobalScope);
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveData, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+}
 
-    size_t signaledIndex;
-    {
-        Vector<WaitableEvent*> events;
-        // Order is important; indicies are used later.
-        events.append(terminationEvent);
-        events.append(m_loaderDoneEvent.get());
+void WorkerThreadableLoader::Peer::didDownloadData(int dataLength)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didDownloadData, clientWrapper, dataLength));
+}
 
-        SafePointScope scope(BlinkGC::HeapPointersOnStack);
-        signaledIndex = WaitableEvent::waitMultiple(events);
-    }
-    // |signaledIndex| is 0; which is terminationEvent.
-    if (signaledIndex == 0) {
-        cancel();
+void WorkerThreadableLoader::Peer::didReceiveCachedMetadata(const char* data, int dataLength)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
         return;
-    }
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveCachedMetadata, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+}
 
-    // The following code must be run only after |m_loaderDoneEvent| is
-    // signalled.
+void WorkerThreadableLoader::Peer::didFinishLoading(unsigned long identifier, double finishTime)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFinishLoading, clientWrapper, identifier, finishTime));
+    m_forwarder = nullptr;
+}
 
-    Vector<std::unique_ptr<ExecutionContextTask>> tasks;
-    {
-        MutexLocker lock(m_lock);
-        ASSERT(m_done);
-        m_clientTasks.swap(tasks);
-    }
-    for (const auto& task : tasks) {
-        // m_clientTask contains only CallClosureTasks. So, it's ok to pass
-        // the nullptr.
-        task->performTask(nullptr);
-    }
+void WorkerThreadableLoader::Peer::didFail(const ResourceError& error)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFail, clientWrapper, error));
+    m_forwarder = nullptr;
 }
 
-WorkerThreadableLoader::MainThreadSyncBridge::~MainThreadSyncBridge()
+void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError& error)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailAccessControlCheck, clientWrapper, error));
+    m_forwarder = nullptr;
 }
 
-void WorkerThreadableLoader::MainThreadSyncBridge::forwardTaskToWorker(std::unique_ptr<ExecutionContextTask> task)
+void WorkerThreadableLoader::Peer::didFailRedirectCheck()
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailRedirectCheck, clientWrapper));
+    m_forwarder = nullptr;
+}
 
-    MutexLocker lock(m_lock);
-    RELEASE_ASSERT(!m_done);
+void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTimingInfo& info)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResourceTiming, clientWrapper, info));
+}
 
-    m_clientTasks.append(std::move(task));
+void WorkerThreadableLoader::Peer::contextDestroyed()
+{
+    DCHECK(isMainThread());
+    if (m_forwarder) {
+        m_forwarder->abort();
+        m_forwarder = nullptr;
+    }
+    m_clientWrapper = nullptr;
+    cancel();
 }
 
-void WorkerThreadableLoader::MainThreadSyncBridge::forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask> task)
+DEFINE_TRACE(WorkerThreadableLoader::Peer)
 {
-    ASSERT(isMainThread());
+    visitor->trace(m_forwarder);
+    WorkerThreadLifecycleObserver::trace(visitor);
+}
 
-    MutexLocker lock(m_lock);
-    RELEASE_ASSERT(!m_done);
+WorkerThreadableLoader::Peer::Peer(TaskForwarder* forwarder, WorkerThreadLifecycleContext* context)
+    : WorkerThreadLifecycleObserver(context)
+    , m_forwarder(forwarder)
+{
+    DCHECK(isMainThread());
+}
 
-    m_clientTasks.append(std::move(task));
-    m_done = true;
-    m_loaderDoneEvent->signal();
+void WorkerThreadableLoader::Peer::start(
+    Document& document,
+    std::unique_ptr<CrossThreadResourceRequestData> request,
+    const ThreadableLoaderOptions& options,
+    const ResourceLoaderOptions& originalResourceLoaderOptions)
+{
+    DCHECK(isMainThread());
+    ResourceLoaderOptions resourceLoaderOptions = originalResourceLoaderOptions;
+    resourceLoaderOptions.requestInitiatorContext = WorkerContext;
+    m_mainThreadLoader = DocumentThreadableLoader::create(document, this, options, resourceLoaderOptions);
+    m_mainThreadLoader->start(ResourceRequest(request.get()));
 }
 
 } // namespace blink