compositor-worker: Keep worker backing thread alive for the lifetime of the compositor thread.

third_party/WebKit/Source/core/workers/WorkerBackingThread.cpp

 // Copyright 2016 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 "core/workers/WorkerBackingThread.h"
 
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8IdleTaskRunner.h"
 #include "bindings/core/v8/V8Initializer.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ThreadSafeFunctional.h"
+#include "platform/WaitableEvent.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 
 namespace blink {
 
 WorkerBackingThread::WorkerBackingThread(const char* name, bool shouldCallGCOnShutdown)
     : m_backingThread(WebThreadSupportingGC::create(name))
     , m_isOwningThread(true)
     , m_shouldCallGCOnShutdown(shouldCallGCOnShutdown)
 {
 }
 
 WorkerBackingThread::WorkerBackingThread(WebThread* thread, bool shouldCallGCOnShutdown)
     : m_backingThread(WebThreadSupportingGC::createForThread(thread))
     , m_isOwningThread(false)
     , m_shouldCallGCOnShutdown(shouldCallGCOnShutdown)
 {
+    // WorkerBackingThread is created on main but needs to be initialized on the
+    // thread in order to attach that thread.
+    thread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerBackingThread::initialize, AllowCrossThreadAccess(this)));

[haraken, 2016/05/11 00:18:31]

I still don't understand why you have to call initialize() here. attach() also
calls initialize(). Don't we end up with calling initialize() twice?

[flackr, 2016/05/18 05:26:50]

I've changed WorkerBackingThread so that when you wrap an existing thread it
initializes once and does nothing when attach / detach are called and doesn't
call shutdown until you destruct the WorkerBackingThread. This is because we
can't call ThreadState::detach until we no longer have any oilpan objects owned
by the compositor thread.

 }
 
 WorkerBackingThread::~WorkerBackingThread()
 {
+    if (!m_isOwningThread)
+        signalShutdownAndWait();

[haraken, 2016/05/11 00:18:31]

I'd move this to CompositorWorkerThread::clearSharedBackingThread (since it's
not a good idea to do complicated stuff in a destructor).

[flackr, 2016/05/18 05:26:50]

Done.

 #if DCHECK_IS_ON()
     MutexLocker locker(m_mutex);
     DCHECK_EQ(0u, m_workerScriptCount);
 #endif
 }
 
 void WorkerBackingThread::attach()
 {
     {
         MutexLocker locker(m_mutex);
         if (++m_workerScriptCount > 1)
             return;
     }
-    initialize();
+    if (m_isOwningThread)
+        initialize();
 }
 
 void WorkerBackingThread::detach()
 {
     {
         MutexLocker locker(m_mutex);
         if (--m_workerScriptCount > 0)
             return;
     }
-    shutdown();
+    if (m_isOwningThread)
+        shutdown();
 }
 
 void WorkerBackingThread::initialize()
 {
     DCHECK(!m_isolate);
     m_isolate = V8PerIsolateData::initialize();
     V8Initializer::initializeWorker(m_isolate);
     m_backingThread->initialize();
 
     OwnPtr<V8IsolateInterruptor> interruptor = adoptPtr(new V8IsolateInterruptor(m_isolate));
     ThreadState::current()->addInterruptor(interruptor.release());
     ThreadState::current()->registerTraceDOMWrappers(m_isolate, V8GCController::traceDOMWrappers);
     if (RuntimeEnabledFeatures::v8IdleTasksEnabled())
         V8PerIsolateData::enableIdleTasks(m_isolate, adoptPtr(new V8IdleTaskRunner(backingThread().platformThread().scheduler())));
     if (m_isOwningThread)
         Platform::current()->didStartWorkerThread();
 }
 
-void WorkerBackingThread::shutdown()
+void WorkerBackingThread::shutdown(WaitableEvent* doneEvent)
 {
     if (m_isOwningThread)
         Platform::current()->willStopWorkerThread();
 
     V8PerIsolateData::willBeDestroyed(m_isolate);
     // TODO(yhirano): Remove this when https://crbug.com/v8/1428 is fixed.
     if (m_shouldCallGCOnShutdown) {
         // This statement runs only in tests.
         V8GCController::collectAllGarbageForTesting(m_isolate);
     }
     m_backingThread->shutdown();
 
     V8PerIsolateData::destroy(m_isolate);
     m_isolate = nullptr;
+    if (doneEvent)
+        doneEvent->signal();
+}
+
+void WorkerBackingThread::signalShutdownAndWait()
+{
+    WaitableEvent doneEvent;
+    m_backingThread->platformThread().getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerBackingThread::shutdown, AllowCrossThreadAccess(this), AllowCrossThreadAccess(&doneEvent)));
+    doneEvent.wait();
 }
 
 } // namespace blink