[worklets] Split apart CompositorWorkerThread for sharing with AnimationWorkletThread.

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp

 // 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/CrossThreadFunctional.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, crossThreadBind(&BackingThreadHolder::initializeOnThread, crossThreadUnretained(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, crossThreadBind(&BackingThreadHolder::shutdownOnThread, crossThreadUnretained(this), crossThreadUnretained(&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)
+    : AbstractAnimationWorkletThread(workerLoaderProxy, workerObjectProxy)
     , m_workerObjectProxy(workerObjectProxy)
     , m_timeOrigin(timeOrigin)
 {
 }
 
 CompositorWorkerThread::~CompositorWorkerThread()
 {
 }
 
-WorkerBackingThread& CompositorWorkerThread::workerBackingThread()
-{
-    return *BackingThreadHolder::instance().thread();
-}
-
 WorkerOrWorkletGlobalScope* 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