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

Side by Side 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, 6 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 unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "config.h"
6 #include "modules/compositorworker/CompositorWorkerManager.h"
7
8 #include "platform/ThreadSafeFunctional.h"
9 #include "platform/WebThreadSupportingGC.h"
10 #include "wtf/MainThread.h"
11 #include "wtf/ThreadingPrimitives.h"
12
13 namespace blink {
14
15 namespace {
16
17 class SharedV8Isolate final : public WorkerIsolateWrapper {
18 WTF_MAKE_NONCOPYABLE(SharedV8Isolate);
19 public:
20 explicit SharedV8Isolate(v8::Isolate* isolate)
21 : m_isolate(isolate) { }
22 ~SharedV8Isolate() override
23 {
24 CompositorWorkerManager::instance()->destroyIsolate();
25 }
26
27 private:
28 // WorkerIsolateWrapper:
29 v8::Isolate* isolate() const override { return m_isolate; }
30 void willDestroy() override
31 {
32 CompositorWorkerManager::instance()->willDestroyIsolate();
33 }
34
35 void terminateExecution() override
36 {
37 CompositorWorkerManager::instance()->terminateIsolate();
38 }
39
40 v8::Isolate* m_isolate;
41 };
42
43 static CompositorWorkerManager* s_instance = nullptr;
44
45 static Mutex& singletonMutex()
46 {
47 AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
48 return mutex;
49 }
50
51 static void destroyThread(WebThreadSupportingGC* thread)
52 {
53 delete thread;
54 }
55
56 } // namespace
57
58 void CompositorWorkerManager::initialize()
59 {
60 MutexLocker lock(singletonMutex());
61 ASSERT(!s_instance);
62 s_instance = new CompositorWorkerManager();
63 }
64
65 void CompositorWorkerManager::shutdown()
66 {
67 MutexLocker lock(singletonMutex());
68 if (s_instance)
kinuko 2015/06/01 13:15:42 nit: could this be null?
sadrul 2015/06/01 14:21:16 We initialize conditionally on whether the feature
69 delete s_instance;
70 s_instance = nullptr;
71 }
72
73 CompositorWorkerManager* CompositorWorkerManager::instance()
74 {
75 MutexLocker lock(singletonMutex());
76 ASSERT(s_instance);
77 return s_instance;
78 }
79
80 CompositorWorkerManager::CompositorWorkerManager()
81 {
82 }
83
84 CompositorWorkerManager::~CompositorWorkerManager()
85 {
86 }
87
88 WebThreadSupportingGC& CompositorWorkerManager::compositorWorkerThread()
89 {
90 MutexLocker lock(m_mutex);
91 if (!m_thread) {
92 ASSERT(isMainThread());
93 ASSERT(!m_workerCount);
94 m_thread = WebThreadSupportingGC::create("CompositorWorker Thread");
95 }
96 return *m_thread.get();
97 }
98
99 void CompositorWorkerManager::initializeBackingThread()
100 {
101 ASSERT(m_thread->isCurrentThread());
102 MutexLocker lock(m_mutex);
103 ++m_workerCount;
104 if (m_workerCount == 1)
105 m_thread->initialize();
106 }
107
108 void CompositorWorkerManager::shutdownBackingThread()
109 {
110 MutexLocker lock(m_mutex);
111 ASSERT(m_thread->isCurrentThread());
112 ASSERT(m_workerCount > 0);
113 --m_workerCount;
114 if (m_workerCount == 0) {
115 m_thread->shutdown();
116 Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(de stroyThread, AllowCrossThreadAccess(m_thread.leakPtr())));
117 }
118 }
119
120 PassOwnPtr<WorkerIsolateWrapper> CompositorWorkerManager::createIsolate()
121 {
122 MutexLocker lock(m_mutex);
123 ASSERT(m_thread->isCurrentThread());
124 if (!m_isolate)
125 m_isolate = WorkerIsolateWrapper::createDefault();
126 else if (m_isolate->isolate()->IsExecutionTerminating())
127 m_isolate->isolate()->CancelTerminateExecution();
kinuko 2015/06/01 13:15:42 Was looking a recent bug that explains a bit about
sadrul 2015/06/01 14:21:16 Whoa. Thanks a lot for that link! Very informative
128 return adoptPtr(new SharedV8Isolate(m_isolate->isolate()));
129 }
130
131 void CompositorWorkerManager::willDestroyIsolate()
132 {
133 MutexLocker lock(m_mutex);
134 ASSERT(m_thread->isCurrentThread());
135 if (m_workerCount == 1)
136 m_isolate->willDestroy();
137 }
138
139 void CompositorWorkerManager::destroyIsolate()
140 {
141 MutexLocker lock(m_mutex);
142 if (!m_thread)
143 m_isolate.clear();
kinuko 2015/06/01 13:15:42 Can you also assert m_workerCount == 0 here?
sadrul 2015/06/01 14:21:16 Done.
144 }
145
146 void CompositorWorkerManager::terminateIsolate()
147 {
148 MutexLocker lock(m_mutex);
149 ASSERT(isMainThread());
150 if (m_workerCount > 1)
151 return;
152
153 m_isolate->terminateExecution();
154 }
155
156 } // namespace blink
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698