Index: third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp |
diff --git a/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp b/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp |
index 004e2e6db6cabb502b8a186a003a2d60d4c0c196..e68c9a31986aa39c1290c0153b420f675cce1856 100644 |
--- a/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp |
+++ b/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp |
@@ -6,6 +6,7 @@ |
#include "bindings/core/v8/V8GCController.h" |
#include "bindings/core/v8/V8Initializer.h" |
+#include "core/workers/WorkerBackingThread.h" |
#include "core/workers/WorkerObjectProxy.h" |
#include "core/workers/WorkerThreadStartupData.h" |
#include "modules/compositorworker/CompositorWorkerGlobalScope.h" |
@@ -17,122 +18,26 @@ namespace blink { |
namespace { |
-void destroyThread(WebThreadSupportingGC* thread) |
-{ |
- ASSERT(isMainThread()); |
- // The destructor for |thread| will block until all tasks have completed. |
- // This guarantees that shutdown will finish before the thread is destroyed. |
- delete thread; |
-} |
- |
-class CompositorWorkerSharedState { |
+class BackingThreadHolder { |
public: |
- static CompositorWorkerSharedState& instance() |
- { |
- DEFINE_THREAD_SAFE_STATIC_LOCAL(CompositorWorkerSharedState, compositorWorkerSharedState, (new CompositorWorkerSharedState())); |
- return compositorWorkerSharedState; |
- } |
- |
- WebThreadSupportingGC* compositorWorkerThread() |
- { |
- MutexLocker lock(m_mutex); |
- if (!m_thread && isMainThread()) { |
- ASSERT(!m_workerCount); |
- WebThread* platformThread = Platform::current()->compositorThread(); |
- m_thread = WebThreadSupportingGC::createForThread(platformThread); |
- } |
- return m_thread.get(); |
- } |
- |
- void initializeBackingThread() |
- { |
- MutexLocker lock(m_mutex); |
- ASSERT(m_thread->isCurrentThread()); |
- ++m_workerCount; |
- if (m_workerCount > 1) |
- return; |
- |
- m_thread->initialize(); |
- |
- // Initialize the isolate at the same time. |
- ASSERT(!m_isolate); |
- m_isolate = V8PerIsolateData::initialize(); |
- V8Initializer::initializeWorker(m_isolate); |
- |
- OwnPtr<V8IsolateInterruptor> interruptor = adoptPtr(new V8IsolateInterruptor(m_isolate)); |
- ThreadState::current()->addInterruptor(interruptor.release()); |
- ThreadState::current()->registerTraceDOMWrappers(m_isolate, V8GCController::traceDOMWrappers); |
- } |
- |
- void shutdownBackingThread() |
- { |
- MutexLocker lock(m_mutex); |
- ASSERT(m_thread->isCurrentThread()); |
- ASSERT(m_workerCount > 0); |
- --m_workerCount; |
- if (m_workerCount == 0) { |
- m_thread->shutdown(); |
- Platform::current()->mainThread()->getWebTaskRunner()->postTask( |
- BLINK_FROM_HERE, threadSafeBind(destroyThread, AllowCrossThreadAccess(m_thread.leakPtr()))); |
- } |
- } |
- |
- v8::Isolate* initializeIsolate() |
- { |
- MutexLocker lock(m_mutex); |
- ASSERT(m_thread->isCurrentThread()); |
- ASSERT(m_isolate); |
- // It is safe to use the existing isolate even if TerminateExecution() has been |
- // called on it, without calling CancelTerminateExecution(). |
- return m_isolate; |
- } |
- |
- void willDestroyIsolate() |
- { |
- MutexLocker lock(m_mutex); |
- ASSERT(m_thread->isCurrentThread()); |
- if (m_workerCount == 1) |
- V8PerIsolateData::willBeDestroyed(m_isolate); |
- } |
- |
- void destroyIsolate() |
- { |
- MutexLocker lock(m_mutex); |
- if (!m_thread) { |
- ASSERT(m_workerCount == 0); |
- V8PerIsolateData::destroy(m_isolate); |
- m_isolate = nullptr; |
- } |
- } |
- |
- void terminateV8Execution() |
+ static BackingThreadHolder& instance() |
{ |
- MutexLocker lock(m_mutex); |
- ASSERT(isMainThread() || m_thread->isCurrentThread()); |
- if (m_workerCount > 1) |
- return; |
- |
- m_isolate->TerminateExecution(); |
- } |
- |
- bool hasThreadForTest() |
- { |
- return m_thread; |
+ DEFINE_THREAD_SAFE_STATIC_LOCAL(BackingThreadHolder, holder, new BackingThreadHolder); |
+ return holder; |
} |
- bool hasIsolateForTest() |
+ WorkerBackingThread* thread() { return m_thread.get(); } |
+ void clear() { m_thread = nullptr; } |
+ void resetForTest() |
{ |
- return m_isolate; |
+ ASSERT(!m_thread || (m_thread->workerScriptCount() == 0)); |
+ m_thread = WorkerBackingThread::createForTest(Platform::current()->compositorThread()); |
} |
private: |
- CompositorWorkerSharedState() {} |
- ~CompositorWorkerSharedState() {} |
+ BackingThreadHolder() : m_thread(WorkerBackingThread::create(Platform::current()->compositorThread())) {} |
- Mutex m_mutex; |
- OwnPtr<WebThreadSupportingGC> m_thread; |
- int m_workerCount = 0; |
- v8::Isolate* m_isolate = nullptr; |
+ OwnPtr<WorkerBackingThread> m_thread; |
}; |
} // namespace |
@@ -155,9 +60,9 @@ CompositorWorkerThread::~CompositorWorkerThread() |
{ |
} |
-WebThreadSupportingGC* CompositorWorkerThread::sharedBackingThread() |
+WorkerBackingThread& CompositorWorkerThread::workerBackingThread() |
{ |
- return CompositorWorkerSharedState::instance().compositorWorkerThread(); |
+ return *BackingThreadHolder::instance().thread(); |
} |
WorkerGlobalScope*CompositorWorkerThread::createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData> startupData) |
@@ -166,54 +71,14 @@ WorkerGlobalScope*CompositorWorkerThread::createWorkerGlobalScope(PassOwnPtr<Wor |
return CompositorWorkerGlobalScope::create(this, startupData, m_timeOrigin); |
} |
-WebThreadSupportingGC& CompositorWorkerThread::backingThread() |
-{ |
- return *CompositorWorkerSharedState::instance().compositorWorkerThread(); |
-} |
- |
-void CompositorWorkerThread::initializeBackingThread() |
-{ |
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::initializeBackingThread"); |
- CompositorWorkerSharedState::instance().initializeBackingThread(); |
-} |
- |
-void CompositorWorkerThread::shutdownBackingThread() |
-{ |
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::shutdownBackingThread"); |
- CompositorWorkerSharedState::instance().shutdownBackingThread(); |
-} |
- |
-v8::Isolate* CompositorWorkerThread::initializeIsolate() |
-{ |
- return CompositorWorkerSharedState::instance().initializeIsolate(); |
-} |
- |
-void CompositorWorkerThread::willDestroyIsolate() |
-{ |
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::willDestroyIsolate"); |
- CompositorWorkerSharedState::instance().willDestroyIsolate(); |
-} |
- |
-void CompositorWorkerThread::destroyIsolate() |
-{ |
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::destroyIsolate"); |
- CompositorWorkerSharedState::instance().destroyIsolate(); |
-} |
- |
-void CompositorWorkerThread::terminateV8Execution() |
-{ |
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::terminateV8Execution"); |
- CompositorWorkerSharedState::instance().terminateV8Execution(); |
-} |
- |
-bool CompositorWorkerThread::hasThreadForTest() |
+void CompositorWorkerThread::clearSharedBackingThread() |
{ |
- return CompositorWorkerSharedState::instance().hasThreadForTest(); |
+ BackingThreadHolder::instance().clear(); |
} |
-bool CompositorWorkerThread::hasIsolateForTest() |
+void CompositorWorkerThread::resetSharedBackingThreadForTest() |
{ |
- return CompositorWorkerSharedState::instance().hasIsolateForTest(); |
+ BackingThreadHolder::instance().resetForTest(); |
} |
} // namespace blink |