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

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/ThreadSafeFunctional.h"
 #include "platform/TraceEvent.h"
+#include "platform/WaitableEvent.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 namespace {
 
 // This is a singleton class holding the compositor worker thread in this
-// renderrer process. BackingThreadHolst::m_thread will never be cleared,
-// but Oilpan and V8 are detached from the thread when the last compositor
-// worker thread is gone.
+// renderer process. BackingThreadHolder::m_thread is cleared by
+// ModulesInitializer::shutdown.
 // See WorkerThread::terminateAndWaitForAllWorkers for the process shutdown
 // case.
 class BackingThreadHolder {
 public:
     static BackingThreadHolder& instance()
     {
-        DEFINE_THREAD_SAFE_STATIC_LOCAL(BackingThreadHolder, holder, new BackingThreadHolder);
-        return holder;
+        MutexLocker locker(holderInstanceMutex());
+        return *s_instance;
+    }
+
+    static void ensureInstance()
+    {
+        MutexLocker locker(holderInstanceMutex());

[kinuko, 2016/05/23 09:53:55]

I'd like to remove this lock if it shouldn't be needed.  The threading
assertions we have seem to be enough, or are there still other possibilities
that we could be stumbled on?

[flackr, 2016/05/25 16:42:52]

Given s_instance is cleared on main after a synchronous shutdown, I think
removing this is fine. Done.

+        if (!s_instance)
+            s_instance = new BackingThreadHolder;
+    }
+
+    static void clear()
+    {
+        MutexLocker locker(holderInstanceMutex());
+        if (s_instance) {
+            s_instance->thread()->isolate()->TerminateExecution();
+            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()));

[flackr, 2016/05/20 15:51:18]

I didn't like how resetForTest swapped out the m_thread (which could have then
had the wrong workerBackingCount if the posted task had already run) and so I'd
have to check that the task to attach was still pending, so I decided we should
just pass the test WorkerBackingThread in to the constructor.

     }
 
     WorkerBackingThread* thread() { return m_thread.get(); }
-    void resetForTest()
+
+private:
+    BackingThreadHolder(PassOwnPtr<WorkerBackingThread> useBackingThread = nullptr)
+        : m_thread(useBackingThread ? useBackingThread.release() : WorkerBackingThread::create(Platform::current()->compositorThread()))
     {
-        ASSERT(!m_thread || (m_thread->workerScriptCount() == 0));
-        m_thread = nullptr;
-        m_thread = WorkerBackingThread::createForTest(Platform::current()->compositorThread());
+        DCHECK(isMainThread());
+        Platform::current()->compositorThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&BackingThreadHolder::initializeOnThread, AllowCrossThreadAccess(this)));
     }
 
-private:
-    BackingThreadHolder() : m_thread(WorkerBackingThread::create(Platform::current()->compositorThread())) {}
+    static Mutex& holderInstanceMutex()
+    {
+        DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, holderMutex, new Mutex);
+        return holderMutex;
+    }
+
+    void initializeOnThread()
+    {
+        DCHECK_EQ(0u, m_thread->workerScriptCount()) << "BackingThreadHolder should be the first to attach to WorkerBackingThread";
+        m_thread->attach();
+    }
+
+    void shutdownAndWait()
+    {
+        DCHECK(isMainThread());
+        WaitableEvent doneEvent;
+        Platform::current()->compositorThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&BackingThreadHolder::shutdownOnThread, AllowCrossThreadAccess(this), AllowCrossThreadAccess(&doneEvent)));
+        doneEvent.wait();
+    }
+
+    void shutdownOnThread(WaitableEvent* doneEvent)
+    {
+        DCHECK_EQ(1u, m_thread->workerScriptCount()) << "BackingThreadHolder should be the last to detach from WorkerBackingThread";
+        m_thread->detach();
+        doneEvent->signal();
+    }
 
     OwnPtr<WorkerBackingThread> m_thread;
+
+    static BackingThreadHolder* s_instance;
 };
 
+BackingThreadHolder* BackingThreadHolder::s_instance = nullptr;
+
 } // namespace
 
 PassOwnPtr<CompositorWorkerThread> CompositorWorkerThread::create(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, InProcessWorkerObjectProxy& workerObjectProxy, double timeOrigin)
 {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::create");
     ASSERT(isMainThread());
     return adoptPtr(new CompositorWorkerThread(workerLoaderProxy, workerObjectProxy, timeOrigin));
 }
 
 CompositorWorkerThread::CompositorWorkerThread(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, InProcessWorkerObjectProxy& workerObjectProxy, double timeOrigin)
@@ skipping 11 matching lines @@
 {
     return *BackingThreadHolder::instance().thread();
 }
 
 WorkerGlobalScope*CompositorWorkerThread::createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData> startupData)
 {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::createWorkerGlobalScope");
     return CompositorWorkerGlobalScope::create(this, std::move(startupData), m_timeOrigin);
 }
 
-void CompositorWorkerThread::resetSharedBackingThreadForTest()
+void CompositorWorkerThread::ensureSharedBackingThread()
 {
-    BackingThreadHolder::instance().resetForTest();
+    DCHECK(isMainThread());
+    BackingThreadHolder::ensureInstance();
+}
+
+void CompositorWorkerThread::clearSharedBackingThread()
+{
+    DCHECK(isMainThread());
+    BackingThreadHolder::clear();
+}
+
+void CompositorWorkerThread::createSharedBackingThreadForTest()
+{
+    BackingThreadHolder::createForTest();
 }
 
 } // namespace blink