OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/pixel_buffer_raster_worker_pool.h" | 5 #include "cc/resources/pixel_buffer_raster_worker_pool.h" |
6 | 6 |
7 #include "base/containers/stack_container.h" | 7 #include "base/containers/stack_container.h" |
8 #include "base/debug/trace_event.h" | 8 #include "base/debug/trace_event.h" |
9 #include "base/values.h" | 9 #include "base/values.h" |
10 #include "cc/debug/traced_value.h" | 10 #include "cc/debug/traced_value.h" |
11 #include "cc/resources/resource.h" | 11 #include "cc/resources/resource.h" |
12 | 12 |
13 namespace cc { | 13 namespace cc { |
14 namespace { | 14 namespace { |
15 | 15 |
16 const int kCheckForCompletedRasterTasksDelayMs = 6; | 16 const int kCheckForCompletedRasterTasksDelayMs = 6; |
17 | 17 |
18 const size_t kMaxScheduledRasterTasks = 48; | 18 const size_t kMaxScheduledRasterTasks = 48; |
19 | 19 |
20 typedef base::StackVector<internal::WorkerPoolTask*, kMaxScheduledRasterTasks> | 20 typedef base::StackVector<internal::WorkerPoolTask*, kMaxScheduledRasterTasks> |
21 WorkerPoolTaskVector; | 21 WorkerPoolTaskVector; |
22 | 22 |
23 // Only used as std::find_if predicate for DCHECKs. | 23 // Only used as std::find_if predicate for DCHECKs. |
24 bool WasCanceled(const internal::RasterWorkerPoolTask* task) { | 24 bool WasCanceled(const internal::WorkerPoolTask* task) { |
25 return !task->HasFinishedRunning(); | 25 return !task->HasFinishedRunning(); |
26 } | 26 } |
27 | 27 |
28 } // namespace | 28 } // namespace |
29 | 29 |
30 // static | 30 // static |
31 scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create( | 31 scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create( |
32 ResourceProvider* resource_provider, | 32 ResourceProvider* resource_provider, |
33 size_t max_transfer_buffer_usage_bytes) { | 33 size_t max_transfer_buffer_usage_bytes) { |
34 return make_scoped_ptr<RasterWorkerPool>( | 34 return make_scoped_ptr<RasterWorkerPool>( |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
70 | 70 |
71 CheckForCompletedWorkerPoolTasks(); | 71 CheckForCompletedWorkerPoolTasks(); |
72 CheckForCompletedUploads(); | 72 CheckForCompletedUploads(); |
73 | 73 |
74 weak_factory_.InvalidateWeakPtrs(); | 74 weak_factory_.InvalidateWeakPtrs(); |
75 check_for_completed_raster_tasks_pending_ = false; | 75 check_for_completed_raster_tasks_pending_ = false; |
76 | 76 |
77 for (RasterTaskStateMap::iterator it = raster_task_states_.begin(); | 77 for (RasterTaskStateMap::iterator it = raster_task_states_.begin(); |
78 it != raster_task_states_.end(); | 78 it != raster_task_states_.end(); |
79 ++it) { | 79 ++it) { |
80 internal::RasterWorkerPoolTask* task = it->first; | 80 internal::WorkerPoolTask* task = it->first; |
| 81 RasterTaskState& state = it->second; |
81 | 82 |
82 // All unscheduled tasks need to be canceled. | 83 // All unscheduled tasks need to be canceled. |
83 if (it->second == UNSCHEDULED) { | 84 if (state.type == RasterTaskState::UNSCHEDULED) { |
84 completed_raster_tasks_.push_back(task); | 85 completed_raster_tasks_.push_back(task); |
85 it->second = COMPLETED; | 86 state.type = RasterTaskState::COMPLETED; |
86 } | 87 } |
87 } | 88 } |
88 DCHECK_EQ(completed_raster_tasks_.size(), raster_task_states_.size()); | 89 DCHECK_EQ(completed_raster_tasks_.size(), raster_task_states_.size()); |
89 } | 90 } |
90 | 91 |
91 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { | 92 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { |
92 TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks"); | 93 TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks"); |
93 | 94 |
94 DCHECK_EQ(queue->required_for_activation_count, | 95 DCHECK_EQ(queue->required_for_activation_count, |
95 static_cast<size_t>( | 96 static_cast<size_t>( |
96 std::count_if(queue->items.begin(), | 97 std::count_if(queue->items.begin(), |
97 queue->items.end(), | 98 queue->items.end(), |
98 RasterTaskQueue::Item::IsRequiredForActivation))); | 99 RasterTaskQueue::Item::IsRequiredForActivation))); |
99 | 100 |
100 if (!should_notify_client_if_no_tasks_are_pending_) | 101 if (!should_notify_client_if_no_tasks_are_pending_) |
101 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); | 102 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); |
102 | 103 |
103 should_notify_client_if_no_tasks_are_pending_ = true; | 104 should_notify_client_if_no_tasks_are_pending_ = true; |
104 should_notify_client_if_no_tasks_required_for_activation_are_pending_ = true; | 105 should_notify_client_if_no_tasks_required_for_activation_are_pending_ = true; |
105 | 106 |
106 raster_tasks_required_for_activation_.clear(); | 107 raster_tasks_required_for_activation_.clear(); |
107 | 108 |
108 // Build new raster task state map. | 109 // Build new raster task state map. |
109 RasterTaskStateMap new_raster_task_states; | 110 RasterTaskStateMap new_raster_task_states; |
110 for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); | 111 for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); |
111 it != queue->items.end(); | 112 it != queue->items.end(); |
112 ++it) { | 113 ++it) { |
113 const RasterTaskQueue::Item& item = *it; | 114 const RasterTaskQueue::Item& item = *it; |
114 internal::RasterWorkerPoolTask* task = item.task; | 115 internal::WorkerPoolTask* task = item.task; |
115 DCHECK(new_raster_task_states.find(task) == new_raster_task_states.end()); | 116 DCHECK(new_raster_task_states.find(task) == new_raster_task_states.end()); |
116 | 117 |
117 RasterTaskStateMap::iterator state_it = raster_task_states_.find(task); | 118 RasterTaskStateMap::iterator state_it = raster_task_states_.find(task); |
118 if (state_it != raster_task_states_.end()) { | 119 if (state_it != raster_task_states_.end()) { |
119 RasterTaskState state = state_it->second; | 120 RasterTaskState& state = state_it->second; |
120 | 121 |
121 new_raster_task_states[task] = state; | 122 new_raster_task_states[task] = state; |
122 // |raster_tasks_required_for_activation_| contains all tasks that need to | 123 // |raster_tasks_required_for_activation_| contains all tasks that need to |
123 // complete before we can send a "ready to activate" signal. Tasks that | 124 // complete before we can send a "ready to activate" signal. Tasks that |
124 // have already completed should not be part of this set. | 125 // have already completed should not be part of this set. |
125 if (state != COMPLETED && item.required_for_activation) | 126 if (state.type != RasterTaskState::COMPLETED && |
| 127 item.required_for_activation) |
126 raster_tasks_required_for_activation_.insert(task); | 128 raster_tasks_required_for_activation_.insert(task); |
127 | 129 |
128 raster_task_states_.erase(state_it); | 130 raster_task_states_.erase(state_it); |
129 } else { | 131 } else { |
130 DCHECK(!task->HasBeenScheduled()); | 132 DCHECK(!task->HasBeenScheduled()); |
131 new_raster_task_states[task] = UNSCHEDULED; | 133 new_raster_task_states[task].type = RasterTaskState::UNSCHEDULED; |
132 if (item.required_for_activation) | 134 if (item.required_for_activation) |
133 raster_tasks_required_for_activation_.insert(task); | 135 raster_tasks_required_for_activation_.insert(task); |
134 } | 136 } |
135 } | 137 } |
136 | 138 |
137 // Transfer old raster task state to |new_raster_task_states| and cancel all | 139 // Transfer old raster task state to |new_raster_task_states| and cancel all |
138 // remaining unscheduled tasks. | 140 // remaining unscheduled tasks. |
139 for (RasterTaskStateMap::iterator it = raster_task_states_.begin(); | 141 for (RasterTaskStateMap::iterator it = raster_task_states_.begin(); |
140 it != raster_task_states_.end(); | 142 it != raster_task_states_.end(); |
141 ++it) { | 143 ++it) { |
142 internal::RasterWorkerPoolTask* task = it->first; | 144 internal::WorkerPoolTask* task = it->first; |
| 145 RasterTaskState& state = it->second; |
143 DCHECK(new_raster_task_states.find(task) == new_raster_task_states.end()); | 146 DCHECK(new_raster_task_states.find(task) == new_raster_task_states.end()); |
144 | 147 |
145 // Unscheduled task can be canceled. | 148 // Unscheduled task can be canceled. |
146 if (it->second == UNSCHEDULED) { | 149 if (state.type == RasterTaskState::UNSCHEDULED) { |
147 DCHECK(!task->HasBeenScheduled()); | 150 DCHECK(!task->HasBeenScheduled()); |
148 DCHECK(std::find(completed_raster_tasks_.begin(), | 151 DCHECK(std::find(completed_raster_tasks_.begin(), |
149 completed_raster_tasks_.end(), | 152 completed_raster_tasks_.end(), |
150 task) == completed_raster_tasks_.end()); | 153 task) == completed_raster_tasks_.end()); |
151 completed_raster_tasks_.push_back(task); | 154 completed_raster_tasks_.push_back(task); |
152 new_raster_task_states[task] = COMPLETED; | 155 new_raster_task_states[task].type = RasterTaskState::COMPLETED; |
153 continue; | 156 continue; |
154 } | 157 } |
155 | 158 |
156 // Move state to |new_raster_task_states|. | 159 // Move state to |new_raster_task_states|. |
157 new_raster_task_states[task] = it->second; | 160 new_raster_task_states[task] = state; |
158 } | 161 } |
159 | 162 |
160 raster_tasks_.Swap(queue); | 163 raster_tasks_.Swap(queue); |
161 raster_task_states_.swap(new_raster_task_states); | 164 raster_task_states_.swap(new_raster_task_states); |
162 | 165 |
163 // Check for completed tasks when ScheduleTasks() is called as | 166 // Check for completed tasks when ScheduleTasks() is called as |
164 // priorities might have changed and this maximizes the number | 167 // priorities might have changed and this maximizes the number |
165 // of top priority tasks that are scheduled. | 168 // of top priority tasks that are scheduled. |
166 CheckForCompletedWorkerPoolTasks(); | 169 CheckForCompletedWorkerPoolTasks(); |
167 CheckForCompletedUploads(); | 170 CheckForCompletedUploads(); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
202 while (!completed_image_decode_tasks_.empty()) { | 205 while (!completed_image_decode_tasks_.empty()) { |
203 internal::WorkerPoolTask* task = | 206 internal::WorkerPoolTask* task = |
204 completed_image_decode_tasks_.front().get(); | 207 completed_image_decode_tasks_.front().get(); |
205 | 208 |
206 task->RunReplyOnOriginThread(); | 209 task->RunReplyOnOriginThread(); |
207 | 210 |
208 completed_image_decode_tasks_.pop_front(); | 211 completed_image_decode_tasks_.pop_front(); |
209 } | 212 } |
210 | 213 |
211 while (!completed_raster_tasks_.empty()) { | 214 while (!completed_raster_tasks_.empty()) { |
212 internal::RasterWorkerPoolTask* task = | 215 internal::WorkerPoolTask* task = completed_raster_tasks_.front().get(); |
213 completed_raster_tasks_.front().get(); | |
214 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); | 216 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); |
215 DCHECK_EQ(COMPLETED, raster_task_states_[task]); | 217 DCHECK_EQ(RasterTaskState::COMPLETED, raster_task_states_[task].type); |
216 | 218 |
217 raster_task_states_.erase(task); | 219 raster_task_states_.erase(task); |
218 | 220 |
219 task->RunReplyOnOriginThread(); | 221 task->RunReplyOnOriginThread(); |
220 | 222 |
221 completed_raster_tasks_.pop_front(); | 223 completed_raster_tasks_.pop_front(); |
222 } | 224 } |
223 } | 225 } |
224 | 226 |
225 SkCanvas* PixelBufferRasterWorkerPool::AcquireCanvasForRaster( | 227 SkCanvas* PixelBufferRasterWorkerPool::AcquireCanvasForRaster( |
226 internal::RasterWorkerPoolTask* task) { | 228 internal::WorkerPoolTask* task, |
227 resource_provider()->AcquirePixelRasterBuffer(task->resource()->id()); | 229 const Resource* resource) { |
228 return resource_provider()->MapPixelRasterBuffer(task->resource()->id()); | 230 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); |
| 231 DCHECK(!raster_task_states_[task].resource); |
| 232 raster_task_states_[task].resource = resource; |
| 233 resource_provider()->AcquirePixelRasterBuffer(resource->id()); |
| 234 return resource_provider()->MapPixelRasterBuffer(resource->id()); |
229 } | 235 } |
230 | 236 |
231 void PixelBufferRasterWorkerPool::OnRasterCompleted( | 237 void PixelBufferRasterWorkerPool::ReleaseCanvasForRaster( |
232 internal::RasterWorkerPoolTask* task, | 238 internal::WorkerPoolTask* task, |
233 const PicturePileImpl::Analysis& analysis) { | 239 const Resource* resource) { |
234 TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc"), | |
235 "PixelBufferRasterWorkerPool::OnRasterCompleted", | |
236 "was_canceled", | |
237 !task->HasFinishedRunning(), | |
238 "needs_upload", | |
239 task->HasFinishedRunning() && !analysis.is_solid_color); | |
240 | |
241 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); | 240 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); |
242 DCHECK_EQ(SCHEDULED, raster_task_states_[task]); | 241 DCHECK(raster_task_states_[task].resource == resource); |
243 | 242 resource_provider()->ReleasePixelRasterBuffer(resource->id()); |
244 // Balanced with MapPixelRasterBuffer() call in AcquireCanvasForRaster(). | |
245 resource_provider()->UnmapPixelRasterBuffer(task->resource()->id()); | |
246 | |
247 if (!task->HasFinishedRunning() || analysis.is_solid_color) { | |
248 resource_provider()->ReleasePixelRasterBuffer(task->resource()->id()); | |
249 | |
250 if (!task->HasFinishedRunning()) { | |
251 // When priorites change, a raster task can be canceled as a result of | |
252 // no longer being of high enough priority to fit in our throttled | |
253 // raster task budget. The task has not yet completed in this case. | |
254 for (RasterTaskQueue::Item::Vector::const_iterator it = | |
255 raster_tasks_.items.begin(); | |
256 it != raster_tasks_.items.end(); | |
257 ++it) { | |
258 if (it->task == task) { | |
259 raster_task_states_[task] = UNSCHEDULED; | |
260 return; | |
261 } | |
262 } | |
263 } | |
264 | |
265 DCHECK(std::find(completed_raster_tasks_.begin(), | |
266 completed_raster_tasks_.end(), | |
267 task) == completed_raster_tasks_.end()); | |
268 completed_raster_tasks_.push_back(task); | |
269 raster_task_states_[task] = COMPLETED; | |
270 raster_tasks_required_for_activation_.erase(task); | |
271 return; | |
272 } | |
273 | |
274 DCHECK(task->HasFinishedRunning()); | |
275 | |
276 resource_provider()->BeginSetPixels(task->resource()->id()); | |
277 has_performed_uploads_since_last_flush_ = true; | |
278 | |
279 bytes_pending_upload_ += task->resource()->bytes(); | |
280 raster_tasks_with_pending_upload_.push_back(task); | |
281 raster_task_states_[task] = UPLOADING; | |
282 } | |
283 | |
284 void PixelBufferRasterWorkerPool::OnImageDecodeCompleted( | |
285 internal::WorkerPoolTask* task) { | |
286 completed_image_decode_tasks_.push_back(task); | |
287 } | 243 } |
288 | 244 |
289 void PixelBufferRasterWorkerPool::OnRasterTasksFinished() { | 245 void PixelBufferRasterWorkerPool::OnRasterTasksFinished() { |
290 // |should_notify_client_if_no_tasks_are_pending_| can be set to false as | 246 // |should_notify_client_if_no_tasks_are_pending_| can be set to false as |
291 // a result of a scheduled CheckForCompletedRasterTasks() call. No need to | 247 // a result of a scheduled CheckForCompletedRasterTasks() call. No need to |
292 // perform another check in that case as we've already notified the client. | 248 // perform another check in that case as we've already notified the client. |
293 if (!should_notify_client_if_no_tasks_are_pending_) | 249 if (!should_notify_client_if_no_tasks_are_pending_) |
294 return; | 250 return; |
295 raster_finished_task_pending_ = false; | 251 raster_finished_task_pending_ = false; |
296 | 252 |
(...skipping 19 matching lines...) Expand all Loading... |
316 | 272 |
317 void PixelBufferRasterWorkerPool::FlushUploads() { | 273 void PixelBufferRasterWorkerPool::FlushUploads() { |
318 if (!has_performed_uploads_since_last_flush_) | 274 if (!has_performed_uploads_since_last_flush_) |
319 return; | 275 return; |
320 | 276 |
321 resource_provider()->ShallowFlushIfSupported(); | 277 resource_provider()->ShallowFlushIfSupported(); |
322 has_performed_uploads_since_last_flush_ = false; | 278 has_performed_uploads_since_last_flush_ = false; |
323 } | 279 } |
324 | 280 |
325 void PixelBufferRasterWorkerPool::CheckForCompletedUploads() { | 281 void PixelBufferRasterWorkerPool::CheckForCompletedUploads() { |
326 RasterTaskDeque tasks_with_completed_uploads; | 282 TaskDeque tasks_with_completed_uploads; |
327 | 283 |
328 // First check if any have completed. | 284 // First check if any have completed. |
329 while (!raster_tasks_with_pending_upload_.empty()) { | 285 while (!raster_tasks_with_pending_upload_.empty()) { |
330 internal::RasterWorkerPoolTask* task = | 286 internal::WorkerPoolTask* task = |
331 raster_tasks_with_pending_upload_.front().get(); | 287 raster_tasks_with_pending_upload_.front().get(); |
332 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); | 288 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); |
333 DCHECK_EQ(UPLOADING, raster_task_states_[task]); | 289 RasterTaskState& state = raster_task_states_[task]; |
| 290 DCHECK_EQ(RasterTaskState::UPLOADING, state.type); |
334 | 291 |
335 // Uploads complete in the order they are issued. | 292 // Uploads complete in the order they are issued. |
336 if (!resource_provider()->DidSetPixelsComplete(task->resource()->id())) | 293 if (!resource_provider()->DidSetPixelsComplete(state.resource->id())) |
337 break; | 294 break; |
338 | 295 |
339 tasks_with_completed_uploads.push_back(task); | 296 tasks_with_completed_uploads.push_back(task); |
340 raster_tasks_with_pending_upload_.pop_front(); | 297 raster_tasks_with_pending_upload_.pop_front(); |
341 } | 298 } |
342 | 299 |
343 DCHECK(client()); | 300 DCHECK(client()); |
344 bool should_force_some_uploads_to_complete = | 301 bool should_force_some_uploads_to_complete = |
345 shutdown_ || client()->ShouldForceTasksRequiredForActivationToComplete(); | 302 shutdown_ || client()->ShouldForceTasksRequiredForActivationToComplete(); |
346 | 303 |
347 if (should_force_some_uploads_to_complete) { | 304 if (should_force_some_uploads_to_complete) { |
348 RasterTaskDeque tasks_with_uploads_to_force; | 305 TaskDeque tasks_with_uploads_to_force; |
349 RasterTaskDeque::iterator it = raster_tasks_with_pending_upload_.begin(); | 306 TaskDeque::iterator it = raster_tasks_with_pending_upload_.begin(); |
350 while (it != raster_tasks_with_pending_upload_.end()) { | 307 while (it != raster_tasks_with_pending_upload_.end()) { |
351 internal::RasterWorkerPoolTask* task = it->get(); | 308 internal::WorkerPoolTask* task = it->get(); |
352 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); | 309 DCHECK(raster_task_states_.find(task) != raster_task_states_.end()); |
353 | 310 |
354 // Force all uploads required for activation to complete. | 311 // Force all uploads required for activation to complete. |
355 // During shutdown, force all pending uploads to complete. | 312 // During shutdown, force all pending uploads to complete. |
356 if (shutdown_ || IsRasterTaskRequiredForActivation(task)) { | 313 if (shutdown_ || IsRasterTaskRequiredForActivation(task)) { |
357 tasks_with_uploads_to_force.push_back(task); | 314 tasks_with_uploads_to_force.push_back(task); |
358 tasks_with_completed_uploads.push_back(task); | 315 tasks_with_completed_uploads.push_back(task); |
359 it = raster_tasks_with_pending_upload_.erase(it); | 316 it = raster_tasks_with_pending_upload_.erase(it); |
360 continue; | 317 continue; |
361 } | 318 } |
362 | 319 |
363 ++it; | 320 ++it; |
364 } | 321 } |
365 | 322 |
366 // Force uploads in reverse order. Since forcing can cause a wait on | 323 // Force uploads in reverse order. Since forcing can cause a wait on |
367 // all previous uploads, we would rather wait only once downstream. | 324 // all previous uploads, we would rather wait only once downstream. |
368 for (RasterTaskDeque::reverse_iterator it = | 325 for (TaskDeque::reverse_iterator it = tasks_with_uploads_to_force.rbegin(); |
369 tasks_with_uploads_to_force.rbegin(); | |
370 it != tasks_with_uploads_to_force.rend(); | 326 it != tasks_with_uploads_to_force.rend(); |
371 ++it) { | 327 ++it) { |
372 resource_provider()->ForceSetPixelsToComplete((*it)->resource()->id()); | 328 internal::WorkerPoolTask* task = it->get(); |
| 329 RasterTaskState& state = raster_task_states_[task]; |
| 330 DCHECK(state.resource); |
| 331 |
| 332 resource_provider()->ForceSetPixelsToComplete(state.resource->id()); |
373 has_performed_uploads_since_last_flush_ = true; | 333 has_performed_uploads_since_last_flush_ = true; |
374 } | 334 } |
375 } | 335 } |
376 | 336 |
377 // Release shared memory and move tasks with completed uploads | 337 // Release shared memory and move tasks with completed uploads |
378 // to |completed_raster_tasks_|. | 338 // to |completed_raster_tasks_|. |
379 while (!tasks_with_completed_uploads.empty()) { | 339 while (!tasks_with_completed_uploads.empty()) { |
380 internal::RasterWorkerPoolTask* task = | 340 internal::WorkerPoolTask* task = tasks_with_completed_uploads.front().get(); |
381 tasks_with_completed_uploads.front().get(); | 341 RasterTaskState& state = raster_task_states_[task]; |
382 | 342 |
383 // It's now safe to release the pixel buffer and the shared memory. | 343 bytes_pending_upload_ -= state.resource->bytes(); |
384 resource_provider()->ReleasePixelRasterBuffer(task->resource()->id()); | |
385 | 344 |
386 bytes_pending_upload_ -= task->resource()->bytes(); | 345 task->WillComplete(); |
| 346 task->CompleteOnOriginThread(this); |
| 347 task->DidComplete(); |
387 | 348 |
388 DCHECK(std::find(completed_raster_tasks_.begin(), | 349 DCHECK(std::find(completed_raster_tasks_.begin(), |
389 completed_raster_tasks_.end(), | 350 completed_raster_tasks_.end(), |
390 task) == completed_raster_tasks_.end()); | 351 task) == completed_raster_tasks_.end()); |
391 completed_raster_tasks_.push_back(task); | 352 completed_raster_tasks_.push_back(task); |
392 raster_task_states_[task] = COMPLETED; | 353 state.type = RasterTaskState::COMPLETED; |
393 | 354 |
394 raster_tasks_required_for_activation_.erase(task); | 355 raster_tasks_required_for_activation_.erase(task); |
395 | 356 |
396 tasks_with_completed_uploads.pop_front(); | 357 tasks_with_completed_uploads.pop_front(); |
397 } | 358 } |
398 } | 359 } |
399 | 360 |
400 void PixelBufferRasterWorkerPool::ScheduleCheckForCompletedRasterTasks() { | 361 void PixelBufferRasterWorkerPool::ScheduleCheckForCompletedRasterTasks() { |
401 base::TimeDelta delay = | 362 base::TimeDelta delay = |
402 base::TimeDelta::FromMilliseconds(kCheckForCompletedRasterTasksDelayMs); | 363 base::TimeDelta::FromMilliseconds(kCheckForCompletedRasterTasksDelayMs); |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
516 ++it) { | 477 ++it) { |
517 const RasterTaskQueue::Item& item = *it; | 478 const RasterTaskQueue::Item& item = *it; |
518 internal::RasterWorkerPoolTask* task = item.task; | 479 internal::RasterWorkerPoolTask* task = item.task; |
519 | 480 |
520 // |raster_task_states_| contains the state of all tasks that we have not | 481 // |raster_task_states_| contains the state of all tasks that we have not |
521 // yet run reply callbacks for. | 482 // yet run reply callbacks for. |
522 RasterTaskStateMap::iterator state_it = raster_task_states_.find(task); | 483 RasterTaskStateMap::iterator state_it = raster_task_states_.find(task); |
523 if (state_it == raster_task_states_.end()) | 484 if (state_it == raster_task_states_.end()) |
524 continue; | 485 continue; |
525 | 486 |
| 487 RasterTaskState& state = state_it->second; |
| 488 |
526 // Skip task if completed. | 489 // Skip task if completed. |
527 if (state_it->second == COMPLETED) { | 490 if (state.type == RasterTaskState::COMPLETED) { |
528 DCHECK(std::find(completed_raster_tasks_.begin(), | 491 DCHECK(std::find(completed_raster_tasks_.begin(), |
529 completed_raster_tasks_.end(), | 492 completed_raster_tasks_.end(), |
530 task) != completed_raster_tasks_.end()); | 493 task) != completed_raster_tasks_.end()); |
531 continue; | 494 continue; |
532 } | 495 } |
533 | 496 |
534 // All raster tasks need to be throttled by bytes of pending uploads. | 497 // All raster tasks need to be throttled by bytes of pending uploads. |
535 size_t new_bytes_pending_upload = bytes_pending_upload; | 498 size_t new_bytes_pending_upload = bytes_pending_upload; |
536 new_bytes_pending_upload += task->resource()->bytes(); | 499 new_bytes_pending_upload += task->resource()->bytes(); |
537 if (new_bytes_pending_upload > max_bytes_pending_upload_) { | 500 if (new_bytes_pending_upload > max_bytes_pending_upload_) { |
538 did_throttle_raster_tasks = true; | 501 did_throttle_raster_tasks = true; |
539 break; | 502 break; |
540 } | 503 } |
541 | 504 |
542 // If raster has finished, just update |bytes_pending_upload|. | 505 // If raster has finished, just update |bytes_pending_upload|. |
543 if (state_it->second == UPLOADING) { | 506 if (state.type == RasterTaskState::UPLOADING) { |
544 DCHECK(task->HasCompleted()); | 507 DCHECK(!task->HasCompleted()); |
545 bytes_pending_upload = new_bytes_pending_upload; | 508 bytes_pending_upload = new_bytes_pending_upload; |
546 continue; | 509 continue; |
547 } | 510 } |
548 | 511 |
549 // Throttle raster tasks based on kMaxScheduledRasterTasks. | 512 // Throttle raster tasks based on kMaxScheduledRasterTasks. |
550 if (tasks.container().size() >= kMaxScheduledRasterTasks) { | 513 if (tasks.container().size() >= kMaxScheduledRasterTasks) { |
551 did_throttle_raster_tasks = true; | 514 did_throttle_raster_tasks = true; |
552 break; | 515 break; |
553 } | 516 } |
554 | 517 |
555 // Update |bytes_pending_upload| now that task has cleared all | 518 // Update |bytes_pending_upload| now that task has cleared all |
556 // throttling limits. | 519 // throttling limits. |
557 bytes_pending_upload = new_bytes_pending_upload; | 520 bytes_pending_upload = new_bytes_pending_upload; |
558 | 521 |
559 DCHECK(state_it->second == UNSCHEDULED || state_it->second == SCHEDULED); | 522 DCHECK(state.type == RasterTaskState::UNSCHEDULED || |
560 state_it->second = SCHEDULED; | 523 state.type == RasterTaskState::SCHEDULED); |
| 524 state.type = RasterTaskState::SCHEDULED; |
561 | 525 |
562 InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++); | 526 InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++); |
563 | 527 |
564 tasks.container().push_back(task); | 528 tasks.container().push_back(task); |
565 if (item.required_for_activation) | 529 if (item.required_for_activation) |
566 tasks_required_for_activation.container().push_back(task); | 530 tasks_required_for_activation.container().push_back(task); |
567 } | 531 } |
568 | 532 |
569 scoped_refptr<internal::WorkerPoolTask> | 533 scoped_refptr<internal::WorkerPoolTask> |
570 new_raster_required_for_activation_finished_task; | 534 new_raster_required_for_activation_finished_task; |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
655 } | 619 } |
656 | 620 |
657 void PixelBufferRasterWorkerPool::CheckForCompletedWorkerPoolTasks() { | 621 void PixelBufferRasterWorkerPool::CheckForCompletedWorkerPoolTasks() { |
658 CollectCompletedWorkerPoolTasks(&completed_tasks_); | 622 CollectCompletedWorkerPoolTasks(&completed_tasks_); |
659 for (internal::Task::Vector::const_iterator it = completed_tasks_.begin(); | 623 for (internal::Task::Vector::const_iterator it = completed_tasks_.begin(); |
660 it != completed_tasks_.end(); | 624 it != completed_tasks_.end(); |
661 ++it) { | 625 ++it) { |
662 internal::WorkerPoolTask* task = | 626 internal::WorkerPoolTask* task = |
663 static_cast<internal::WorkerPoolTask*>(it->get()); | 627 static_cast<internal::WorkerPoolTask*>(it->get()); |
664 | 628 |
665 task->WillComplete(); | 629 RasterTaskStateMap::iterator state_it = raster_task_states_.find(task); |
666 task->CompleteOnOriginThread(this); | 630 if (state_it == raster_task_states_.end()) { |
667 task->DidComplete(); | 631 task->WillComplete(); |
| 632 task->CompleteOnOriginThread(this); |
| 633 task->DidComplete(); |
| 634 |
| 635 completed_image_decode_tasks_.push_back(task); |
| 636 continue; |
| 637 } |
| 638 |
| 639 RasterTaskState& state = state_it->second; |
| 640 DCHECK_EQ(RasterTaskState::SCHEDULED, state.type); |
| 641 DCHECK(state.resource); |
| 642 |
| 643 // Balanced with MapPixelRasterBuffer() call in AcquireCanvasForRaster(). |
| 644 bool content_has_changed = |
| 645 resource_provider()->UnmapPixelRasterBuffer(state.resource->id()); |
| 646 |
| 647 // |content_has_changed| can be false as result of task being canceled or |
| 648 // task implementation deciding not to modify bitmap (ie. analysis of raster |
| 649 // commands detected content as a solid color). |
| 650 if (!content_has_changed) { |
| 651 task->WillComplete(); |
| 652 task->CompleteOnOriginThread(this); |
| 653 task->DidComplete(); |
| 654 |
| 655 if (!task->HasFinishedRunning()) { |
| 656 // When priorites change, a raster task can be canceled as a result of |
| 657 // no longer being of high enough priority to fit in our throttled |
| 658 // raster task budget. The task has not yet completed in this case. |
| 659 RasterTaskQueue::Item::Vector::const_iterator item_it = |
| 660 std::find_if(raster_tasks_.items.begin(), |
| 661 raster_tasks_.items.end(), |
| 662 RasterTaskQueue::Item::TaskComparator(task)); |
| 663 if (item_it != raster_tasks_.items.end()) { |
| 664 state.type = RasterTaskState::UNSCHEDULED; |
| 665 state.resource = NULL; |
| 666 continue; |
| 667 } |
| 668 } |
| 669 |
| 670 DCHECK(std::find(completed_raster_tasks_.begin(), |
| 671 completed_raster_tasks_.end(), |
| 672 task) == completed_raster_tasks_.end()); |
| 673 completed_raster_tasks_.push_back(task); |
| 674 state.type = RasterTaskState::COMPLETED; |
| 675 raster_tasks_required_for_activation_.erase(task); |
| 676 continue; |
| 677 } |
| 678 |
| 679 DCHECK(task->HasFinishedRunning()); |
| 680 |
| 681 resource_provider()->BeginSetPixels(state.resource->id()); |
| 682 has_performed_uploads_since_last_flush_ = true; |
| 683 |
| 684 bytes_pending_upload_ += state.resource->bytes(); |
| 685 raster_tasks_with_pending_upload_.push_back(task); |
| 686 state.type = RasterTaskState::UPLOADING; |
668 } | 687 } |
669 completed_tasks_.clear(); | 688 completed_tasks_.clear(); |
670 } | 689 } |
671 | 690 |
672 bool PixelBufferRasterWorkerPool::IsRasterTaskRequiredForActivation( | 691 bool PixelBufferRasterWorkerPool::IsRasterTaskRequiredForActivation( |
673 internal::RasterWorkerPoolTask* task) const { | 692 internal::WorkerPoolTask* task) const { |
674 return raster_tasks_required_for_activation_.find(task) != | 693 return raster_tasks_required_for_activation_.find(task) != |
675 raster_tasks_required_for_activation_.end(); | 694 raster_tasks_required_for_activation_.end(); |
676 } | 695 } |
677 | 696 |
678 scoped_ptr<base::Value> PixelBufferRasterWorkerPool::StateAsValue() const { | 697 scoped_ptr<base::Value> PixelBufferRasterWorkerPool::StateAsValue() const { |
679 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue); | 698 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue); |
680 | 699 |
681 state->SetInteger("completed_count", completed_raster_tasks_.size()); | 700 state->SetInteger("completed_count", completed_raster_tasks_.size()); |
682 state->SetInteger("pending_count", raster_task_states_.size()); | 701 state->SetInteger("pending_count", raster_task_states_.size()); |
683 state->SetInteger("pending_upload_count", | 702 state->SetInteger("pending_upload_count", |
(...skipping 10 matching lines...) Expand all Loading... |
694 | 713 |
695 throttle_state->SetInteger("bytes_available_for_upload", | 714 throttle_state->SetInteger("bytes_available_for_upload", |
696 max_bytes_pending_upload_ - bytes_pending_upload_); | 715 max_bytes_pending_upload_ - bytes_pending_upload_); |
697 throttle_state->SetInteger("bytes_pending_upload", bytes_pending_upload_); | 716 throttle_state->SetInteger("bytes_pending_upload", bytes_pending_upload_); |
698 throttle_state->SetInteger("scheduled_raster_task_count", | 717 throttle_state->SetInteger("scheduled_raster_task_count", |
699 scheduled_raster_task_count_); | 718 scheduled_raster_task_count_); |
700 return throttle_state.PassAs<base::Value>(); | 719 return throttle_state.PassAs<base::Value>(); |
701 } | 720 } |
702 | 721 |
703 } // namespace cc | 722 } // namespace cc |
OLD | NEW |