diff options
author | reveman@chromium.org <reveman@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2014-02-19 02:42:04 +0000 |
---|---|---|
committer | reveman@chromium.org <reveman@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2014-02-19 02:42:04 +0000 |
commit | 13b45f1e5895466645be643c86397ee9ca0b9921 (patch) | |
tree | 08b5bc68e0c2760abb46160ceff9f48a5fd19ed9 /cc/resources | |
parent | 5f82572c92520e67a6d1490bbb407211e8fca531 (diff) | |
download | chromium_src-13b45f1e5895466645be643c86397ee9ca0b9921.zip chromium_src-13b45f1e5895466645be643c86397ee9ca0b9921.tar.gz chromium_src-13b45f1e5895466645be643c86397ee9ca0b9921.tar.bz2 |
cc: Remove RasterWorkerPool::Task.
This removes some unnecessary layers of abstraction between
internal::Task and the tile manager. Prerequisite to getting
rid of our large raster task objects and anonymous functions.
BUG=269841
Review URL: https://codereview.chromium.org/168083002
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@251938 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'cc/resources')
-rw-r--r-- | cc/resources/direct_raster_worker_pool.cc | 36 | ||||
-rw-r--r-- | cc/resources/direct_raster_worker_pool.h | 4 | ||||
-rw-r--r-- | cc/resources/image_raster_worker_pool.cc | 23 | ||||
-rw-r--r-- | cc/resources/image_raster_worker_pool.h | 4 | ||||
-rw-r--r-- | cc/resources/managed_tile_state.cc | 2 | ||||
-rw-r--r-- | cc/resources/managed_tile_state.h | 2 | ||||
-rw-r--r-- | cc/resources/pixel_buffer_raster_worker_pool.cc | 36 | ||||
-rw-r--r-- | cc/resources/pixel_buffer_raster_worker_pool.h | 4 | ||||
-rw-r--r-- | cc/resources/raster_worker_pool.cc | 140 | ||||
-rw-r--r-- | cc/resources/raster_worker_pool.h | 161 | ||||
-rw-r--r-- | cc/resources/raster_worker_pool_delegate.cc | 3 | ||||
-rw-r--r-- | cc/resources/raster_worker_pool_delegate.h | 2 | ||||
-rw-r--r-- | cc/resources/raster_worker_pool_perftest.cc | 86 | ||||
-rw-r--r-- | cc/resources/raster_worker_pool_unittest.cc | 59 | ||||
-rw-r--r-- | cc/resources/tile_manager.cc | 35 | ||||
-rw-r--r-- | cc/resources/tile_manager.h | 13 |
16 files changed, 234 insertions, 376 deletions
diff --git a/cc/resources/direct_raster_worker_pool.cc b/cc/resources/direct_raster_worker_pool.cc index 9bad9a5..9473208 100644 --- a/cc/resources/direct_raster_worker_pool.cc +++ b/cc/resources/direct_raster_worker_pool.cc @@ -34,16 +34,22 @@ DirectRasterWorkerPool::~DirectRasterWorkerPool() { DCHECK_EQ(0u, completed_tasks_.size()); } -void DirectRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { +void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks"); + DCHECK_EQ(queue->required_for_activation_count, + static_cast<size_t>( + std::count_if(queue->items.begin(), + queue->items.end(), + RasterTaskQueue::Item::IsRequiredForActivation))); + raster_tasks_pending_ = true; raster_tasks_required_for_activation_pending_ = true; scoped_refptr<internal::WorkerPoolTask> new_raster_required_for_activation_finished_task( CreateRasterRequiredForActivationFinishedTask( - queue->required_for_activation_count())); + queue->required_for_activation_count)); scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task( CreateRasterFinishedTask()); @@ -52,13 +58,16 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { // TODO(reveman): Remove this once only tasks for which // ::ScheduleOnOriginThread has been called need to be canceled. if (run_tasks_on_origin_thread_pending_) { - for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) { - internal::RasterWorkerPoolTask* task = *it; - - if (std::find_if(queue->tasks_.begin(), - queue->tasks_.end(), - RasterTask::Queue::QueuedTask::TaskComparator(task)) == - queue->tasks_.end()) + for (RasterTaskQueue::Item::Vector::const_iterator it = + raster_tasks_.items.begin(); + it != raster_tasks_.items.end(); + ++it) { + internal::RasterWorkerPoolTask* task = it->task; + + if (std::find_if(queue->items.begin(), + queue->items.end(), + RasterTaskQueue::Item::TaskComparator(task)) == + queue->items.end()) completed_tasks_.push_back(task); } } @@ -132,14 +141,17 @@ void DirectRasterWorkerPool::RunTasksOnOriginThread() { DCHECK(run_tasks_on_origin_thread_pending_); run_tasks_on_origin_thread_pending_ = false; - if (!raster_tasks_.tasks_.empty()) { + if (!raster_tasks_.items.empty()) { GrContext* gr_context = context_provider_->GrContext(); // TODO(alokp): Implement TestContextProvider::GrContext(). if (gr_context) gr_context->resetContext(); - for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) { - internal::RasterWorkerPoolTask* task = *it; + for (RasterTaskQueue::Item::Vector::const_iterator it = + raster_tasks_.items.begin(); + it != raster_tasks_.items.end(); + ++it) { + internal::RasterWorkerPoolTask* task = it->task; DCHECK(!task->HasCompleted()); // First need to run all dependencies. diff --git a/cc/resources/direct_raster_worker_pool.h b/cc/resources/direct_raster_worker_pool.h index 4062218..ac53f2c 100644 --- a/cc/resources/direct_raster_worker_pool.h +++ b/cc/resources/direct_raster_worker_pool.h @@ -18,7 +18,7 @@ class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool { ContextProvider* context_provider); // Overridden from RasterWorkerPool: - virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE; + virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE; virtual unsigned GetResourceTarget() const OVERRIDE; virtual ResourceFormat GetResourceFormat() const OVERRIDE; virtual void CheckForCompletedTasks() OVERRIDE; @@ -48,7 +48,7 @@ class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool { bool run_tasks_on_origin_thread_pending_; - RasterTask::Queue raster_tasks_; + RasterTaskQueue raster_tasks_; bool raster_tasks_pending_; bool raster_tasks_required_for_activation_pending_; diff --git a/cc/resources/image_raster_worker_pool.cc b/cc/resources/image_raster_worker_pool.cc index 4f35e81..b50ac02 100644 --- a/cc/resources/image_raster_worker_pool.cc +++ b/cc/resources/image_raster_worker_pool.cc @@ -33,9 +33,15 @@ ImageRasterWorkerPool::ImageRasterWorkerPool( ImageRasterWorkerPool::~ImageRasterWorkerPool() {} -void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { +void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { TRACE_EVENT0("cc", "ImageRasterWorkerPool::ScheduleTasks"); + DCHECK_EQ(queue->required_for_activation_count, + static_cast<size_t>( + std::count_if(queue->items.begin(), + queue->items.end(), + RasterTaskQueue::Item::IsRequiredForActivation))); + if (!raster_tasks_pending_) TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); @@ -49,15 +55,18 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { scoped_refptr<internal::WorkerPoolTask> new_raster_required_for_activation_finished_task( CreateRasterRequiredForActivationFinishedTask( - queue->required_for_activation_count())); + queue->required_for_activation_count)); scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task( CreateRasterFinishedTask()); - for (RasterTaskQueueIterator it(queue); it; ++it) { - internal::RasterWorkerPoolTask* task = *it; + for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); + it != queue->items.end(); + ++it) { + const RasterTaskQueue::Item& item = *it; + internal::RasterWorkerPoolTask* task = item.task; DCHECK(!task->HasCompleted()); - if (it.required_for_activation()) { + if (item.required_for_activation) { graph_.edges.push_back(internal::TaskGraph::Edge( task, new_raster_required_for_activation_finished_task.get())); } @@ -71,11 +80,11 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { InsertNodeForTask(&graph_, new_raster_required_for_activation_finished_task.get(), kRasterRequiredForActivationFinishedTaskPriority, - queue->required_for_activation_count()); + queue->required_for_activation_count); InsertNodeForTask(&graph_, new_raster_finished_task.get(), kRasterFinishedTaskPriority, - queue->count()); + queue->items.size()); raster_tasks_.Swap(queue); diff --git a/cc/resources/image_raster_worker_pool.h b/cc/resources/image_raster_worker_pool.h index 8bd3c517..a4f55c5 100644 --- a/cc/resources/image_raster_worker_pool.h +++ b/cc/resources/image_raster_worker_pool.h @@ -18,7 +18,7 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool { unsigned texture_target); // Overridden from RasterWorkerPool: - virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE; + virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE; virtual unsigned GetResourceTarget() const OVERRIDE; virtual ResourceFormat GetResourceFormat() const OVERRIDE; virtual void CheckForCompletedTasks() OVERRIDE; @@ -46,7 +46,7 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool { const unsigned texture_target_; - RasterTask::Queue raster_tasks_; + RasterTaskQueue raster_tasks_; bool raster_tasks_pending_; bool raster_tasks_required_for_activation_pending_; diff --git a/cc/resources/managed_tile_state.cc b/cc/resources/managed_tile_state.cc index 383986e..d1bf9ac 100644 --- a/cc/resources/managed_tile_state.cc +++ b/cc/resources/managed_tile_state.cc @@ -84,7 +84,7 @@ scoped_ptr<base::Value> ManagedTileState::AsValue() const { bool has_active_task = false; for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { has_resource |= (tile_versions[mode].resource_.get() != 0); - has_active_task |= !tile_versions[mode].raster_task_.is_null(); + has_active_task |= (tile_versions[mode].raster_task_.get() != 0); } bool is_using_gpu_memory = has_resource || has_active_task; diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h index 2843169..6445623 100644 --- a/cc/resources/managed_tile_state.h +++ b/cc/resources/managed_tile_state.h @@ -95,7 +95,7 @@ class CC_EXPORT ManagedTileState { SkColor solid_color_; bool has_text_; scoped_ptr<ScopedResource> resource_; - RasterWorkerPool::RasterTask raster_task_; + scoped_refptr<internal::RasterWorkerPoolTask> raster_task_; }; ManagedTileState(); diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc index 21ee1cc..b5b9788 100644 --- a/cc/resources/pixel_buffer_raster_worker_pool.cc +++ b/cc/resources/pixel_buffer_raster_worker_pool.cc @@ -88,9 +88,15 @@ void PixelBufferRasterWorkerPool::Shutdown() { DCHECK_EQ(completed_raster_tasks_.size(), raster_task_states_.size()); } -void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { +void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks"); + DCHECK_EQ(queue->required_for_activation_count, + static_cast<size_t>( + std::count_if(queue->items.begin(), + queue->items.end(), + RasterTaskQueue::Item::IsRequiredForActivation))); + if (!should_notify_client_if_no_tasks_are_pending_) TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); @@ -101,8 +107,11 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { // Build new raster task state map. RasterTaskStateMap new_raster_task_states; - for (RasterTaskQueueIterator it(queue); it; ++it) { - internal::RasterWorkerPoolTask* task = *it; + for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); + it != queue->items.end(); + ++it) { + const RasterTaskQueue::Item& item = *it; + internal::RasterWorkerPoolTask* task = item.task; DCHECK(new_raster_task_states.find(task) == new_raster_task_states.end()); RasterTaskStateMap::iterator state_it = raster_task_states_.find(task); @@ -113,14 +122,14 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) { // |raster_tasks_required_for_activation_| contains all tasks that need to // complete before we can send a "ready to activate" signal. Tasks that // have already completed should not be part of this set. - if (state != COMPLETED && it.required_for_activation()) + if (state != COMPLETED && item.required_for_activation) raster_tasks_required_for_activation_.insert(task); raster_task_states_.erase(state_it); } else { DCHECK(!task->HasBeenScheduled()); new_raster_task_states[task] = UNSCHEDULED; - if (it.required_for_activation()) + if (item.required_for_activation) raster_tasks_required_for_activation_.insert(task); } } @@ -242,8 +251,11 @@ void PixelBufferRasterWorkerPool::OnRasterCompleted( // When priorites change, a raster task can be canceled as a result of // no longer being of high enough priority to fit in our throttled // raster task budget. The task has not yet completed in this case. - for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) { - if (*it == task) { + for (RasterTaskQueue::Item::Vector::const_iterator it = + raster_tasks_.items.begin(); + it != raster_tasks_.items.end(); + ++it) { + if (it->task == task) { raster_task_states_[task] = UNSCHEDULED; return; } @@ -498,8 +510,12 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() { size_t bytes_pending_upload = bytes_pending_upload_; bool did_throttle_raster_tasks = false; - for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) { - internal::RasterWorkerPoolTask* task = *it; + for (RasterTaskQueue::Item::Vector::const_iterator it = + raster_tasks_.items.begin(); + it != raster_tasks_.items.end(); + ++it) { + const RasterTaskQueue::Item& item = *it; + internal::RasterWorkerPoolTask* task = item.task; // |raster_task_states_| contains the state of all tasks that we have not // yet run reply callbacks for. @@ -546,7 +562,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() { InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++); tasks.container().push_back(task); - if (it.required_for_activation()) + if (item.required_for_activation) tasks_required_for_activation.container().push_back(task); } diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_raster_worker_pool.h index f90f20e5..d9c7412 100644 --- a/cc/resources/pixel_buffer_raster_worker_pool.h +++ b/cc/resources/pixel_buffer_raster_worker_pool.h @@ -33,7 +33,7 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool { // Overridden from RasterWorkerPool: virtual void Shutdown() OVERRIDE; - virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE; + virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE; virtual unsigned GetResourceTarget() const OVERRIDE; virtual ResourceFormat GetResourceFormat() const OVERRIDE; virtual void CheckForCompletedTasks() OVERRIDE; @@ -82,7 +82,7 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool { bool shutdown_; - RasterTask::Queue raster_tasks_; + RasterTaskQueue raster_tasks_; RasterTaskSet raster_tasks_required_for_activation_; RasterTaskStateMap raster_task_states_; RasterTaskDeque raster_tasks_with_pending_upload_; diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc index 2500588..925cf94 100644 --- a/cc/resources/raster_worker_pool.cc +++ b/cc/resources/raster_worker_pool.cc @@ -69,19 +69,20 @@ class DisableLCDTextFilter : public SkDrawFilter { class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask { public: - RasterWorkerPoolTaskImpl(const Resource* resource, - PicturePileImpl* picture_pile, - const gfx::Rect& content_rect, - float contents_scale, - RasterMode raster_mode, - TileResolution tile_resolution, - int layer_id, - const void* tile_id, - int source_frame_number, - RenderingStatsInstrumentation* rendering_stats, - const RasterWorkerPool::RasterTask::Reply& reply, - internal::WorkerPoolTask::Vector* dependencies, - ContextProvider* context_provider) + RasterWorkerPoolTaskImpl( + const Resource* resource, + PicturePileImpl* picture_pile, + const gfx::Rect& content_rect, + float contents_scale, + RasterMode raster_mode, + TileResolution tile_resolution, + int layer_id, + const void* tile_id, + int source_frame_number, + RenderingStatsInstrumentation* rendering_stats, + const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply, + internal::WorkerPoolTask::Vector* dependencies, + ContextProvider* context_provider) : internal::RasterWorkerPoolTask(resource, dependencies), picture_pile_(picture_pile), content_rect_(content_rect), @@ -236,7 +237,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask { const void* tile_id_; int source_frame_number_; RenderingStatsInstrumentation* rendering_stats_; - const RasterWorkerPool::RasterTask::Reply reply_; + const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_; ContextProvider* context_provider_; SkCanvas* canvas_; @@ -245,10 +246,11 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask { class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask { public: - ImageDecodeWorkerPoolTaskImpl(SkPixelRef* pixel_ref, - int layer_id, - RenderingStatsInstrumentation* rendering_stats, - const RasterWorkerPool::Task::Reply& reply) + ImageDecodeWorkerPoolTaskImpl( + SkPixelRef* pixel_ref, + int layer_id, + RenderingStatsInstrumentation* rendering_stats, + const base::Callback<void(bool was_canceled)>& reply) : pixel_ref_(skia::SharePtr(pixel_ref)), layer_id_(layer_id), rendering_stats_(rendering_stats), @@ -290,7 +292,7 @@ class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask { skia::RefPtr<SkPixelRef> pixel_ref_; int layer_id_; RenderingStatsInstrumentation* rendering_stats_; - const RasterWorkerPool::Task::Reply reply_; + const base::Callback<void(bool was_canceled)>& reply_; DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl); }; @@ -447,64 +449,27 @@ RasterWorkerPoolTask::~RasterWorkerPoolTask() {} } // namespace internal -RasterWorkerPool::Task::Set::Set() {} - -RasterWorkerPool::Task::Set::~Set() {} - -void RasterWorkerPool::Task::Set::Insert(const Task& task) { - DCHECK(!task.is_null()); - tasks_.push_back(task.internal_); -} - -RasterWorkerPool::Task::Task() {} - -RasterWorkerPool::Task::Task(internal::WorkerPoolTask* internal) - : internal_(internal) {} - -RasterWorkerPool::Task::~Task() {} - -void RasterWorkerPool::Task::Reset() { internal_ = NULL; } - -RasterWorkerPool::RasterTask::Queue::QueuedTask::QueuedTask( - internal::RasterWorkerPoolTask* task, - bool required_for_activation) +RasterTaskQueue::Item::Item(internal::RasterWorkerPoolTask* task, + bool required_for_activation) : task(task), required_for_activation(required_for_activation) {} -RasterWorkerPool::RasterTask::Queue::QueuedTask::~QueuedTask() {} - -RasterWorkerPool::RasterTask::Queue::Queue() - : required_for_activation_count_(0u) {} +RasterTaskQueue::Item::~Item() {} -RasterWorkerPool::RasterTask::Queue::~Queue() {} +RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {} -void RasterWorkerPool::RasterTask::Queue::Reset() { - tasks_.clear(); - required_for_activation_count_ = 0u; -} +RasterTaskQueue::~RasterTaskQueue() {} -void RasterWorkerPool::RasterTask::Queue::Append(const RasterTask& task, - bool required_for_activation) { - DCHECK(!task.is_null()); - tasks_.push_back(QueuedTask(task.internal_, required_for_activation)); - required_for_activation_count_ += required_for_activation; +void RasterTaskQueue::Swap(RasterTaskQueue* other) { + items.swap(other->items); + std::swap(required_for_activation_count, + other->required_for_activation_count); } -void RasterWorkerPool::RasterTask::Queue::Swap(Queue* other) { - tasks_.swap(other->tasks_); - std::swap(required_for_activation_count_, - other->required_for_activation_count_); +void RasterTaskQueue::Reset() { + required_for_activation_count = 0u; + items.clear(); } -RasterWorkerPool::RasterTask::RasterTask() {} - -RasterWorkerPool::RasterTask::RasterTask( - internal::RasterWorkerPoolTask* internal) - : internal_(internal) {} - -void RasterWorkerPool::RasterTask::Reset() { internal_ = NULL; } - -RasterWorkerPool::RasterTask::~RasterTask() {} - // This allows an external rasterize on-demand system to run raster tasks // with highest priority using the same task graph runner instance. unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u; @@ -549,7 +514,8 @@ internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() { } // static -RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask( +scoped_refptr<internal::RasterWorkerPoolTask> +RasterWorkerPool::CreateRasterTask( const Resource* resource, PicturePileImpl* picture_pile, const gfx::Rect& content_rect, @@ -560,31 +526,31 @@ RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask( const void* tile_id, int source_frame_number, RenderingStatsInstrumentation* rendering_stats, - const RasterTask::Reply& reply, - Task::Set* dependencies, + const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply, + internal::WorkerPoolTask::Vector* dependencies, ContextProvider* context_provider) { - return RasterTask(new RasterWorkerPoolTaskImpl(resource, - picture_pile, - content_rect, - contents_scale, - raster_mode, - tile_resolution, - layer_id, - tile_id, - source_frame_number, - rendering_stats, - reply, - &dependencies->tasks_, - context_provider)); + return make_scoped_refptr(new RasterWorkerPoolTaskImpl(resource, + picture_pile, + content_rect, + contents_scale, + raster_mode, + tile_resolution, + layer_id, + tile_id, + source_frame_number, + rendering_stats, + reply, + dependencies, + context_provider)); } // static -RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask( +scoped_refptr<internal::WorkerPoolTask> RasterWorkerPool::CreateImageDecodeTask( SkPixelRef* pixel_ref, int layer_id, RenderingStatsInstrumentation* rendering_stats, - const Task::Reply& reply) { - return Task(new ImageDecodeWorkerPoolTaskImpl( + const base::Callback<void(bool was_canceled)>& reply) { + return make_scoped_refptr(new ImageDecodeWorkerPoolTaskImpl( pixel_ref, layer_id, rendering_stats, reply)); } diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h index 1be286c..521ea9f 100644 --- a/cc/resources/raster_worker_pool.h +++ b/cc/resources/raster_worker_pool.h @@ -93,111 +93,45 @@ class CC_EXPORT RasterWorkerPoolClient { virtual ~RasterWorkerPoolClient() {} }; -// A worker thread pool that runs raster tasks. -class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient { - public: - class CC_EXPORT Task { - public: - typedef base::Callback<void(bool was_canceled)> Reply; - - class CC_EXPORT Set { +struct CC_EXPORT RasterTaskQueue { + struct CC_EXPORT Item { + class TaskComparator { public: - Set(); - ~Set(); + explicit TaskComparator(const internal::RasterWorkerPoolTask* task) + : task_(task) {} - void Insert(const Task& task); + bool operator()(const Item& item) const { return item.task == task_; } private: - friend class RasterWorkerPool; - - internal::WorkerPoolTask::Vector tasks_; + const internal::RasterWorkerPoolTask* task_; }; - Task(); - ~Task(); - - // Returns true if Task is null (doesn't refer to anything). - bool is_null() const { return !internal_.get(); } + typedef std::vector<Item> Vector; - // Returns the Task into an uninitialized state. - void Reset(); + Item(internal::RasterWorkerPoolTask* task, bool required_for_activation); + ~Item(); - protected: - friend class RasterWorkerPool; - - explicit Task(internal::WorkerPoolTask* internal); + static bool IsRequiredForActivation(const Item& item) { + return item.required_for_activation; + } - scoped_refptr<internal::WorkerPoolTask> internal_; + scoped_refptr<internal::RasterWorkerPoolTask> task; + bool required_for_activation; }; - class CC_EXPORT RasterTask { - public: - typedef base::Callback<void(const PicturePileImpl::Analysis& analysis, - bool was_canceled)> Reply; - - class CC_EXPORT Queue { - public: - Queue(); - ~Queue(); - - void Reset(); - void Append(const RasterTask& task, bool required_for_activation); - void Swap(Queue* other); + RasterTaskQueue(); + ~RasterTaskQueue(); - size_t count() const { return tasks_.size(); } - size_t required_for_activation_count() const { - return required_for_activation_count_; - } - - private: - friend class RasterWorkerPool; - friend class DirectRasterWorkerPool; - - struct QueuedTask { - class TaskComparator { - public: - explicit TaskComparator(const internal::RasterWorkerPoolTask* task) - : task_(task) {} - - bool operator()(const QueuedTask& queued_task) const { - return queued_task.task == task_; - } - - private: - const internal::RasterWorkerPoolTask* task_; - }; - - typedef std::vector<QueuedTask> Vector; - - QueuedTask(internal::RasterWorkerPoolTask* task, - bool required_for_activation); - ~QueuedTask(); - - scoped_refptr<internal::RasterWorkerPoolTask> task; - bool required_for_activation; - }; - - QueuedTask::Vector tasks_; - size_t required_for_activation_count_; - }; + void Swap(RasterTaskQueue* other); + void Reset(); - RasterTask(); - ~RasterTask(); - - // Returns true if Task is null (doesn't refer to anything). - bool is_null() const { return !internal_.get(); } - - // Returns the Task into an uninitialized state. - void Reset(); - - protected: - friend class RasterWorkerPool; - - explicit RasterTask(internal::RasterWorkerPoolTask* internal); - - scoped_refptr<internal::RasterWorkerPoolTask> internal_; - }; + Item::Vector items; + size_t required_for_activation_count; +}; +// A worker thread pool that runs raster tasks. +class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient { + public: virtual ~RasterWorkerPool(); static void SetNumRasterThreads(int num_threads); @@ -211,7 +145,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient { static unsigned kRasterTaskPriorityBase; // TODO(vmpstr): Figure out an elegant way to not pass this many parameters. - static RasterTask CreateRasterTask( + static scoped_refptr<internal::RasterWorkerPoolTask> CreateRasterTask( const Resource* resource, PicturePileImpl* picture_pile, const gfx::Rect& content_rect, @@ -222,15 +156,15 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient { const void* tile_id, int source_frame_number, RenderingStatsInstrumentation* rendering_stats, - const RasterTask::Reply& reply, - Task::Set* dependencies, + const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply, + internal::WorkerPoolTask::Vector* dependencies, ContextProvider* context_provider); - static Task CreateImageDecodeTask( + static scoped_refptr<internal::WorkerPoolTask> CreateImageDecodeTask( SkPixelRef* pixel_ref, int layer_id, RenderingStatsInstrumentation* rendering_stats, - const Task::Reply& reply); + const base::Callback<void(bool was_canceled)>& reply); void SetClient(RasterWorkerPoolClient* client); @@ -243,7 +177,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient { // raster tasks in |queue| will be canceled unless already running. // Once scheduled, reply callbacks are guaranteed to run for all tasks // even if they later get canceled by another call to ScheduleTasks(). - virtual void ScheduleTasks(RasterTask::Queue* queue) = 0; + virtual void ScheduleTasks(RasterTaskQueue* queue) = 0; // Force a check for completed tasks. virtual void CheckForCompletedTasks() = 0; @@ -255,39 +189,6 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient { virtual ResourceFormat GetResourceFormat() const = 0; protected: - class RasterTaskQueueIterator { - public: - explicit RasterTaskQueueIterator(const RasterTask::Queue* queue) - : tasks_(&queue->tasks_), current_index_(0u) {} - ~RasterTaskQueueIterator() {} - - bool required_for_activation() const { - DCHECK_LT(current_index_, tasks_->size()); - return (*tasks_)[current_index_].required_for_activation; - } - - internal::RasterWorkerPoolTask* operator->() const { - DCHECK_LT(current_index_, tasks_->size()); - return (*tasks_)[current_index_].task.get(); - } - - internal::RasterWorkerPoolTask* operator*() const { - DCHECK_LT(current_index_, tasks_->size()); - return (*tasks_)[current_index_].task.get(); - } - - RasterTaskQueueIterator& operator++() { - DCHECK_LT(current_index_, tasks_->size()); - ++current_index_; - return *this; - } - - operator bool() const { return current_index_ < tasks_->size(); } - - private: - const RasterTask::Queue::QueuedTask::Vector* tasks_; - size_t current_index_; - }; typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector; typedef std::deque<scoped_refptr<internal::WorkerPoolTask> > TaskDeque; typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> > diff --git a/cc/resources/raster_worker_pool_delegate.cc b/cc/resources/raster_worker_pool_delegate.cc index dca4cfc..6a2edae 100644 --- a/cc/resources/raster_worker_pool_delegate.cc +++ b/cc/resources/raster_worker_pool_delegate.cc @@ -40,8 +40,7 @@ void RasterWorkerPoolDelegate::Shutdown() { (*it)->Shutdown(); } -void RasterWorkerPoolDelegate::ScheduleTasks( - RasterWorkerPool::RasterTask::Queue* raster_queue) { +void RasterWorkerPoolDelegate::ScheduleTasks(RasterTaskQueue* raster_queue) { for (size_t i = 0; i < raster_worker_pools_.size(); ++i) raster_worker_pools_[i]->ScheduleTasks(&raster_queue[i]); diff --git a/cc/resources/raster_worker_pool_delegate.h b/cc/resources/raster_worker_pool_delegate.h index 4be6d09..0a3be78 100644 --- a/cc/resources/raster_worker_pool_delegate.h +++ b/cc/resources/raster_worker_pool_delegate.h @@ -22,7 +22,7 @@ class RasterWorkerPoolDelegate : public RasterWorkerPoolClient { void SetClient(RasterWorkerPoolClient* client); void Shutdown(); - void ScheduleTasks(RasterWorkerPool::RasterTask::Queue* raster_queue); + void ScheduleTasks(RasterTaskQueue* raster_queue); void CheckForCompletedTasks(); // Overriden from RasterWorkerPoolClient: diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc index 70e667a..c76ec43 100644 --- a/cc/resources/raster_worker_pool_perftest.cc +++ b/cc/resources/raster_worker_pool_perftest.cc @@ -129,41 +129,8 @@ class RasterWorkerPoolPerfTest : public testing::TestWithParam<RasterWorkerPoolType>, public RasterWorkerPoolClient { public: - class Task : public RasterWorkerPool::Task { - public: - typedef std::vector<Task> Vector; - - static Task Create() { return Task(new PerfWorkerPoolTaskImpl); } - - void AppendTo(internal::WorkerPoolTask::Vector* dependencies) const { - dependencies->push_back(internal_); - } - - private: - explicit Task(internal::WorkerPoolTask* task) - : RasterWorkerPool::Task(task) {} - }; - - class RasterTask : public RasterWorkerPool::RasterTask { - public: - typedef std::vector<RasterTask> Vector; - - static RasterTask Create(scoped_ptr<ScopedResource> resource, - const Task::Vector& image_decode_tasks) { - internal::WorkerPoolTask::Vector dependencies; - for (Task::Vector::const_iterator it = image_decode_tasks.begin(); - it != image_decode_tasks.end(); - ++it) - it->AppendTo(&dependencies); - - return RasterTask( - new PerfRasterWorkerPoolTaskImpl(resource.Pass(), &dependencies)); - } - - private: - explicit RasterTask(internal::RasterWorkerPoolTask* task) - : RasterWorkerPool::RasterTask(task) {} - }; + typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> > + RasterTaskVector; RasterWorkerPoolPerfTest() : context_provider_(TestContextProvider::Create()), @@ -220,15 +187,17 @@ class RasterWorkerPoolPerfTest base::MessageLoop::current()->Run(); } - void CreateImageDecodeTasks(unsigned num_image_decode_tasks, - Task::Vector* image_decode_tasks) { + void CreateImageDecodeTasks( + unsigned num_image_decode_tasks, + internal::WorkerPoolTask::Vector* image_decode_tasks) { for (unsigned i = 0; i < num_image_decode_tasks; ++i) - image_decode_tasks->push_back(Task::Create()); + image_decode_tasks->push_back(new PerfWorkerPoolTaskImpl); } - void CreateRasterTasks(unsigned num_raster_tasks, - const Task::Vector& image_decode_tasks, - RasterTask::Vector* raster_tasks) { + void CreateRasterTasks( + unsigned num_raster_tasks, + const internal::WorkerPoolTask::Vector& image_decode_tasks, + RasterTaskVector* raster_tasks) { const gfx::Size size(1, 1); for (unsigned i = 0; i < num_raster_tasks; ++i) { @@ -236,29 +205,30 @@ class RasterWorkerPoolPerfTest ScopedResource::Create(resource_provider_.get())); resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888); + internal::WorkerPoolTask::Vector dependencies = image_decode_tasks; raster_tasks->push_back( - RasterTask::Create(resource.Pass(), image_decode_tasks)); + new PerfRasterWorkerPoolTaskImpl(resource.Pass(), &dependencies)); } } - void BuildTaskQueue(RasterWorkerPool::RasterTask::Queue* tasks, - const RasterTask::Vector& raster_tasks) { - for (RasterTask::Vector::const_iterator it = raster_tasks.begin(); + void BuildTaskQueue(RasterTaskQueue* queue, + const RasterTaskVector& raster_tasks) { + for (RasterTaskVector::const_iterator it = raster_tasks.begin(); it != raster_tasks.end(); ++it) - tasks->Append(*it, false); + queue->items.push_back(RasterTaskQueue::Item(it->get(), false)); } void RunScheduleTasksTest(const std::string& test_name, unsigned num_raster_tasks, unsigned num_image_decode_tasks) { - Task::Vector image_decode_tasks; - RasterTask::Vector raster_tasks; + internal::WorkerPoolTask::Vector image_decode_tasks; + RasterTaskVector raster_tasks; CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); // Avoid unnecessary heap allocations by reusing the same queue. - RasterWorkerPool::RasterTask::Queue queue; + RasterTaskQueue queue; timer_.Reset(); do { @@ -269,7 +239,7 @@ class RasterWorkerPoolPerfTest timer_.NextLap(); } while (!timer_.HasTimeLimitExpired()); - RasterWorkerPool::RasterTask::Queue empty; + RasterTaskQueue empty; raster_worker_pool_->ScheduleTasks(&empty); RunMessageLoopUntilAllTasksHaveCompleted(); @@ -285,8 +255,8 @@ class RasterWorkerPoolPerfTest unsigned num_raster_tasks, unsigned num_image_decode_tasks) { const size_t kNumVersions = 2; - Task::Vector image_decode_tasks[kNumVersions]; - RasterTask::Vector raster_tasks[kNumVersions]; + internal::WorkerPoolTask::Vector image_decode_tasks[kNumVersions]; + RasterTaskVector raster_tasks[kNumVersions]; for (size_t i = 0; i < kNumVersions; ++i) { CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]); CreateRasterTasks( @@ -294,7 +264,7 @@ class RasterWorkerPoolPerfTest } // Avoid unnecessary heap allocations by reusing the same queue. - RasterWorkerPool::RasterTask::Queue queue; + RasterTaskQueue queue; size_t count = 0; timer_.Reset(); @@ -307,7 +277,7 @@ class RasterWorkerPoolPerfTest timer_.NextLap(); } while (!timer_.HasTimeLimitExpired()); - RasterWorkerPool::RasterTask::Queue empty; + RasterTaskQueue empty; raster_worker_pool_->ScheduleTasks(&empty); RunMessageLoopUntilAllTasksHaveCompleted(); @@ -322,13 +292,13 @@ class RasterWorkerPoolPerfTest void RunScheduleAndExecuteTasksTest(const std::string& test_name, unsigned num_raster_tasks, unsigned num_image_decode_tasks) { - Task::Vector image_decode_tasks; - RasterTask::Vector raster_tasks; + internal::WorkerPoolTask::Vector image_decode_tasks; + RasterTaskVector raster_tasks; CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks); // Avoid unnecessary heap allocations by reusing the same queue. - RasterWorkerPool::RasterTask::Queue queue; + RasterTaskQueue queue; timer_.Reset(); do { @@ -339,7 +309,7 @@ class RasterWorkerPoolPerfTest timer_.NextLap(); } while (!timer_.HasTimeLimitExpired()); - RasterWorkerPool::RasterTask::Queue empty; + RasterTaskQueue empty; raster_worker_pool_->ScheduleTasks(&empty); RunMessageLoopUntilAllTasksHaveCompleted(); diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc index 4170a7a..7f4b2cd 100644 --- a/cc/resources/raster_worker_pool_unittest.cc +++ b/cc/resources/raster_worker_pool_unittest.cc @@ -113,39 +113,15 @@ class RasterWorkerPoolTest : public testing::TestWithParam<RasterWorkerPoolType>, public RasterWorkerPoolClient { public: - class RasterTask : public RasterWorkerPool::RasterTask { - public: - typedef std::vector<RasterTask> Vector; - - static RasterTask Create(const Resource* resource, - const TestRasterWorkerPoolTaskImpl::Reply& reply) { - internal::WorkerPoolTask::Vector dependencies; - return RasterTask( - new TestRasterWorkerPoolTaskImpl(resource, reply, &dependencies)); - } - - static RasterTask CreateBlocking( - const Resource* resource, - const TestRasterWorkerPoolTaskImpl::Reply& reply, - base::Lock* lock) { - internal::WorkerPoolTask::Vector dependencies; - return RasterTask(new BlockingTestRasterWorkerPoolTaskImpl( - resource, reply, lock, &dependencies)); - } - - private: - friend class RasterWorkerPoolTest; - - explicit RasterTask(internal::RasterWorkerPoolTask* task) - : RasterWorkerPool::RasterTask(task) {} - }; - struct RasterTaskResult { unsigned id; bool canceled; RasterThread raster_thread; }; + typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> > + RasterTaskVector; + RasterWorkerPoolTest() : context_provider_(TestContextProvider::Create()), timeout_seconds_(5), @@ -212,11 +188,12 @@ class RasterWorkerPoolTest } void ScheduleTasks() { - RasterWorkerPool::RasterTask::Queue queue; + RasterTaskQueue queue; - for (RasterTask::Vector::iterator it = tasks_.begin(); it != tasks_.end(); + for (RasterTaskVector::const_iterator it = tasks_.begin(); + it != tasks_.end(); ++it) - queue.Append(*it, false); + queue.items.push_back(RasterTaskQueue::Item(*it, false)); raster_worker_pool_->ScheduleTasks(&queue); } @@ -229,12 +206,14 @@ class RasterWorkerPoolTest resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888); const Resource* const_resource = resource.get(); - tasks_.push_back( - RasterTask::Create(const_resource, - base::Bind(&RasterWorkerPoolTest::OnTaskCompleted, - base::Unretained(this), - base::Passed(&resource), - id))); + internal::WorkerPoolTask::Vector empty; + tasks_.push_back(new TestRasterWorkerPoolTaskImpl( + const_resource, + base::Bind(&RasterWorkerPoolTest::OnTaskCompleted, + base::Unretained(this), + base::Passed(&resource), + id), + &empty)); } void AppendBlockingTask(unsigned id, base::Lock* lock) { @@ -245,13 +224,15 @@ class RasterWorkerPoolTest resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888); const Resource* const_resource = resource.get(); - tasks_.push_back(RasterTask::CreateBlocking( + internal::WorkerPoolTask::Vector empty; + tasks_.push_back(new BlockingTestRasterWorkerPoolTaskImpl( const_resource, base::Bind(&RasterWorkerPoolTest::OnTaskCompleted, base::Unretained(this), base::Passed(&resource), id), - lock)); + lock, + &empty)); } const std::vector<RasterTaskResult>& completed_tasks() const { @@ -285,7 +266,7 @@ class RasterWorkerPoolTest base::CancelableClosure timeout_; int timeout_seconds_; bool timed_out_; - std::vector<RasterTask> tasks_; + RasterTaskVector tasks_; std::vector<RasterTaskResult> completed_tasks_; }; diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc index 60e69fa..9418451 100644 --- a/cc/resources/tile_manager.cc +++ b/cc/resources/tile_manager.cc @@ -214,7 +214,7 @@ TileManager::~TileManager() { CleanUpReleasedTiles(); DCHECK_EQ(0u, tiles_.size()); - RasterWorkerPool::RasterTask::Queue empty[NUM_RASTER_WORKER_POOL_TYPES]; + RasterTaskQueue empty[NUM_RASTER_WORKER_POOL_TYPES]; raster_worker_pool_delegate_->ScheduleTasks(empty); // This should finish all pending tasks and release any uninitialized @@ -354,9 +354,8 @@ void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) { const ManagedTileState::TileVersion& tile_version = tile->GetTileVersionForDrawing(); bool tile_is_ready_to_draw = tile_version.IsReadyToDraw(); - bool tile_is_active = - tile_is_ready_to_draw || - !mts.tile_versions[mts.raster_mode].raster_task_.is_null(); + bool tile_is_active = tile_is_ready_to_draw || + mts.tile_versions[mts.raster_mode].raster_task_; // Get the active priority and bin. TilePriority active_priority = tile->priority(ACTIVE_TREE); @@ -686,7 +685,7 @@ void TileManager::AssignGpuMemoryToTiles( if (raster_bytes_if_rastered <= max_raster_bytes) { // If we don't have the required version, and it's not in flight // then we'll have to pay to create a new task. - if (!tile_version.resource_ && tile_version.raster_task_.is_null()) { + if (!tile_version.resource_ && !tile_version.raster_task_) { tile_bytes += bytes_if_allocated; tile_resources++; } @@ -819,15 +818,17 @@ void TileManager::ScheduleTasks( DCHECK(tile_version.requires_resource()); DCHECK(!tile_version.resource_); - if (tile_version.raster_task_.is_null()) + if (!tile_version.raster_task_) tile_version.raster_task_ = CreateRasterTask(tile); size_t pool_type = tile->use_gpu_rasterization() ? RASTER_WORKER_POOL_TYPE_DIRECT : RASTER_WORKER_POOL_TYPE_DEFAULT; - raster_queue_[pool_type] - .Append(tile_version.raster_task_, tile->required_for_activation()); + raster_queue_[pool_type].items.push_back(RasterTaskQueue::Item( + tile_version.raster_task_.get(), tile->required_for_activation())); + raster_queue_[pool_type].required_for_activation_count += + tile->required_for_activation(); } // We must reduce the amount of unused resoruces before calling @@ -842,7 +843,7 @@ void TileManager::ScheduleTasks( did_check_for_completed_tasks_since_last_schedule_tasks_ = false; } -RasterWorkerPool::Task TileManager::CreateImageDecodeTask( +scoped_refptr<internal::WorkerPoolTask> TileManager::CreateImageDecodeTask( Tile* tile, SkPixelRef* pixel_ref) { return RasterWorkerPool::CreateImageDecodeTask( @@ -855,7 +856,8 @@ RasterWorkerPool::Task TileManager::CreateImageDecodeTask( base::Unretained(pixel_ref))); } -RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) { +scoped_refptr<internal::RasterWorkerPoolTask> TileManager::CreateRasterTask( + Tile* tile) { ManagedTileState& mts = tile->managed_state(); scoped_ptr<ScopedResource> resource = @@ -863,7 +865,7 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) { const ScopedResource* const_resource = resource.get(); // Create and queue all image decode tasks that this tile depends on. - RasterWorkerPool::Task::Set decode_tasks; + internal::WorkerPoolTask::Vector decode_tasks; PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()]; for (PicturePileImpl::PixelRefIterator iter( tile->content_rect(), tile->contents_scale(), tile->picture_pile()); @@ -875,13 +877,14 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) { // Append existing image decode task if available. PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id); if (decode_task_it != existing_pixel_refs.end()) { - decode_tasks.Insert(decode_task_it->second); + decode_tasks.push_back(decode_task_it->second); continue; } // Create and append new image decode task for this pixel ref. - RasterWorkerPool::Task decode_task = CreateImageDecodeTask(tile, pixel_ref); - decode_tasks.Insert(decode_task); + scoped_refptr<internal::WorkerPoolTask> decode_task = + CreateImageDecodeTask(tile, pixel_ref); + decode_tasks.push_back(decode_task); existing_pixel_refs[id] = decode_task; } @@ -942,8 +945,8 @@ void TileManager::OnRasterTaskCompleted( Tile* tile = it->second; ManagedTileState& mts = tile->managed_state(); ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode]; - DCHECK(!tile_version.raster_task_.is_null()); - tile_version.raster_task_.Reset(); + DCHECK(tile_version.raster_task_); + tile_version.raster_task_ = NULL; if (was_canceled) { ++update_visible_tiles_stats_.canceled_count; diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h index 200d1f0..c279d2c 100644 --- a/cc/resources/tile_manager.h +++ b/cc/resources/tile_manager.h @@ -176,9 +176,10 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient, void FreeResourceForTile(Tile* tile, RasterMode mode); void FreeResourcesForTile(Tile* tile); void FreeUnusedResourcesForTile(Tile* tile); - RasterWorkerPool::Task CreateImageDecodeTask(Tile* tile, - SkPixelRef* pixel_ref); - RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile); + scoped_refptr<internal::WorkerPoolTask> CreateImageDecodeTask( + Tile* tile, + SkPixelRef* pixel_ref); + scoped_refptr<internal::RasterWorkerPoolTask> CreateRasterTask(Tile* tile); scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const; void UpdatePrioritizedTileSetIfNeeded(); @@ -214,7 +215,8 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient, bool did_initialize_visible_tile_; bool did_check_for_completed_tasks_since_last_schedule_tasks_; - typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefTaskMap; + typedef base::hash_map<uint32_t, scoped_refptr<internal::WorkerPoolTask> > + PixelRefTaskMap; typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap; LayerPixelRefTaskMap image_decode_tasks_; @@ -228,8 +230,7 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient, bool use_rasterize_on_demand_; // Queues used when scheduling raster tasks. - RasterWorkerPool::RasterTask::Queue - raster_queue_[NUM_RASTER_WORKER_POOL_TYPES]; + RasterTaskQueue raster_queue_[NUM_RASTER_WORKER_POOL_TYPES]; DISALLOW_COPY_AND_ASSIGN(TileManager); }; |