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/raster_worker_pool.h" | 5 #include "cc/resources/raster_worker_pool.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/debug/trace_event_synthetic_delay.h" | 9 #include "base/debug/trace_event_synthetic_delay.h" |
10 #include "base/json/json_writer.h" | 10 #include "base/json/json_writer.h" |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 if (type != SkDrawFilter::kText_Type) | 62 if (type != SkDrawFilter::kText_Type) |
63 return true; | 63 return true; |
64 | 64 |
65 paint->setLCDRenderText(false); | 65 paint->setLCDRenderText(false); |
66 return true; | 66 return true; |
67 } | 67 } |
68 }; | 68 }; |
69 | 69 |
70 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask { | 70 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask { |
71 public: | 71 public: |
72 RasterWorkerPoolTaskImpl(const Resource* resource, | 72 RasterWorkerPoolTaskImpl( |
73 PicturePileImpl* picture_pile, | 73 const Resource* resource, |
74 const gfx::Rect& content_rect, | 74 PicturePileImpl* picture_pile, |
75 float contents_scale, | 75 const gfx::Rect& content_rect, |
76 RasterMode raster_mode, | 76 float contents_scale, |
77 TileResolution tile_resolution, | 77 RasterMode raster_mode, |
78 int layer_id, | 78 TileResolution tile_resolution, |
79 const void* tile_id, | 79 int layer_id, |
80 int source_frame_number, | 80 const void* tile_id, |
81 bool use_gpu_rasterization, | 81 int source_frame_number, |
82 RenderingStatsInstrumentation* rendering_stats, | 82 RenderingStatsInstrumentation* rendering_stats, |
83 const RasterWorkerPool::RasterTask::Reply& reply, | 83 const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply, |
84 internal::Task::Vector* dependencies) | 84 internal::WorkerPoolTask::Vector* dependencies, |
85 : internal::RasterWorkerPoolTask(resource, | 85 ContextProvider* context_provider) |
86 dependencies, | 86 : internal::RasterWorkerPoolTask(resource, dependencies), |
87 use_gpu_rasterization), | |
88 picture_pile_(picture_pile), | 87 picture_pile_(picture_pile), |
89 content_rect_(content_rect), | 88 content_rect_(content_rect), |
90 contents_scale_(contents_scale), | 89 contents_scale_(contents_scale), |
91 raster_mode_(raster_mode), | 90 raster_mode_(raster_mode), |
92 tile_resolution_(tile_resolution), | 91 tile_resolution_(tile_resolution), |
93 layer_id_(layer_id), | 92 layer_id_(layer_id), |
94 tile_id_(tile_id), | 93 tile_id_(tile_id), |
95 source_frame_number_(source_frame_number), | 94 source_frame_number_(source_frame_number), |
96 rendering_stats_(rendering_stats), | 95 rendering_stats_(rendering_stats), |
97 reply_(reply), | 96 reply_(reply), |
| 97 context_provider_(context_provider), |
98 canvas_(NULL) {} | 98 canvas_(NULL) {} |
99 | 99 |
100 void RunAnalysisOnThread(unsigned thread_index) { | 100 void RunAnalysisOnThread(unsigned thread_index) { |
101 TRACE_EVENT1("cc", | 101 TRACE_EVENT1("cc", |
102 "RasterWorkerPoolTaskImpl::RunAnalysisOnThread", | 102 "RasterWorkerPoolTaskImpl::RunAnalysisOnThread", |
103 "data", | 103 "data", |
104 TracedValue::FromValue(DataAsValue().release())); | 104 TracedValue::FromValue(DataAsValue().release())); |
105 | 105 |
106 DCHECK(picture_pile_.get()); | 106 DCHECK(picture_pile_.get()); |
107 DCHECK(rendering_stats_); | 107 DCHECK(rendering_stats_); |
(...skipping 25 matching lines...) Expand all Loading... |
133 | 133 |
134 devtools_instrumentation::ScopedLayerTask raster_task( | 134 devtools_instrumentation::ScopedLayerTask raster_task( |
135 devtools_instrumentation::kRasterTask, layer_id_); | 135 devtools_instrumentation::kRasterTask, layer_id_); |
136 | 136 |
137 DCHECK(picture_pile_.get()); | 137 DCHECK(picture_pile_.get()); |
138 Raster(picture_pile_->GetCloneForDrawingOnThread(thread_index)); | 138 Raster(picture_pile_->GetCloneForDrawingOnThread(thread_index)); |
139 } | 139 } |
140 | 140 |
141 // Overridden from internal::Task: | 141 // Overridden from internal::Task: |
142 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { | 142 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { |
143 // TODO(alokp): For now run-on-worker-thread implies software rasterization. | |
144 DCHECK(!use_gpu_rasterization()); | |
145 RunAnalysisOnThread(thread_index); | 143 RunAnalysisOnThread(thread_index); |
146 if (canvas_ && !analysis_.is_solid_color) | 144 if (canvas_ && !analysis_.is_solid_color) |
147 RunRasterOnThread(thread_index); | 145 RunRasterOnThread(thread_index); |
148 } | 146 } |
149 | 147 |
150 // Overridden from internal::WorkerPoolTask: | 148 // Overridden from internal::WorkerPoolTask: |
151 virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client) | 149 virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client) |
152 OVERRIDE { | 150 OVERRIDE { |
153 DCHECK(!canvas_); | 151 DCHECK(!canvas_); |
154 canvas_ = client->AcquireCanvasForRaster(this); | 152 canvas_ = client->AcquireCanvasForRaster(this); |
155 } | 153 } |
| 154 virtual void RunOnOriginThread() OVERRIDE { |
| 155 // TODO(alokp): Use a trace macro to push/pop markers. |
| 156 // Using push/pop functions directly incurs cost to evaluate function |
| 157 // arguments even when tracing is disabled. |
| 158 DCHECK(context_provider_); |
| 159 context_provider_->ContextGL()->PushGroupMarkerEXT( |
| 160 0, |
| 161 base::StringPrintf( |
| 162 "Raster-%d-%d-%p", source_frame_number_, layer_id_, tile_id_) |
| 163 .c_str()); |
| 164 if (canvas_) |
| 165 Raster(picture_pile_); |
| 166 context_provider_->ContextGL()->PopGroupMarkerEXT(); |
| 167 } |
156 virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client) | 168 virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client) |
157 OVERRIDE { | 169 OVERRIDE { |
158 canvas_ = NULL; | 170 canvas_ = NULL; |
159 client->OnRasterCompleted(this, analysis_); | 171 client->OnRasterCompleted(this, analysis_); |
160 } | 172 } |
161 virtual void RunReplyOnOriginThread() OVERRIDE { | 173 virtual void RunReplyOnOriginThread() OVERRIDE { |
162 DCHECK(!canvas_); | 174 DCHECK(!canvas_); |
163 reply_.Run(analysis_, !HasFinishedRunning()); | 175 reply_.Run(analysis_, !HasFinishedRunning()); |
164 } | 176 } |
165 | 177 |
166 // Overridden from internal::RasterWorkerPoolTask: | |
167 virtual void RunOnOriginThread(ResourceProvider* resource_provider, | |
168 ContextProvider* context_provider) OVERRIDE { | |
169 // TODO(alokp): Use a trace macro to push/pop markers. | |
170 // Using push/pop functions directly incurs cost to evaluate function | |
171 // arguments even when tracing is disabled. | |
172 context_provider->ContextGL()->PushGroupMarkerEXT( | |
173 0, | |
174 base::StringPrintf( | |
175 "Raster-%d-%d-%p", source_frame_number_, layer_id_, tile_id_) | |
176 .c_str()); | |
177 // TODO(alokp): For now run-on-origin-thread implies gpu rasterization. | |
178 DCHECK(use_gpu_rasterization()); | |
179 Raster(picture_pile_); | |
180 context_provider->ContextGL()->PopGroupMarkerEXT(); | |
181 } | |
182 | |
183 protected: | 178 protected: |
184 virtual ~RasterWorkerPoolTaskImpl() { DCHECK(!canvas_); } | 179 virtual ~RasterWorkerPoolTaskImpl() { DCHECK(!canvas_); } |
185 | 180 |
186 private: | 181 private: |
187 scoped_ptr<base::Value> DataAsValue() const { | 182 scoped_ptr<base::Value> DataAsValue() const { |
188 scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue()); | 183 scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue()); |
189 res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release()); | 184 res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release()); |
190 res->Set("resolution", TileResolutionAsValue(tile_resolution_).release()); | 185 res->Set("resolution", TileResolutionAsValue(tile_resolution_).release()); |
191 res->SetInteger("source_frame_number", source_frame_number_); | 186 res->SetInteger("source_frame_number", source_frame_number_); |
192 res->SetInteger("layer_id", layer_id_); | 187 res->SetInteger("layer_id", layer_id_); |
(...skipping 19 matching lines...) Expand all Loading... |
212 | 207 |
213 base::TimeDelta prev_rasterize_time = | 208 base::TimeDelta prev_rasterize_time = |
214 rendering_stats_->impl_thread_rendering_stats().rasterize_time; | 209 rendering_stats_->impl_thread_rendering_stats().rasterize_time; |
215 | 210 |
216 // Only record rasterization time for highres tiles, because | 211 // Only record rasterization time for highres tiles, because |
217 // lowres tiles are not required for activation and therefore | 212 // lowres tiles are not required for activation and therefore |
218 // introduce noise in the measurement (sometimes they get rasterized | 213 // introduce noise in the measurement (sometimes they get rasterized |
219 // before we draw and sometimes they aren't) | 214 // before we draw and sometimes they aren't) |
220 RenderingStatsInstrumentation* stats = | 215 RenderingStatsInstrumentation* stats = |
221 tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL; | 216 tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL; |
| 217 DCHECK(picture_pile); |
222 picture_pile->RasterToBitmap( | 218 picture_pile->RasterToBitmap( |
223 canvas_, content_rect_, contents_scale_, stats); | 219 canvas_, content_rect_, contents_scale_, stats); |
224 | 220 |
225 if (rendering_stats_->record_rendering_stats()) { | 221 if (rendering_stats_->record_rendering_stats()) { |
226 base::TimeDelta current_rasterize_time = | 222 base::TimeDelta current_rasterize_time = |
227 rendering_stats_->impl_thread_rendering_stats().rasterize_time; | 223 rendering_stats_->impl_thread_rendering_stats().rasterize_time; |
228 HISTOGRAM_CUSTOM_COUNTS( | 224 HISTOGRAM_CUSTOM_COUNTS( |
229 "Renderer4.PictureRasterTimeUS", | 225 "Renderer4.PictureRasterTimeUS", |
230 (current_rasterize_time - prev_rasterize_time).InMicroseconds(), | 226 (current_rasterize_time - prev_rasterize_time).InMicroseconds(), |
231 0, | 227 0, |
232 100000, | 228 100000, |
233 100); | 229 100); |
234 } | 230 } |
235 } | 231 } |
236 | 232 |
237 PicturePileImpl::Analysis analysis_; | 233 PicturePileImpl::Analysis analysis_; |
238 scoped_refptr<PicturePileImpl> picture_pile_; | 234 scoped_refptr<PicturePileImpl> picture_pile_; |
239 gfx::Rect content_rect_; | 235 gfx::Rect content_rect_; |
240 float contents_scale_; | 236 float contents_scale_; |
241 RasterMode raster_mode_; | 237 RasterMode raster_mode_; |
242 TileResolution tile_resolution_; | 238 TileResolution tile_resolution_; |
243 int layer_id_; | 239 int layer_id_; |
244 const void* tile_id_; | 240 const void* tile_id_; |
245 int source_frame_number_; | 241 int source_frame_number_; |
246 RenderingStatsInstrumentation* rendering_stats_; | 242 RenderingStatsInstrumentation* rendering_stats_; |
247 const RasterWorkerPool::RasterTask::Reply reply_; | 243 const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_; |
| 244 ContextProvider* context_provider_; |
248 SkCanvas* canvas_; | 245 SkCanvas* canvas_; |
249 | 246 |
250 DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl); | 247 DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl); |
251 }; | 248 }; |
252 | 249 |
253 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask { | 250 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask { |
254 public: | 251 public: |
255 ImageDecodeWorkerPoolTaskImpl(SkPixelRef* pixel_ref, | 252 ImageDecodeWorkerPoolTaskImpl( |
256 int layer_id, | 253 SkPixelRef* pixel_ref, |
257 RenderingStatsInstrumentation* rendering_stats, | 254 int layer_id, |
258 const RasterWorkerPool::Task::Reply& reply) | 255 RenderingStatsInstrumentation* rendering_stats, |
| 256 const base::Callback<void(bool was_canceled)>& reply) |
259 : pixel_ref_(skia::SharePtr(pixel_ref)), | 257 : pixel_ref_(skia::SharePtr(pixel_ref)), |
260 layer_id_(layer_id), | 258 layer_id_(layer_id), |
261 rendering_stats_(rendering_stats), | 259 rendering_stats_(rendering_stats), |
262 reply_(reply) {} | 260 reply_(reply) {} |
263 | 261 |
264 // Overridden from internal::Task: | 262 // Overridden from internal::Task: |
265 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { | 263 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { |
266 TRACE_EVENT0("cc", "ImageDecodeWorkerPoolTaskImpl::RunOnWorkerThread"); | 264 TRACE_EVENT0("cc", "ImageDecodeWorkerPoolTaskImpl::RunOnWorkerThread"); |
267 devtools_instrumentation::ScopedImageDecodeTask image_decode_task( | 265 devtools_instrumentation::ScopedImageDecodeTask image_decode_task( |
268 pixel_ref_.get()); | 266 pixel_ref_.get()); |
269 // This will cause the image referred to by pixel ref to be decoded. | 267 // This will cause the image referred to by pixel ref to be decoded. |
270 pixel_ref_->lockPixels(); | 268 pixel_ref_->lockPixels(); |
271 pixel_ref_->unlockPixels(); | 269 pixel_ref_->unlockPixels(); |
272 } | 270 } |
273 | 271 |
274 // Overridden from internal::WorkerPoolTask: | 272 // Overridden from internal::WorkerPoolTask: |
275 virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client) | 273 virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client) |
276 OVERRIDE {} | 274 OVERRIDE {} |
| 275 virtual void RunOnOriginThread() OVERRIDE {} |
277 virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client) | 276 virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client) |
278 OVERRIDE { | 277 OVERRIDE { |
279 client->OnImageDecodeCompleted(this); | 278 client->OnImageDecodeCompleted(this); |
280 } | 279 } |
281 virtual void RunReplyOnOriginThread() OVERRIDE { | 280 virtual void RunReplyOnOriginThread() OVERRIDE { |
282 reply_.Run(!HasFinishedRunning()); | 281 reply_.Run(!HasFinishedRunning()); |
283 } | 282 } |
284 | 283 |
285 protected: | 284 protected: |
286 virtual ~ImageDecodeWorkerPoolTaskImpl() {} | 285 virtual ~ImageDecodeWorkerPoolTaskImpl() {} |
287 | 286 |
288 private: | 287 private: |
289 skia::RefPtr<SkPixelRef> pixel_ref_; | 288 skia::RefPtr<SkPixelRef> pixel_ref_; |
290 int layer_id_; | 289 int layer_id_; |
291 RenderingStatsInstrumentation* rendering_stats_; | 290 RenderingStatsInstrumentation* rendering_stats_; |
292 const RasterWorkerPool::Task::Reply reply_; | 291 const base::Callback<void(bool was_canceled)>& reply_; |
293 | 292 |
294 DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl); | 293 DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl); |
295 }; | 294 }; |
296 | 295 |
297 class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask { | 296 class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask { |
298 public: | 297 public: |
299 typedef base::Callback<void(const internal::WorkerPoolTask* source)> Callback; | 298 typedef base::Callback<void(const internal::WorkerPoolTask* source)> Callback; |
300 | 299 |
301 explicit RasterFinishedWorkerPoolTaskImpl( | 300 explicit RasterFinishedWorkerPoolTaskImpl( |
302 const Callback& on_raster_finished_callback) | 301 const Callback& on_raster_finished_callback) |
303 : origin_loop_(base::MessageLoopProxy::current().get()), | 302 : origin_loop_(base::MessageLoopProxy::current().get()), |
304 on_raster_finished_callback_(on_raster_finished_callback) {} | 303 on_raster_finished_callback_(on_raster_finished_callback) {} |
305 | 304 |
306 // Overridden from internal::Task: | 305 // Overridden from internal::Task: |
307 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { | 306 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { |
308 TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread"); | 307 TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread"); |
309 origin_loop_->PostTask( | 308 origin_loop_->PostTask( |
310 FROM_HERE, | 309 FROM_HERE, |
311 base::Bind(&RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread, this)); | 310 base::Bind( |
| 311 &RasterFinishedWorkerPoolTaskImpl::OnRasterFinishedOnOriginThread, |
| 312 this)); |
312 } | 313 } |
313 | 314 |
314 // Overridden from internal::WorkerPoolTask: | 315 // Overridden from internal::WorkerPoolTask: |
315 virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client) | 316 virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client) |
316 OVERRIDE {} | 317 OVERRIDE {} |
| 318 virtual void RunOnOriginThread() OVERRIDE { |
| 319 origin_loop_->PostTask( |
| 320 FROM_HERE, |
| 321 base::Bind( |
| 322 &RasterFinishedWorkerPoolTaskImpl::OnRasterFinishedOnOriginThread, |
| 323 this)); |
| 324 } |
317 virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client) | 325 virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client) |
318 OVERRIDE {} | 326 OVERRIDE {} |
319 virtual void RunReplyOnOriginThread() OVERRIDE {} | 327 virtual void RunReplyOnOriginThread() OVERRIDE {} |
320 | 328 |
321 protected: | 329 protected: |
322 virtual ~RasterFinishedWorkerPoolTaskImpl() {} | 330 virtual ~RasterFinishedWorkerPoolTaskImpl() {} |
323 | 331 |
324 private: | 332 private: |
325 void RunOnOriginThread() const { on_raster_finished_callback_.Run(this); } | 333 void OnRasterFinishedOnOriginThread() const { |
| 334 on_raster_finished_callback_.Run(this); |
| 335 } |
326 | 336 |
327 scoped_refptr<base::MessageLoopProxy> origin_loop_; | 337 scoped_refptr<base::MessageLoopProxy> origin_loop_; |
328 const Callback on_raster_finished_callback_; | 338 const Callback on_raster_finished_callback_; |
329 | 339 |
330 DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl); | 340 DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl); |
331 }; | 341 }; |
332 | 342 |
333 class RasterRequiredForActivationFinishedWorkerPoolTaskImpl | 343 class RasterRequiredForActivationFinishedWorkerPoolTaskImpl |
334 : public RasterFinishedWorkerPoolTaskImpl { | 344 : public RasterFinishedWorkerPoolTaskImpl { |
335 public: | 345 public: |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
404 | 414 |
405 void WorkerPoolTask::DidComplete() { | 415 void WorkerPoolTask::DidComplete() { |
406 DCHECK(did_schedule_); | 416 DCHECK(did_schedule_); |
407 DCHECK(!did_complete_); | 417 DCHECK(!did_complete_); |
408 did_schedule_ = false; | 418 did_schedule_ = false; |
409 did_complete_ = true; | 419 did_complete_ = true; |
410 } | 420 } |
411 | 421 |
412 bool WorkerPoolTask::HasCompleted() const { return did_complete_; } | 422 bool WorkerPoolTask::HasCompleted() const { return did_complete_; } |
413 | 423 |
414 RasterWorkerPoolTask::RasterWorkerPoolTask(const Resource* resource, | 424 RasterWorkerPoolTask::RasterWorkerPoolTask( |
415 internal::Task::Vector* dependencies, | 425 const Resource* resource, |
416 bool use_gpu_rasterization) | 426 internal::WorkerPoolTask::Vector* dependencies) |
417 : resource_(resource), use_gpu_rasterization_(use_gpu_rasterization) { | 427 : resource_(resource) { |
418 dependencies_.swap(*dependencies); | 428 dependencies_.swap(*dependencies); |
419 } | 429 } |
420 | 430 |
421 RasterWorkerPoolTask::~RasterWorkerPoolTask() {} | 431 RasterWorkerPoolTask::~RasterWorkerPoolTask() {} |
422 | 432 |
423 } // namespace internal | 433 } // namespace internal |
424 | 434 |
425 RasterWorkerPool::Task::Set::Set() {} | 435 RasterTaskQueue::Task::Task(internal::RasterWorkerPoolTask* task, |
| 436 bool required_for_activation) |
| 437 : task(task), required_for_activation(required_for_activation) {} |
426 | 438 |
427 RasterWorkerPool::Task::Set::~Set() {} | 439 RasterTaskQueue::Task::~Task() {} |
428 | 440 |
429 void RasterWorkerPool::Task::Set::Insert(const Task& task) { | 441 RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {} |
430 DCHECK(!task.is_null()); | 442 |
431 tasks_.push_back(task.internal_); | 443 RasterTaskQueue::~RasterTaskQueue() {} |
| 444 |
| 445 void RasterTaskQueue::Swap(RasterTaskQueue* other) { |
| 446 tasks.swap(other->tasks); |
| 447 std::swap(required_for_activation_count, |
| 448 other->required_for_activation_count); |
432 } | 449 } |
433 | 450 |
434 RasterWorkerPool::Task::Task() {} | 451 void RasterTaskQueue::Reset() { |
435 | 452 required_for_activation_count = 0u; |
436 RasterWorkerPool::Task::Task(internal::WorkerPoolTask* internal) | 453 tasks.clear(); |
437 : internal_(internal) {} | |
438 | |
439 RasterWorkerPool::Task::~Task() {} | |
440 | |
441 void RasterWorkerPool::Task::Reset() { internal_ = NULL; } | |
442 | |
443 RasterWorkerPool::RasterTask::Queue::QueuedTask::QueuedTask( | |
444 internal::RasterWorkerPoolTask* task, | |
445 bool required_for_activation) | |
446 : task(task), required_for_activation(required_for_activation) {} | |
447 | |
448 RasterWorkerPool::RasterTask::Queue::QueuedTask::~QueuedTask() {} | |
449 | |
450 RasterWorkerPool::RasterTask::Queue::Queue() | |
451 : required_for_activation_count_(0u) {} | |
452 | |
453 RasterWorkerPool::RasterTask::Queue::~Queue() {} | |
454 | |
455 void RasterWorkerPool::RasterTask::Queue::Reset() { | |
456 tasks_.clear(); | |
457 required_for_activation_count_ = 0u; | |
458 } | 454 } |
459 | 455 |
460 void RasterWorkerPool::RasterTask::Queue::Append(const RasterTask& task, | |
461 bool required_for_activation) { | |
462 DCHECK(!task.is_null()); | |
463 tasks_.push_back(QueuedTask(task.internal_, required_for_activation)); | |
464 required_for_activation_count_ += required_for_activation; | |
465 } | |
466 | |
467 void RasterWorkerPool::RasterTask::Queue::Swap(Queue* other) { | |
468 tasks_.swap(other->tasks_); | |
469 std::swap(required_for_activation_count_, | |
470 other->required_for_activation_count_); | |
471 } | |
472 | |
473 RasterWorkerPool::RasterTask::RasterTask() {} | |
474 | |
475 RasterWorkerPool::RasterTask::RasterTask( | |
476 internal::RasterWorkerPoolTask* internal) | |
477 : internal_(internal) {} | |
478 | |
479 void RasterWorkerPool::RasterTask::Reset() { internal_ = NULL; } | |
480 | |
481 RasterWorkerPool::RasterTask::~RasterTask() {} | |
482 | |
483 // This allows an external rasterize on-demand system to run raster tasks | 456 // This allows an external rasterize on-demand system to run raster tasks |
484 // with highest priority using the same task graph runner instance. | 457 // with highest priority using the same task graph runner instance. |
485 unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u; | 458 unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u; |
486 // Task priorities that make sure raster finished tasks run before any | 459 // Task priorities that make sure raster finished tasks run before any |
487 // remaining raster tasks. | 460 // remaining raster tasks. |
488 unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u; | 461 unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u; |
489 unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority = | 462 unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority = |
490 1u; | 463 1u; |
491 unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u; | 464 unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u; |
492 | 465 |
493 RasterWorkerPool::RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner, | 466 RasterWorkerPool::RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner, |
494 ResourceProvider* resource_provider, | 467 ResourceProvider* resource_provider) |
495 ContextProvider* context_provider) | |
496 : task_graph_runner_(task_graph_runner), | 468 : task_graph_runner_(task_graph_runner), |
497 namespace_token_(task_graph_runner_->GetNamespaceToken()), | |
498 client_(NULL), | 469 client_(NULL), |
499 resource_provider_(resource_provider), | 470 resource_provider_(resource_provider), |
500 context_provider_(context_provider), | 471 weak_ptr_factory_(this) { |
501 weak_ptr_factory_(this) {} | 472 if (task_graph_runner_) |
| 473 namespace_token_ = task_graph_runner_->GetNamespaceToken(); |
| 474 } |
502 | 475 |
503 RasterWorkerPool::~RasterWorkerPool() {} | 476 RasterWorkerPool::~RasterWorkerPool() {} |
504 | 477 |
505 // static | 478 // static |
506 void RasterWorkerPool::SetNumRasterThreads(int num_threads) { | 479 void RasterWorkerPool::SetNumRasterThreads(int num_threads) { |
507 DCHECK_LT(0, num_threads); | 480 DCHECK_LT(0, num_threads); |
508 DCHECK_EQ(0, g_num_raster_threads); | 481 DCHECK_EQ(0, g_num_raster_threads); |
509 | 482 |
510 g_num_raster_threads = num_threads; | 483 g_num_raster_threads = num_threads; |
511 } | 484 } |
512 | 485 |
513 // static | 486 // static |
514 int RasterWorkerPool::GetNumRasterThreads() { | 487 int RasterWorkerPool::GetNumRasterThreads() { |
515 if (!g_num_raster_threads) | 488 if (!g_num_raster_threads) |
516 g_num_raster_threads = kDefaultNumRasterThreads; | 489 g_num_raster_threads = kDefaultNumRasterThreads; |
517 | 490 |
518 return g_num_raster_threads; | 491 return g_num_raster_threads; |
519 } | 492 } |
520 | 493 |
521 // static | 494 // static |
522 internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() { | 495 internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() { |
523 return g_task_graph_runner.Pointer(); | 496 return g_task_graph_runner.Pointer(); |
524 } | 497 } |
525 | 498 |
526 // static | 499 // static |
527 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask( | 500 scoped_refptr<internal::RasterWorkerPoolTask> |
| 501 RasterWorkerPool::CreateRasterTask( |
528 const Resource* resource, | 502 const Resource* resource, |
529 PicturePileImpl* picture_pile, | 503 PicturePileImpl* picture_pile, |
530 const gfx::Rect& content_rect, | 504 const gfx::Rect& content_rect, |
531 float contents_scale, | 505 float contents_scale, |
532 RasterMode raster_mode, | 506 RasterMode raster_mode, |
533 TileResolution tile_resolution, | 507 TileResolution tile_resolution, |
534 int layer_id, | 508 int layer_id, |
535 const void* tile_id, | 509 const void* tile_id, |
536 int source_frame_number, | 510 int source_frame_number, |
537 bool use_gpu_rasterization, | |
538 RenderingStatsInstrumentation* rendering_stats, | 511 RenderingStatsInstrumentation* rendering_stats, |
539 const RasterTask::Reply& reply, | 512 const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply, |
540 Task::Set* dependencies) { | 513 internal::WorkerPoolTask::Vector* dependencies, |
541 return RasterTask(new RasterWorkerPoolTaskImpl(resource, | 514 ContextProvider* context_provider) { |
542 picture_pile, | 515 return make_scoped_refptr(new RasterWorkerPoolTaskImpl(resource, |
543 content_rect, | 516 picture_pile, |
544 contents_scale, | 517 content_rect, |
545 raster_mode, | 518 contents_scale, |
546 tile_resolution, | 519 raster_mode, |
547 layer_id, | 520 tile_resolution, |
548 tile_id, | 521 layer_id, |
549 source_frame_number, | 522 tile_id, |
550 use_gpu_rasterization, | 523 source_frame_number, |
551 rendering_stats, | 524 rendering_stats, |
552 reply, | 525 reply, |
553 &dependencies->tasks_)); | 526 dependencies, |
| 527 context_provider)); |
554 } | 528 } |
555 | 529 |
556 // static | 530 // static |
557 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask( | 531 scoped_refptr<internal::WorkerPoolTask> RasterWorkerPool::CreateImageDecodeTask( |
558 SkPixelRef* pixel_ref, | 532 SkPixelRef* pixel_ref, |
559 int layer_id, | 533 int layer_id, |
560 RenderingStatsInstrumentation* rendering_stats, | 534 RenderingStatsInstrumentation* rendering_stats, |
561 const Task::Reply& reply) { | 535 const base::Callback<void(bool was_canceled)>& reply) { |
562 return Task(new ImageDecodeWorkerPoolTaskImpl( | 536 return make_scoped_refptr(new ImageDecodeWorkerPoolTaskImpl( |
563 pixel_ref, layer_id, rendering_stats, reply)); | 537 pixel_ref, layer_id, rendering_stats, reply)); |
564 } | 538 } |
565 | 539 |
566 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) { | 540 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) { |
567 client_ = client; | 541 client_ = client; |
568 } | 542 } |
569 | 543 |
570 void RasterWorkerPool::Shutdown() { | 544 void RasterWorkerPool::Shutdown() { |
571 TRACE_EVENT0("cc", "RasterWorkerPool::Shutdown"); | 545 TRACE_EVENT0("cc", "RasterWorkerPool::Shutdown"); |
572 | 546 |
573 internal::TaskGraph empty; | 547 if (task_graph_runner_) { |
574 SetTaskGraph(&empty); | 548 internal::TaskGraph empty; |
575 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | 549 task_graph_runner_->SetTaskGraph(namespace_token_, &empty); |
| 550 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); |
| 551 } |
| 552 |
576 weak_ptr_factory_.InvalidateWeakPtrs(); | 553 weak_ptr_factory_.InvalidateWeakPtrs(); |
577 } | 554 } |
578 | 555 |
579 void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) { | 556 void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) { |
580 TRACE_EVENT0("cc", "RasterWorkerPool::SetTaskGraph"); | 557 TRACE_EVENT0("cc", "RasterWorkerPool::SetTaskGraph"); |
581 | 558 |
| 559 DCHECK(task_graph_runner_); |
582 for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin(); | 560 for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin(); |
583 it != graph->nodes.end(); | 561 it != graph->nodes.end(); |
584 ++it) { | 562 ++it) { |
585 internal::TaskGraph::Node& node = *it; | 563 internal::TaskGraph::Node& node = *it; |
586 internal::WorkerPoolTask* task = | 564 internal::WorkerPoolTask* task = |
587 static_cast<internal::WorkerPoolTask*>(node.task); | 565 static_cast<internal::WorkerPoolTask*>(node.task); |
588 | 566 |
589 if (!task->HasBeenScheduled()) { | 567 if (!task->HasBeenScheduled()) { |
590 task->WillSchedule(); | 568 task->WillSchedule(); |
591 task->ScheduleOnOriginThread(this); | 569 task->ScheduleOnOriginThread(this); |
592 task->DidSchedule(); | 570 task->DidSchedule(); |
593 } | 571 } |
594 } | 572 } |
595 | 573 |
596 task_graph_runner_->SetTaskGraph(namespace_token_, graph); | 574 task_graph_runner_->SetTaskGraph(namespace_token_, graph); |
597 } | 575 } |
598 | 576 |
599 void RasterWorkerPool::CollectCompletedWorkerPoolTasks( | 577 void RasterWorkerPool::CollectCompletedWorkerPoolTasks( |
600 internal::Task::Vector* completed_tasks) { | 578 internal::Task::Vector* completed_tasks) { |
| 579 DCHECK(task_graph_runner_); |
601 task_graph_runner_->CollectCompletedTasks(namespace_token_, completed_tasks); | 580 task_graph_runner_->CollectCompletedTasks(namespace_token_, completed_tasks); |
602 } | 581 } |
603 | 582 |
604 void RasterWorkerPool::RunGpuRasterTasks(const RasterTaskVector& tasks) { | |
605 DCHECK(!tasks.empty()); | |
606 TRACE_EVENT1( | |
607 "cc", "RasterWorkerPool::RunGpuRasterTasks", "num_tasks", tasks.size()); | |
608 | |
609 GrContext* gr_context = context_provider_->GrContext(); | |
610 // TODO(alokp): Implement TestContextProvider::GrContext(). | |
611 if (gr_context) | |
612 gr_context->resetContext(); | |
613 | |
614 for (RasterTaskVector::const_iterator it = tasks.begin(); it != tasks.end(); | |
615 ++it) { | |
616 internal::RasterWorkerPoolTask* task = it->get(); | |
617 DCHECK(task->use_gpu_rasterization()); | |
618 | |
619 task->WillSchedule(); | |
620 task->ScheduleOnOriginThread(this); | |
621 task->DidSchedule(); | |
622 | |
623 task->WillRun(); | |
624 task->RunOnOriginThread(resource_provider_, context_provider_); | |
625 task->DidRun(); | |
626 | |
627 task->WillComplete(); | |
628 task->CompleteOnOriginThread(this); | |
629 task->DidComplete(); | |
630 | |
631 completed_gpu_raster_tasks_.push_back(task); | |
632 } | |
633 | |
634 // TODO(alokp): Implement TestContextProvider::GrContext(). | |
635 if (gr_context) | |
636 gr_context->flush(); | |
637 } | |
638 | |
639 void RasterWorkerPool::CheckForCompletedGpuRasterTasks() { | |
640 // Complete gpu rasterization tasks. | |
641 while (!completed_gpu_raster_tasks_.empty()) { | |
642 internal::WorkerPoolTask* task = completed_gpu_raster_tasks_.front().get(); | |
643 | |
644 task->RunReplyOnOriginThread(); | |
645 | |
646 completed_gpu_raster_tasks_.pop_front(); | |
647 } | |
648 } | |
649 | |
650 scoped_refptr<internal::WorkerPoolTask> | 583 scoped_refptr<internal::WorkerPoolTask> |
651 RasterWorkerPool::CreateRasterFinishedTask() { | 584 RasterWorkerPool::CreateRasterFinishedTask() { |
652 return make_scoped_refptr(new RasterFinishedWorkerPoolTaskImpl(base::Bind( | 585 return make_scoped_refptr(new RasterFinishedWorkerPoolTaskImpl(base::Bind( |
653 &RasterWorkerPool::OnRasterFinished, weak_ptr_factory_.GetWeakPtr()))); | 586 &RasterWorkerPool::OnRasterFinished, weak_ptr_factory_.GetWeakPtr()))); |
654 } | 587 } |
655 | 588 |
656 scoped_refptr<internal::WorkerPoolTask> | 589 scoped_refptr<internal::WorkerPoolTask> |
657 RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask( | 590 RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask( |
658 size_t tasks_required_for_activation_count) { | 591 size_t tasks_required_for_activation_count) { |
659 return make_scoped_refptr( | 592 return make_scoped_refptr( |
660 new RasterRequiredForActivationFinishedWorkerPoolTaskImpl( | 593 new RasterRequiredForActivationFinishedWorkerPoolTaskImpl( |
661 base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished, | 594 base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished, |
662 weak_ptr_factory_.GetWeakPtr()), | 595 weak_ptr_factory_.GetWeakPtr()), |
663 tasks_required_for_activation_count)); | 596 tasks_required_for_activation_count)); |
664 } | 597 } |
665 | 598 |
| 599 void RasterWorkerPool::RunTaskOnOriginThread(internal::WorkerPoolTask* task) { |
| 600 task->WillSchedule(); |
| 601 task->ScheduleOnOriginThread(this); |
| 602 task->DidSchedule(); |
| 603 |
| 604 task->WillRun(); |
| 605 task->RunOnOriginThread(); |
| 606 task->DidRun(); |
| 607 |
| 608 task->WillComplete(); |
| 609 task->CompleteOnOriginThread(this); |
| 610 task->DidComplete(); |
| 611 } |
| 612 |
666 void RasterWorkerPool::OnRasterFinished( | 613 void RasterWorkerPool::OnRasterFinished( |
667 const internal::WorkerPoolTask* source) { | 614 const internal::WorkerPoolTask* source) { |
668 TRACE_EVENT0("cc", "RasterWorkerPool::OnRasterFinished"); | 615 TRACE_EVENT0("cc", "RasterWorkerPool::OnRasterFinished"); |
669 | 616 |
670 // Early out if current |raster_finished_task_| is not the source. | 617 // Early out if current |raster_finished_task_| is not the source. |
671 if (source != raster_finished_task_.get()) | 618 if (source != raster_finished_task_.get()) |
672 return; | 619 return; |
673 | 620 |
674 OnRasterTasksFinished(); | 621 OnRasterTasksFinished(); |
675 } | 622 } |
(...skipping 20 matching lines...) Expand all Loading... |
696 internal::TaskGraph::Node::TaskComparator(task)) == | 643 internal::TaskGraph::Node::TaskComparator(task)) == |
697 graph->nodes.end()); | 644 graph->nodes.end()); |
698 graph->nodes.push_back( | 645 graph->nodes.push_back( |
699 internal::TaskGraph::Node(task, priority, dependencies)); | 646 internal::TaskGraph::Node(task, priority, dependencies)); |
700 } | 647 } |
701 | 648 |
702 // static | 649 // static |
703 void RasterWorkerPool::InsertNodeForRasterTask( | 650 void RasterWorkerPool::InsertNodeForRasterTask( |
704 internal::TaskGraph* graph, | 651 internal::TaskGraph* graph, |
705 internal::WorkerPoolTask* raster_task, | 652 internal::WorkerPoolTask* raster_task, |
706 const internal::Task::Vector& decode_tasks, | 653 const internal::WorkerPoolTask::Vector& decode_tasks, |
707 unsigned priority) { | 654 unsigned priority) { |
708 size_t dependencies = 0u; | 655 size_t dependencies = 0u; |
709 | 656 |
710 // Insert image decode tasks. | 657 // Insert image decode tasks. |
711 for (internal::Task::Vector::const_iterator it = decode_tasks.begin(); | 658 for (internal::WorkerPoolTask::Vector::const_iterator it = |
| 659 decode_tasks.begin(); |
712 it != decode_tasks.end(); | 660 it != decode_tasks.end(); |
713 ++it) { | 661 ++it) { |
714 internal::WorkerPoolTask* decode_task = | 662 internal::WorkerPoolTask* decode_task = it->get(); |
715 static_cast<internal::WorkerPoolTask*>(it->get()); | |
716 | 663 |
717 // Skip if already decoded. | 664 // Skip if already decoded. |
718 if (decode_task->HasCompleted()) | 665 if (decode_task->HasCompleted()) |
719 continue; | 666 continue; |
720 | 667 |
721 dependencies++; | 668 dependencies++; |
722 | 669 |
723 // Add decode task if it doesn't already exists in graph. | 670 // Add decode task if it doesn't already exists in graph. |
724 internal::TaskGraph::Node::Vector::iterator decode_it = | 671 internal::TaskGraph::Node::Vector::iterator decode_it = |
725 std::find_if(graph->nodes.begin(), | 672 std::find_if(graph->nodes.begin(), |
726 graph->nodes.end(), | 673 graph->nodes.end(), |
727 internal::TaskGraph::Node::TaskComparator(decode_task)); | 674 internal::TaskGraph::Node::TaskComparator(decode_task)); |
728 if (decode_it == graph->nodes.end()) | 675 if (decode_it == graph->nodes.end()) |
729 InsertNodeForTask(graph, decode_task, priority, 0u); | 676 InsertNodeForTask(graph, decode_task, priority, 0u); |
730 | 677 |
731 graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task)); | 678 graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task)); |
732 } | 679 } |
733 | 680 |
734 InsertNodeForTask(graph, raster_task, priority, dependencies); | 681 InsertNodeForTask(graph, raster_task, priority, dependencies); |
735 } | 682 } |
736 | 683 |
737 } // namespace cc | 684 } // namespace cc |
OLD | NEW |