Move WorkerThreadable internal classes to Oilpan heap

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

 /*
  * Copyright (C) 2009, 2010 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 "core/loader/WorkerThreadableLoader.h"
 
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/Document.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #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)
 {
     std::unique_ptr<WorkerThreadableLoader> loader = wrapUnique(new WorkerThreadableLoader(workerGlobalScope, &client, options, resourceLoaderOptions, LoadSynchronously));
     loader->start(request);
 }
 
 WorkerThreadableLoader::~WorkerThreadableLoader()
 {
     m_bridge->destroy();
-    m_bridge = nullptr;
 }
 
 void WorkerThreadableLoader::start(const ResourceRequest& request)
 {
     ResourceRequest requestToPass(request);
     if (!requestToPass.didSetHTTPReferrer())
         requestToPass.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalScope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer()));
     m_bridge->start(requestToPass, *m_workerGlobalScope);
 }
 
 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)
+WorkerThreadableLoader::AsyncTaskForwarder::AsyncTaskForwarder(PassRefPtr<WorkerLoaderProxy> loaderProxy)
+    : m_loaderProxy(loaderProxy)
+{
+    DCHECK(isMainThread());
+}
+
+WorkerThreadableLoader::AsyncTaskForwarder::~AsyncTaskForwarder()
+{
+    DCHECK(isMainThread());
+}
+
+void WorkerThreadableLoader::AsyncTaskForwarder::forwardTask(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    m_loaderProxy->postTaskToWorkerGlobalScope(std::move(task));
+}
+
+void WorkerThreadableLoader::AsyncTaskForwarder::forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    m_loaderProxy->postTaskToWorkerGlobalScope(std::move(task));
+}
+
+void WorkerThreadableLoader::AsyncTaskForwarder::abort()
+{
+    DCHECK(isMainThread());
+}
+
+WorkerThreadableLoader::WaitableEventWithTasks::~WaitableEventWithTasks() {}
+
+void WorkerThreadableLoader::WaitableEventWithTasks::signal()
+{
+    DCHECK(isMainThread());
+    DCHECK(!m_isSignalCalled);
+    m_isSignalCalled = true;
+    m_event.signal();
+}
+
+void WorkerThreadableLoader::WaitableEventWithTasks::wait()
+{
+    DCHECK(!isMainThread());
+    DCHECK(!m_isWaitDone);
+    m_event.wait();
+    m_isWaitDone = true;
+}
+
+bool WorkerThreadableLoader::WaitableEventWithTasks::isAborted() const
+{
+    DCHECK(!isMainThread());
+    DCHECK(m_isWaitDone);
+    return m_isAborted;
+}
+
+Vector<std::unique_ptr<ExecutionContextTask>> WorkerThreadableLoader::WaitableEventWithTasks::take()
+{
+    DCHECK(!isMainThread());
+    DCHECK(m_isWaitDone);
+    return std::move(m_tasks);
+}
+
+void WorkerThreadableLoader::WaitableEventWithTasks::setIsAborted()
+{
+    DCHECK(isMainThread());
+    DCHECK(!m_isSignalCalled);
+    m_isAborted = true;
+}
+
+void WorkerThreadableLoader::WaitableEventWithTasks::append(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    DCHECK(!m_isSignalCalled);
+    m_tasks.append(std::move(task));
+}
+
+WorkerThreadableLoader::SyncTaskForwarder::SyncTaskForwarder(PassRefPtr<WaitableEventWithTasks> eventWithTasks)
+    : m_eventWithTasks(eventWithTasks)
+{
+    DCHECK(isMainThread());
+}
+
+WorkerThreadableLoader::SyncTaskForwarder::~SyncTaskForwarder()
+{
+    DCHECK(isMainThread());
+}
+
+void WorkerThreadableLoader::SyncTaskForwarder::forwardTask(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    m_eventWithTasks->append(std::move(task));
+}
+
+void WorkerThreadableLoader::SyncTaskForwarder::forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask> task)
+{
+    DCHECK(isMainThread());
+    m_eventWithTasks->append(std::move(task));
+    m_eventWithTasks->signal();
+}
+
+void WorkerThreadableLoader::SyncTaskForwarder::abort()
+{
+    DCHECK(isMainThread());
+    m_eventWithTasks->setIsAborted();
+    m_eventWithTasks->signal();
+}
+
+WorkerThreadableLoader::Bridge::Bridge(
+    ThreadableLoaderClientWrapper* clientWrapper,
+    PassRefPtr<WorkerLoaderProxy> loaderProxy,
+    const ThreadableLoaderOptions& threadableLoaderOptions,
+    const ResourceLoaderOptions& resourceLoaderOptions,
+    BlockingBehavior blockingBehavior)
+    : m_clientWrapper(clientWrapper)
     , m_loaderProxy(loaderProxy)
-{
-    ASSERT(m_workerClientWrapper.get());
-    ASSERT(m_loaderProxy.get());
-}
-
-WorkerThreadableLoader::MainThreadBridgeBase::~MainThreadBridgeBase()
-{
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadCreateLoader(ThreadableLoaderOptions options, ResourceLoaderOptions resourceLoaderOptions, ExecutionContext* context)
-{
-    ASSERT(isMainThread());
-    Document* document = toDocument(context);
-
-    resourceLoaderOptions.requestInitiatorContext = WorkerContext;
-    m_mainThreadLoader = DocumentThreadableLoader::create(*document, this, options, resourceLoaderOptions);
-    ASSERT(m_mainThreadLoader);
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadStart(std::unique_ptr<CrossThreadResourceRequestData> requestData)
-{
-    ASSERT(isMainThread());
-    ASSERT(m_mainThreadLoader);
-    m_mainThreadLoader->start(ResourceRequest(requestData.get()));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::createLoaderInMainThread(const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
-{
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadCreateLoader, crossThreadUnretained(this), options, resourceLoaderOptions));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::startInMainThread(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
-{
-    loaderProxy()->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadStart, crossThreadUnretained(this), request));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadDestroy(ExecutionContext* context)
-{
-    ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context->isDocument());
-    delete this;
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::destroy()
-{
-    // 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();
-
-    // "delete this" and m_mainThreadLoader::deref() on the worker object's
-    // thread.
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadDestroy, crossThreadUnretained(this)));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadOverrideTimeout(unsigned long timeoutMilliseconds, ExecutionContext* context)
-{
-    ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context->isDocument());
-
-    if (!m_mainThreadLoader)
-        return;
-    m_mainThreadLoader->overrideTimeout(timeoutMilliseconds);
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::overrideTimeout(unsigned long timeoutMilliseconds)
-{
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadBridgeBase::mainThreadOverrideTimeout, crossThreadUnretained(this), timeoutMilliseconds));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::mainThreadCancel(ExecutionContext* context)
-{
-    ASSERT(isMainThread());
-    ASSERT_UNUSED(context, context->isDocument());
-
-    if (!m_mainThreadLoader)
-        return;
-    m_mainThreadLoader->cancel();
-    m_mainThreadLoader = nullptr;
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::cancel()
-{
-    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();
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
-{
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didSendData, m_workerClientWrapper, bytesSent, totalBytesToBeSent));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
-{
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResponse, m_workerClientWrapper, identifier, response, passed(std::move(handle))));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveData(const char* data, unsigned dataLength)
-{
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveData, m_workerClientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didDownloadData(int dataLength)
-{
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didDownloadData, m_workerClientWrapper, dataLength));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveCachedMetadata(const char* data, int dataLength)
-{
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveCachedMetadata, m_workerClientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didFinishLoading(unsigned long identifier, double finishTime)
-{
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFinishLoading, m_workerClientWrapper, identifier, finishTime));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didFail(const ResourceError& error)
-{
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFail, m_workerClientWrapper, error));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didFailAccessControlCheck(const ResourceError& error)
-{
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailAccessControlCheck, m_workerClientWrapper, error));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didFailRedirectCheck()
-{
-    forwardTaskToWorkerOnLoaderDone(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailRedirectCheck, m_workerClientWrapper));
-}
-
-void WorkerThreadableLoader::MainThreadBridgeBase::didReceiveResourceTiming(const ResourceTimingInfo& info)
-{
-    forwardTaskToWorker(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResourceTiming, m_workerClientWrapper, info));
-}
-
-WorkerThreadableLoader::MainThreadAsyncBridge::MainThreadAsyncBridge(
-    WorkerGlobalScope& workerGlobalScope,
-    ThreadableLoaderClientWrapper* workerClientWrapper,
-    const ThreadableLoaderOptions& options,
-    const ResourceLoaderOptions& resourceLoaderOptions)
-    : MainThreadBridgeBase(workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy())
-{
-    createLoaderInMainThread(options, resourceLoaderOptions);
-}
-
-void WorkerThreadableLoader::MainThreadAsyncBridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
-{
-    startInMainThread(request, workerGlobalScope);
-}
-
-WorkerThreadableLoader::MainThreadAsyncBridge::~MainThreadAsyncBridge()
-{
-}
-
-void WorkerThreadableLoader::MainThreadAsyncBridge::forwardTaskToWorker(std::unique_ptr<ExecutionContextTask> task)
-{
-    loaderProxy()->postTaskToWorkerGlobalScope(std::move(task));
-}
-
-void WorkerThreadableLoader::MainThreadAsyncBridge::forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask> task)
-{
-    loaderProxy()->postTaskToWorkerGlobalScope(std::move(task));
-}
-
-WorkerThreadableLoader::MainThreadSyncBridge::MainThreadSyncBridge(
-    WorkerGlobalScope& workerGlobalScope,
-    ThreadableLoaderClientWrapper* workerClientWrapper,
-    const ThreadableLoaderOptions& options,
-    const ResourceLoaderOptions& resourceLoaderOptions)
-    : MainThreadBridgeBase(workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy())
-    , m_done(false)
-{
-    createLoaderInMainThread(options, resourceLoaderOptions);
-}
-
-void WorkerThreadableLoader::MainThreadSyncBridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
-{
-    WaitableEvent* terminationEvent = workerGlobalScope.thread()->terminationEvent();
-    m_loaderDoneEvent = wrapUnique(new WaitableEvent());
-
-    startInMainThread(request, workerGlobalScope);
-
-    size_t signaledIndex;
+    , m_threadableLoaderOptions(threadableLoaderOptions)
+    , m_resourceLoaderOptions(resourceLoaderOptions)
+    , m_blockingBehavior(blockingBehavior)
+{
+    DCHECK(!isMainThread());
+}
+
+WorkerThreadableLoader::Bridge::~Bridge()
+{
+    DCHECK(!isMainThread());
+    DCHECK(!m_peer);
+}
+
+void WorkerThreadableLoader::Bridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
+{
+    DCHECK(!isMainThread());
+    RefPtr<WaitableEventWithTasks> eventWithTasks;
+    if (m_blockingBehavior == LoadSynchronously)
+        eventWithTasks = WaitableEventWithTasks::create();
+
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(
+        &Peer::createAndStart,
+        CrossThreadPersistent<Bridge>(this),
+        m_loaderProxy,
+        CrossThreadPersistent<WorkerThreadLifecycleContext>(workerGlobalScope.thread()->getWorkerThreadLifecycleContext()),
+        request,
+        threadableLoaderOptions(),
+        resourceLoaderOptions(),
+        eventWithTasks));
+
+    if (m_blockingBehavior == LoadAsynchronously)
+        return;
+
     {
-        Vector<WaitableEvent*> events;
-        // Order is important; indicies are used later.
-        events.append(terminationEvent);
-        events.append(m_loaderDoneEvent.get());
-
         SafePointScope scope(BlinkGC::HeapPointersOnStack);
-        signaledIndex = WaitableEvent::waitMultiple(events);
-    }
-    // |signaledIndex| is 0; which is terminationEvent.
-    if (signaledIndex == 0) {
+        eventWithTasks->wait();
+    }
+
+    if (eventWithTasks->isAborted()) {
+        // This thread is going to terminate.
         cancel();
         return;
     }
 
-    // The following code must be run only after |m_loaderDoneEvent| is
-    // signalled.
-
-    Vector<std::unique_ptr<ExecutionContextTask>> tasks;
-    {
-        MutexLocker lock(m_lock);
-        ASSERT(m_done);
-        m_clientTasks.swap(tasks);
-    }
-    for (const auto& task : tasks) {
+    for (const auto& task : eventWithTasks->take()) {
         // m_clientTask contains only CallClosureTasks. So, it's ok to pass
         // the nullptr.
         task->performTask(nullptr);
     }
 }
 
-WorkerThreadableLoader::MainThreadSyncBridge::~MainThreadSyncBridge()
-{
-    ASSERT(isMainThread());
-}
-
-void WorkerThreadableLoader::MainThreadSyncBridge::forwardTaskToWorker(std::unique_ptr<ExecutionContextTask> task)
-{
-    ASSERT(isMainThread());
-
-    MutexLocker lock(m_lock);
-    RELEASE_ASSERT(!m_done);
-
-    m_clientTasks.append(std::move(task));
-}
-
-void WorkerThreadableLoader::MainThreadSyncBridge::forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask> task)
-{
-    ASSERT(isMainThread());
-
-    MutexLocker lock(m_lock);
-    RELEASE_ASSERT(!m_done);
-
-    m_clientTasks.append(std::move(task));
-    m_done = true;
-    m_loaderDoneEvent->signal();
+void WorkerThreadableLoader::Bridge::overrideTimeout(unsigned long timeoutMilliseconds)
+{
+    DCHECK(!isMainThread());
+    if (!m_peer)
+        return;
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
+}
+
+void WorkerThreadableLoader::Bridge::cancel()
+{
+    DCHECK(!isMainThread());
+    if (!m_peer)
+        return;
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::cancel, m_peer));
+    m_peer = nullptr;

[haraken, 2016/07/22 08:57:30]

I'd remove line 277 - 280 and instead call destroy() at the end of cancel().

[yhirano, 2016/07/25 02:20:59]

Done. As m_clientWrapper->clearClient should be called differently, I added a
helper function.

+
+    auto clientWrapper = m_clientWrapper.get();
+
+    if (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);
+    clientWrapper->didFail(error);
+    clientWrapper->clearClient();
+}
+
+void WorkerThreadableLoader::Bridge::destroy()
+{
+    DCHECK(!isMainThread());
+    m_clientWrapper->clearClient();
+    if (!m_peer)
+        return;
+    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::cancel, m_peer));
+    m_peer = nullptr;
+}
+
+void WorkerThreadableLoader::Bridge::didStart(Peer* peer)
+{
+    DCHECK(!isMainThread());
+    DCHECK(!m_peer);
+    DCHECK(peer);
+    if (m_clientWrapper->done()) {
+        // The loading is already cancelled.
+        return;
+    }
+
+    m_peer = peer;
+}
+
+DEFINE_TRACE(WorkerThreadableLoader::Bridge)
+{
+    visitor->trace(m_clientWrapper);
+}
+
+void WorkerThreadableLoader::Peer::createAndStart(
+    Bridge* bridge,
+    PassRefPtr<WorkerLoaderProxy> passLoaderProxy,
+    WorkerThreadLifecycleContext* workerThreadLifecycleContext,
+    std::unique_ptr<CrossThreadResourceRequestData> request,
+    const ThreadableLoaderOptions& options,
+    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, CrossThreadPersistent<Bridge>(bridge), CrossThreadPersistent<Peer>(peer)));
+}
+
+WorkerThreadableLoader::Peer::~Peer()
+{
+    DCHECK(isMainThread());
+    DCHECK(!m_mainThreadLoader);
+}
+
+void WorkerThreadableLoader::Peer::overrideTimeout(unsigned long timeoutMilliseconds)
+{
+    DCHECK(isMainThread());
+    if (!m_mainThreadLoader)
+        return;
+    m_mainThreadLoader->overrideTimeout(timeoutMilliseconds);
+}
+
+void WorkerThreadableLoader::Peer::cancel()
+{
+    DCHECK(isMainThread());
+    if (!m_mainThreadLoader)
+        return;
+    m_mainThreadLoader->cancel();
+    m_mainThreadLoader = nullptr;
+}
+
+void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didSendData, clientWrapper, bytesSent, totalBytesToBeSent));
+}
+
+void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
+{
+    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::Peer::didReceiveData(const char* data, unsigned dataLength)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper || !m_forwarder)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveData, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+}
+
+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));
+}
+
+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))));
+}
+
+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;
+}
+
+void WorkerThreadableLoader::Peer::didFail(const ResourceError& error)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFail, clientWrapper, error));
+    m_forwarder = nullptr;
+}
+
+void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError& error)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailAccessControlCheck, clientWrapper, error));
+    m_forwarder = nullptr;
+}
+
+void WorkerThreadableLoader::Peer::didFailRedirectCheck()
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!m_forwarder || !clientWrapper)
+        return;
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailRedirectCheck, clientWrapper));
+    m_forwarder = nullptr;
+}
+
+void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTimingInfo& info)
+{
+    DCHECK(isMainThread());
+    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+    if (!clientWrapper)
+        return;
+    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResourceTiming, clientWrapper, info));
+}
+
+void WorkerThreadableLoader::Peer::contextDestroyed()

[haraken, 2016/07/22 08:57:30]

Just help me understand: Do we need to observe contextDestroyed()? When the
worker thread is shut down, Bridge::destroy() should have already been called.
Bridge::destroy() calls Peer:cancel(), so we won't need to call cancel() here.

Also the worker thread can abort things himself without relying on the main
thread call m_forwarder->abort().

[yhirano, 2016/07/25 02:20:59]

Peer needs to inherit WorkerThreadableLifecycleObserver from two reasons:


1) It should know if the thread is being terminated in Peer::createAndStart. As
the Peer is not yet associated with a Bridge, I would like to cancel the main
thread loader here.

2) The abort call in contextDestroyed interrupts a worker-side sync loading that
may block the thread termination (Even the worker thread is blocked, the
termination process can be started from the main thread).

[haraken, 2016/07/25 07:48:48]

Makes sense.

I now understand that Peer needs to observe contextDestroyed(), but do we need
to call Peer::cancel()? I guess Peer::cancel() will anyway be called when
Bridge::destroy() is called (when the worker thread terminates), so we don't
need to call it here.

[yhirano, 2016/07/25 11:07:46]

I'm concerned about the process shutdown scenario. On that case it's possible
that Bridge::destroy runs on the worker thread but the posted Peer::cancel won't
run on the main thread, I think.

What do you think about this scenario? If that's impossible, I think we can
remove this statement.

+{
+    DCHECK(isMainThread());
+    if (m_forwarder) {
+        m_forwarder->abort();
+        m_forwarder = nullptr;
+    }
+    m_clientWrapper = nullptr;
+    cancel();
+}
+
+DEFINE_TRACE(WorkerThreadableLoader::Peer)
+{
+    visitor->trace(m_forwarder);
+    WorkerThreadLifecycleObserver::trace(visitor);
+}
+
+WorkerThreadableLoader::Peer::Peer(TaskForwarder* forwarder, WorkerThreadLifecycleContext* context)
+    : WorkerThreadLifecycleObserver(context)
+    , m_forwarder(forwarder)
+{
+    DCHECK(isMainThread());
+}
+
+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