compositor-worker: Get the thread to run compositor-workers from the Platform.

Source/modules/compositorworker/CompositorWorkerManager.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 "config.h"
 #include "modules/compositorworker/CompositorWorkerManager.h"
 
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8Initializer.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "wtf/MainThread.h"
 #include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 
 namespace {
 
 static CompositorWorkerManager* s_instance = nullptr;
 
 static Mutex& singletonMutex()
 {
     AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
     return mutex;
 }
 
-static void destroyThread(WebThreadSupportingGC* thread)
+static void destroyThread(WebThread* thread)
 {
     delete thread;
 }
 
 } // namespace
 
 void CompositorWorkerManager::initialize()
 {
     MutexLocker lock(singletonMutex());
     ASSERT(!s_instance);
@@ skipping 16 matching lines @@
 }
 
 CompositorWorkerManager::CompositorWorkerManager()
 {
 }
 
 CompositorWorkerManager::~CompositorWorkerManager()
 {
 }
 
-WebThreadSupportingGC& CompositorWorkerManager::compositorWorkerThread()
+WebThread& CompositorWorkerManager::compositorWorkerThread()
 {
     MutexLocker lock(m_mutex);
     if (!m_thread) {
         ASSERT(isMainThread());
         ASSERT(!m_workerCount);
-        m_thread = WebThreadSupportingGC::create("CompositorWorker Thread");
+        // TODO(sad): Instead of creating a new thread, retrieve the thread from Platform using a more
+        // specialized function (e.g. Platform::comositorWorkerThread()).
+        m_thread = adoptPtr(Platform::current()->createThread("CompositorWorker Thread"));
     }
-    return *m_thread.get();
+    return *m_thread;
 }
 
 void CompositorWorkerManager::initializeBackingThread()
 {
     ASSERT(m_thread->isCurrentThread());
     MutexLocker lock(m_mutex);
     ++m_workerCount;
     if (m_workerCount > 1)
         return;
 
-    m_thread->initialize();
+    ASSERT(!m_gcSupport);
+    m_gcSupport = GCSupportForWebThread::create(*m_thread);
 
     // 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 CompositorWorkerManager::shutdownBackingThread()
 {
     MutexLocker lock(m_mutex);
     ASSERT(m_thread->isCurrentThread());
     ASSERT(m_workerCount > 0);
     --m_workerCount;
     if (m_workerCount == 0) {
-        m_thread->shutdown();
+        m_gcSupport.clear();
         Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(destroyThread, AllowCrossThreadAccess(m_thread.leakPtr())));
         m_thread = nullptr;
     }
 }
 
 v8::Isolate* CompositorWorkerManager::initializeIsolate()
 {
     MutexLocker lock(m_mutex);
     ASSERT(m_thread->isCurrentThread());
     ASSERT(m_isolate);
@@ skipping 24 matching lines @@
 {
     MutexLocker lock(m_mutex);
     ASSERT(isMainThread());
     if (m_workerCount > 1)
         return;
 
     v8::V8::TerminateExecution(m_isolate);
 }
 
 } // namespace blink