Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1363)

Unified Diff: Source/modules/compositorworker/CompositorWorkerManager.cpp

Issue 1158443008: compositor-worker: Share a thread and an isolate for compositor workers. (Closed) Base URL: svn://svn.chromium.org/blink/trunk
Patch Set: . Created 5 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: Source/modules/compositorworker/CompositorWorkerManager.cpp
diff --git a/Source/modules/compositorworker/CompositorWorkerManager.cpp b/Source/modules/compositorworker/CompositorWorkerManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d3dcf7d8f00fba68e5615aaadf1bb817e7b8dce
--- /dev/null
+++ b/Source/modules/compositorworker/CompositorWorkerManager.cpp
@@ -0,0 +1,158 @@
+// 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 "platform/ThreadSafeFunctional.h"
+#include "platform/WebThreadSupportingGC.h"
+#include "wtf/MainThread.h"
+#include "wtf/ThreadingPrimitives.h"
+
+namespace blink {
+
+namespace {
+
+class SharedV8Isolate final : public WorkerV8Isolate {
+ WTF_MAKE_NONCOPYABLE(SharedV8Isolate);
+public:
+ explicit SharedV8Isolate(v8::Isolate* isolate)
+ : m_isolate(isolate) { }
+ ~SharedV8Isolate() override
+ {
+ CompositorWorkerManager::instance()->destroyIsolate();
+ }
+
+private:
+ // WorkerV8Isolate:
+ v8::Isolate* isolate() const override { return m_isolate; }
+ void willDestroy() override
+ {
+ CompositorWorkerManager::instance()->willDestroyIsolate();
+ }
+
+ void terminateExecution() override
+ {
+ CompositorWorkerManager::instance()->terminateIsolate();
+ }
+
+ v8::Isolate* m_isolate;
+};
+
+static CompositorWorkerManager* s_instance = nullptr;
kinuko 2015/05/31 15:18:24 The same question I asked before... this means tha
sadrul 2015/05/31 16:23:42 I believe we have discussed this before. We can ge
+
+static Mutex& singletonMutex()
+{
+ AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
+ return mutex;
+}
+
+static void destroyThread(WebThreadSupportingGC* thread)
+{
+ delete thread;
+}
+
+} // namespace
+
+void CompositorWorkerManager::initialize()
+{
+ MutexLocker lock(singletonMutex());
+ ASSERT(!s_instance);
+ s_instance = new CompositorWorkerManager();
+}
+
+void CompositorWorkerManager::shutdown()
+{
+ MutexLocker lock(singletonMutex());
+ if (s_instance)
+ delete s_instance;
+ s_instance = nullptr;
+}
+
+CompositorWorkerManager* CompositorWorkerManager::instance()
+{
+ MutexLocker lock(singletonMutex());
+ ASSERT(s_instance);
+ return s_instance;
+}
+
+CompositorWorkerManager::CompositorWorkerManager()
+{
+}
+
+CompositorWorkerManager::~CompositorWorkerManager()
+{
+}
+
+WebThreadSupportingGC& CompositorWorkerManager::compositorWorkerThread()
+{
+ MutexLocker lock(m_mutex);
+ if (!m_thread) {
+ ASSERT(isMainThread());
+ ASSERT(!m_workerCount);
+ m_thread = WebThreadSupportingGC::create("CompositorWorker Thread");
+ }
+ return *m_thread.get();
+}
+
+void CompositorWorkerManager::initializeBackingThread()
+{
+ ASSERT(m_thread->isCurrentThread());
+ MutexLocker lock(m_mutex);
+ ++m_workerCount;
+ if (m_workerCount == 1)
+ m_thread->initialize();
+}
+
+void CompositorWorkerManager::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()->postTask(FROM_HERE, threadSafeBind(destroyThread, AllowCrossThreadAccess(m_thread.leakPtr())));
+ }
+}
+
+PassOwnPtr<WorkerV8Isolate> CompositorWorkerManager::createIsolate()
+{
+ MutexLocker lock(m_mutex);
+ ASSERT(m_thread->isCurrentThread());
+ if (!m_isolate)
+ m_isolate = WorkerV8Isolate::createDefault();
+ else if (m_isolate->isolate()->IsExecutionTerminating())
+ m_isolate->isolate()->CancelTerminateExecution();
+ ++m_isolateCount;
+ return adoptPtr(new SharedV8Isolate(m_isolate->isolate()));
+}
+
+void CompositorWorkerManager::willDestroyIsolate()
+{
+ MutexLocker lock(m_mutex);
+ ASSERT(m_thread->isCurrentThread());
+ --m_isolateCount;
+ if (m_isolateCount == 0)
+ m_isolate->willDestroy();
+}
+
+void CompositorWorkerManager::destroyIsolate()
+{
+ MutexLocker lock(m_mutex);
+ if (m_isolateCount == 0)
+ m_isolate = nullptr;
+}
+
+void CompositorWorkerManager::terminateIsolate()
+{
+ MutexLocker lock(m_mutex);
+ ASSERT(isMainThread());
+ if (m_isolateCount > 1)
+ return;
+
+ m_isolate->terminateExecution();
+}
+
+} // namespace blink

Powered by Google App Engine
This is Rietveld 408576698