blob: 45736806e457700f10364c5be672575adc443697 [file] [log] [blame]
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "modules/compositorworker/CompositorWorkerThread.h"
#include "bindings/core/v8/V8GCController.h"
#include "bindings/core/v8/V8Initializer.h"
#include "core/workers/InProcessWorkerObjectProxy.h"
#include "core/workers/WorkerBackingThread.h"
#include "core/workers/WorkerThreadStartupData.h"
#include "modules/compositorworker/CompositorWorkerGlobalScope.h"
#include "platform/ThreadSafeFunctional.h"
#include "platform/TraceEvent.h"
#include "platform/WaitableEvent.h"
#include "platform/WebThreadSupportingGC.h"
#include "public/platform/Platform.h"
#include "wtf/Assertions.h"
#include "wtf/PtrUtil.h"
#include <memory>
namespace blink {
namespace {
// This is a singleton class holding the compositor worker thread in this
// renderer process. BackingThreadHolder::m_thread is cleared by
// ModulesInitializer::shutdown.
// See WorkerThread::terminateAndWaitForAllWorkers for the process shutdown
// case.
class BackingThreadHolder {
public:
static BackingThreadHolder& instance()
{
MutexLocker locker(holderInstanceMutex());
return *s_instance;
}
static void ensureInstance()
{
if (!s_instance)
s_instance = new BackingThreadHolder;
}
static void clear()
{
MutexLocker locker(holderInstanceMutex());
if (s_instance) {
s_instance->shutdownAndWait();
delete s_instance;
s_instance = nullptr;
}
}
static void createForTest()
{
MutexLocker locker(holderInstanceMutex());
DCHECK_EQ(nullptr, s_instance);
s_instance = new BackingThreadHolder(WorkerBackingThread::createForTest(Platform::current()->compositorThread()));
}
WorkerBackingThread* thread() { return m_thread.get(); }
private:
BackingThreadHolder(std::unique_ptr<WorkerBackingThread> useBackingThread = nullptr)
: m_thread(useBackingThread ? std::move(useBackingThread) : WorkerBackingThread::create(Platform::current()->compositorThread()))
{
DCHECK(isMainThread());
m_thread->backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&BackingThreadHolder::initializeOnThread, AllowCrossThreadAccess(this)));
}
static Mutex& holderInstanceMutex()
{
DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, holderMutex, new Mutex);
return holderMutex;
}
void initializeOnThread()
{
MutexLocker locker(holderInstanceMutex());
DCHECK(!m_initialized);
m_thread->initialize();
m_initialized = true;
}
void shutdownAndWait()
{
DCHECK(isMainThread());
WaitableEvent doneEvent;
m_thread->backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&BackingThreadHolder::shutdownOnThread, AllowCrossThreadAccess(this), AllowCrossThreadAccess(&doneEvent)));
doneEvent.wait();
}
void shutdownOnThread(WaitableEvent* doneEvent)
{
m_thread->shutdown();
doneEvent->signal();
}
std::unique_ptr<WorkerBackingThread> m_thread;
bool m_initialized = false;
static BackingThreadHolder* s_instance;
};
BackingThreadHolder* BackingThreadHolder::s_instance = nullptr;
} // namespace
std::unique_ptr<CompositorWorkerThread> CompositorWorkerThread::create(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, InProcessWorkerObjectProxy& workerObjectProxy, double timeOrigin)
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::create");
ASSERT(isMainThread());
return wrapUnique(new CompositorWorkerThread(workerLoaderProxy, workerObjectProxy, timeOrigin));
}
CompositorWorkerThread::CompositorWorkerThread(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, InProcessWorkerObjectProxy& workerObjectProxy, double timeOrigin)
: WorkerThread(workerLoaderProxy, workerObjectProxy)
, m_workerObjectProxy(workerObjectProxy)
, m_timeOrigin(timeOrigin)
{
}
CompositorWorkerThread::~CompositorWorkerThread()
{
}
WorkerBackingThread& CompositorWorkerThread::workerBackingThread()
{
return *BackingThreadHolder::instance().thread();
}
WorkerGlobalScope*CompositorWorkerThread::createWorkerGlobalScope(std::unique_ptr<WorkerThreadStartupData> startupData)
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::createWorkerGlobalScope");
return CompositorWorkerGlobalScope::create(this, std::move(startupData), m_timeOrigin);
}
void CompositorWorkerThread::ensureSharedBackingThread()
{
DCHECK(isMainThread());
BackingThreadHolder::ensureInstance();
}
void CompositorWorkerThread::clearSharedBackingThread()
{
DCHECK(isMainThread());
BackingThreadHolder::clear();
}
void CompositorWorkerThread::createSharedBackingThreadForTest()
{
BackingThreadHolder::createForTest();
}
} // namespace blink