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

Side by Side Diff: cc/resources/pixel_buffer_raster_worker_pool.cc

Issue 170783007: Re-land: cc: Cleanup internal::WorkerPoolTaskClient interface. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix bad DCHECK Created 6 years, 10 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
« no previous file with comments | « cc/resources/pixel_buffer_raster_worker_pool.h ('k') | cc/resources/raster_worker_pool.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « cc/resources/pixel_buffer_raster_worker_pool.h ('k') | cc/resources/raster_worker_pool.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698