OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/resources/direct_raster_worker_pool.h" | 5 #include "cc/resources/gpu_raster_worker_pool.h" |
6 | 6 |
7 #include "base/debug/trace_event.h" | 7 #include "base/debug/trace_event.h" |
8 #include "cc/output/context_provider.h" | 8 #include "cc/output/context_provider.h" |
9 #include "cc/resources/resource.h" | 9 #include "cc/resources/resource.h" |
10 #include "cc/resources/resource_provider.h" | 10 #include "cc/resources/resource_provider.h" |
11 #include "gpu/command_buffer/client/gles2_interface.h" | 11 #include "gpu/command_buffer/client/gles2_interface.h" |
12 #include "third_party/skia/include/gpu/GrContext.h" | 12 #include "third_party/skia/include/gpu/GrContext.h" |
13 | 13 |
14 namespace cc { | 14 namespace cc { |
15 | 15 |
16 // static | 16 // static |
17 scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create( | 17 scoped_ptr<RasterWorkerPool> GpuRasterWorkerPool::Create( |
18 base::SequencedTaskRunner* task_runner, | 18 base::SequencedTaskRunner* task_runner, |
19 ResourceProvider* resource_provider, | 19 ResourceProvider* resource_provider, |
20 ContextProvider* context_provider) { | 20 ContextProvider* context_provider) { |
21 return make_scoped_ptr<RasterWorkerPool>(new DirectRasterWorkerPool( | 21 return make_scoped_ptr<RasterWorkerPool>(new GpuRasterWorkerPool( |
22 task_runner, resource_provider, context_provider)); | 22 task_runner, resource_provider, context_provider)); |
23 } | 23 } |
24 | 24 |
25 DirectRasterWorkerPool::DirectRasterWorkerPool( | 25 GpuRasterWorkerPool::GpuRasterWorkerPool(base::SequencedTaskRunner* task_runner, |
26 base::SequencedTaskRunner* task_runner, | 26 ResourceProvider* resource_provider, |
27 ResourceProvider* resource_provider, | 27 ContextProvider* context_provider) |
28 ContextProvider* context_provider) | |
29 : task_runner_(task_runner), | 28 : task_runner_(task_runner), |
30 task_graph_runner_(new TaskGraphRunner), | 29 task_graph_runner_(new TaskGraphRunner), |
31 namespace_token_(task_graph_runner_->GetNamespaceToken()), | 30 namespace_token_(task_graph_runner_->GetNamespaceToken()), |
32 resource_provider_(resource_provider), | 31 resource_provider_(resource_provider), |
33 context_provider_(context_provider), | 32 context_provider_(context_provider), |
34 run_tasks_on_origin_thread_pending_(false), | 33 run_tasks_on_origin_thread_pending_(false), |
35 raster_tasks_pending_(false), | 34 raster_tasks_pending_(false), |
36 raster_tasks_required_for_activation_pending_(false), | 35 raster_tasks_required_for_activation_pending_(false), |
37 raster_finished_weak_ptr_factory_(this), | 36 raster_finished_weak_ptr_factory_(this), |
38 weak_ptr_factory_(this) {} | 37 weak_ptr_factory_(this) { |
38 } | |
39 | 39 |
40 DirectRasterWorkerPool::~DirectRasterWorkerPool() { | 40 GpuRasterWorkerPool::~GpuRasterWorkerPool() { |
41 DCHECK_EQ(0u, completed_tasks_.size()); | 41 DCHECK_EQ(0u, completed_tasks_.size()); |
42 } | 42 } |
43 | 43 |
44 Rasterizer* DirectRasterWorkerPool::AsRasterizer() { return this; } | 44 Rasterizer* GpuRasterWorkerPool::AsRasterizer() { |
45 return this; | |
46 } | |
45 | 47 |
46 void DirectRasterWorkerPool::SetClient(RasterizerClient* client) { | 48 void GpuRasterWorkerPool::SetClient(RasterizerClient* client) { |
47 client_ = client; | 49 client_ = client; |
48 } | 50 } |
49 | 51 |
50 void DirectRasterWorkerPool::Shutdown() { | 52 void GpuRasterWorkerPool::Shutdown() { |
51 TRACE_EVENT0("cc", "DirectRasterWorkerPool::Shutdown"); | 53 TRACE_EVENT0("cc", "GpuRasterWorkerPool::Shutdown"); |
52 | 54 |
53 TaskGraph empty; | 55 TaskGraph empty; |
54 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); | 56 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); |
55 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | 57 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); |
56 } | 58 } |
57 | 59 |
58 void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { | 60 void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { |
59 TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks"); | 61 TRACE_EVENT0("cc", "GpuRasterWorkerPool::ScheduleTasks"); |
60 | 62 |
61 DCHECK_EQ(queue->required_for_activation_count, | 63 DCHECK_EQ(queue->required_for_activation_count, |
62 static_cast<size_t>( | 64 static_cast<size_t>( |
63 std::count_if(queue->items.begin(), | 65 std::count_if(queue->items.begin(), |
64 queue->items.end(), | 66 queue->items.end(), |
65 RasterTaskQueue::Item::IsRequiredForActivation))); | 67 RasterTaskQueue::Item::IsRequiredForActivation))); |
66 | 68 |
67 raster_tasks_pending_ = true; | 69 raster_tasks_pending_ = true; |
68 raster_tasks_required_for_activation_pending_ = true; | 70 raster_tasks_required_for_activation_pending_ = true; |
69 | 71 |
70 unsigned priority = kRasterTaskPriorityBase; | 72 unsigned priority = kRasterTaskPriorityBase; |
71 | 73 |
72 graph_.Reset(); | 74 graph_.Reset(); |
73 | 75 |
74 // Cancel existing OnRasterFinished callbacks. | 76 // Cancel existing OnRasterFinished callbacks. |
75 raster_finished_weak_ptr_factory_.InvalidateWeakPtrs(); | 77 raster_finished_weak_ptr_factory_.InvalidateWeakPtrs(); |
76 | 78 |
77 scoped_refptr<RasterizerTask> | 79 scoped_refptr<RasterizerTask> |
78 new_raster_required_for_activation_finished_task( | 80 new_raster_required_for_activation_finished_task( |
79 CreateRasterRequiredForActivationFinishedTask( | 81 CreateRasterRequiredForActivationFinishedTask( |
80 queue->required_for_activation_count, | 82 queue->required_for_activation_count, |
81 task_runner_.get(), | 83 task_runner_.get(), |
82 base::Bind(&DirectRasterWorkerPool:: | 84 base::Bind( |
83 OnRasterRequiredForActivationFinished, | 85 &GpuRasterWorkerPool::OnRasterRequiredForActivationFinished, |
84 raster_finished_weak_ptr_factory_.GetWeakPtr()))); | 86 raster_finished_weak_ptr_factory_.GetWeakPtr()))); |
85 scoped_refptr<RasterizerTask> new_raster_finished_task( | 87 scoped_refptr<RasterizerTask> new_raster_finished_task( |
86 CreateRasterFinishedTask( | 88 CreateRasterFinishedTask( |
87 task_runner_.get(), | 89 task_runner_.get(), |
88 base::Bind(&DirectRasterWorkerPool::OnRasterFinished, | 90 base::Bind(&GpuRasterWorkerPool::OnRasterFinished, |
89 raster_finished_weak_ptr_factory_.GetWeakPtr()))); | 91 raster_finished_weak_ptr_factory_.GetWeakPtr()))); |
90 | 92 |
91 for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); | 93 for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); |
92 it != queue->items.end(); | 94 it != queue->items.end(); |
93 ++it) { | 95 ++it) { |
94 const RasterTaskQueue::Item& item = *it; | 96 const RasterTaskQueue::Item& item = *it; |
95 RasterTask* task = item.task; | 97 RasterTask* task = item.task; |
96 DCHECK(!task->HasCompleted()); | 98 DCHECK(!task->HasCompleted()); |
97 | 99 |
98 if (item.required_for_activation) { | 100 if (item.required_for_activation) { |
(...skipping 19 matching lines...) Expand all Loading... | |
118 ScheduleTasksOnOriginThread(this, &graph_); | 120 ScheduleTasksOnOriginThread(this, &graph_); |
119 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); | 121 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); |
120 | 122 |
121 ScheduleRunTasksOnOriginThread(); | 123 ScheduleRunTasksOnOriginThread(); |
122 | 124 |
123 raster_finished_task_ = new_raster_finished_task; | 125 raster_finished_task_ = new_raster_finished_task; |
124 raster_required_for_activation_finished_task_ = | 126 raster_required_for_activation_finished_task_ = |
125 new_raster_required_for_activation_finished_task; | 127 new_raster_required_for_activation_finished_task; |
126 } | 128 } |
127 | 129 |
128 void DirectRasterWorkerPool::CheckForCompletedTasks() { | 130 void GpuRasterWorkerPool::CheckForCompletedTasks() { |
129 TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks"); | 131 TRACE_EVENT0("cc", "GpuRasterWorkerPool::CheckForCompletedTasks"); |
130 | 132 |
131 task_graph_runner_->CollectCompletedTasks(namespace_token_, | 133 task_graph_runner_->CollectCompletedTasks(namespace_token_, |
132 &completed_tasks_); | 134 &completed_tasks_); |
133 for (Task::Vector::const_iterator it = completed_tasks_.begin(); | 135 for (Task::Vector::const_iterator it = completed_tasks_.begin(); |
134 it != completed_tasks_.end(); | 136 it != completed_tasks_.end(); |
135 ++it) { | 137 ++it) { |
136 RasterizerTask* task = static_cast<RasterizerTask*>(it->get()); | 138 RasterizerTask* task = static_cast<RasterizerTask*>(it->get()); |
137 | 139 |
138 task->WillComplete(); | 140 task->WillComplete(); |
139 task->CompleteOnOriginThread(this); | 141 task->CompleteOnOriginThread(this); |
140 task->DidComplete(); | 142 task->DidComplete(); |
141 | 143 |
142 task->RunReplyOnOriginThread(); | 144 task->RunReplyOnOriginThread(); |
143 } | 145 } |
144 completed_tasks_.clear(); | 146 completed_tasks_.clear(); |
145 } | 147 } |
146 | 148 |
147 SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) { | 149 SkCanvas* GpuRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) { |
148 return resource_provider_->MapDirectRasterBuffer(task->resource()->id()); | 150 return resource_provider_->MapGpuRasterBuffer(task->resource()->id()); |
149 } | 151 } |
150 | 152 |
151 void DirectRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) { | 153 void GpuRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) { |
152 resource_provider_->UnmapDirectRasterBuffer(task->resource()->id()); | 154 resource_provider_->UnmapGpuRasterBuffer(task->resource()->id()); |
153 } | 155 } |
154 | 156 |
155 void DirectRasterWorkerPool::OnRasterFinished() { | 157 void GpuRasterWorkerPool::OnRasterFinished() { |
156 TRACE_EVENT0("cc", "DirectRasterWorkerPool::OnRasterFinished"); | 158 TRACE_EVENT0("cc", "GpuRasterWorkerPool::OnRasterFinished"); |
157 | 159 |
158 DCHECK(raster_tasks_pending_); | 160 DCHECK(raster_tasks_pending_); |
159 raster_tasks_pending_ = false; | 161 raster_tasks_pending_ = false; |
160 client_->DidFinishRunningTasks(); | 162 client_->DidFinishRunningTasks(); |
161 } | 163 } |
162 | 164 |
163 void DirectRasterWorkerPool::OnRasterRequiredForActivationFinished() { | 165 void GpuRasterWorkerPool::OnRasterRequiredForActivationFinished() { |
164 TRACE_EVENT0("cc", | 166 TRACE_EVENT0("cc", |
165 "DirectRasterWorkerPool::OnRasterRequiredForActivationFinished"); | 167 "GpuRasterWorkerPool::OnRasterRequiredForActivationFinished"); |
166 | 168 |
167 DCHECK(raster_tasks_required_for_activation_pending_); | 169 DCHECK(raster_tasks_required_for_activation_pending_); |
168 raster_tasks_required_for_activation_pending_ = false; | 170 raster_tasks_required_for_activation_pending_ = false; |
169 client_->DidFinishRunningTasksRequiredForActivation(); | 171 client_->DidFinishRunningTasksRequiredForActivation(); |
170 } | 172 } |
171 | 173 |
172 void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() { | 174 void GpuRasterWorkerPool::ScheduleRunTasksOnOriginThread() { |
173 if (run_tasks_on_origin_thread_pending_) | 175 if (run_tasks_on_origin_thread_pending_) |
174 return; | 176 return; |
175 | 177 |
176 task_runner_->PostTask( | 178 task_runner_->PostTask( |
177 FROM_HERE, | 179 FROM_HERE, |
178 base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread, | 180 base::Bind(&GpuRasterWorkerPool::RunTasksOnOriginThread, |
179 weak_ptr_factory_.GetWeakPtr())); | 181 weak_ptr_factory_.GetWeakPtr())); |
180 run_tasks_on_origin_thread_pending_ = true; | 182 run_tasks_on_origin_thread_pending_ = true; |
181 } | 183 } |
182 | 184 |
183 void DirectRasterWorkerPool::RunTasksOnOriginThread() { | 185 void GpuRasterWorkerPool::RunTasksOnOriginThread() { |
184 TRACE_EVENT0("cc", "DirectRasterWorkerPool::RunTasksOnOriginThread"); | 186 TRACE_EVENT0("cc", "GpuRasterWorkerPool::RunTasksOnOriginThread"); |
185 | 187 |
186 DCHECK(run_tasks_on_origin_thread_pending_); | 188 DCHECK(run_tasks_on_origin_thread_pending_); |
187 run_tasks_on_origin_thread_pending_ = false; | 189 run_tasks_on_origin_thread_pending_ = false; |
188 | 190 |
189 if (context_provider_) { | 191 if (context_provider_) { |
190 DCHECK(context_provider_->ContextGL()); | 192 DCHECK(context_provider_->ContextGL()); |
191 // TODO(alokp): Use a trace macro to push/pop markers. | 193 // TODO(alokp): Use a trace macro to push/pop markers. |
192 // Using push/pop functions directly incurs cost to evaluate function | 194 // Using push/pop functions directly incurs cost to evaluate function |
193 // arguments even when tracing is disabled. | 195 // arguments even when tracing is disabled. |
194 context_provider_->ContextGL()->PushGroupMarkerEXT( | 196 context_provider_->ContextGL()->PushGroupMarkerEXT( |
195 0, "DirectRasterWorkerPool::RunTasksOnOriginThread"); | 197 0, "GpuRasterWorkerPool::RunTasksOnOriginThread"); |
196 | 198 |
197 GrContext* gr_context = context_provider_->GrContext(); | 199 GrContext* gr_context = context_provider_->GrContext(); |
198 // TODO(alokp): Implement TestContextProvider::GrContext(). | 200 // TODO(alokp): Implement TestContextProvider::GrContext(). |
199 if (gr_context) | 201 if (gr_context) |
200 gr_context->resetContext(); | 202 gr_context->resetContext(); |
201 } | 203 } |
reveman
2014/06/30 13:20:15
This ContextProvider related code doesn't belong h
sohanjg
2014/06/30 15:02:35
We already have ResourceProvider API's for glconte
reveman
2014/06/30 15:22:32
It'd be better if this code didn't make any assump
sohanjg
2014/06/30 16:05:50
OK. I will put a separate patch for it.
| |
202 | 204 |
203 task_graph_runner_->RunUntilIdle(); | 205 task_graph_runner_->RunUntilIdle(); |
204 | 206 |
205 if (context_provider_) { | 207 if (context_provider_) { |
206 GrContext* gr_context = context_provider_->GrContext(); | 208 GrContext* gr_context = context_provider_->GrContext(); |
207 // TODO(alokp): Implement TestContextProvider::GrContext(). | 209 // TODO(alokp): Implement TestContextProvider::GrContext(). |
208 if (gr_context) | 210 if (gr_context) |
209 gr_context->flush(); | 211 gr_context->flush(); |
210 | 212 |
211 context_provider_->ContextGL()->PopGroupMarkerEXT(); | 213 context_provider_->ContextGL()->PopGroupMarkerEXT(); |
212 } | 214 } |
213 } | 215 } |
214 | 216 |
215 } // namespace cc | 217 } // namespace cc |
OLD | NEW |