summaryrefslogtreecommitdiffstats
path: root/cc/resources
diff options
context:
space:
mode:
authorreveman@chromium.org <reveman@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2014-02-19 02:42:04 +0000
committerreveman@chromium.org <reveman@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2014-02-19 02:42:04 +0000
commit13b45f1e5895466645be643c86397ee9ca0b9921 (patch)
tree08b5bc68e0c2760abb46160ceff9f48a5fd19ed9 /cc/resources
parent5f82572c92520e67a6d1490bbb407211e8fca531 (diff)
downloadchromium_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.cc36
-rw-r--r--cc/resources/direct_raster_worker_pool.h4
-rw-r--r--cc/resources/image_raster_worker_pool.cc23
-rw-r--r--cc/resources/image_raster_worker_pool.h4
-rw-r--r--cc/resources/managed_tile_state.cc2
-rw-r--r--cc/resources/managed_tile_state.h2
-rw-r--r--cc/resources/pixel_buffer_raster_worker_pool.cc36
-rw-r--r--cc/resources/pixel_buffer_raster_worker_pool.h4
-rw-r--r--cc/resources/raster_worker_pool.cc140
-rw-r--r--cc/resources/raster_worker_pool.h161
-rw-r--r--cc/resources/raster_worker_pool_delegate.cc3
-rw-r--r--cc/resources/raster_worker_pool_delegate.h2
-rw-r--r--cc/resources/raster_worker_pool_perftest.cc86
-rw-r--r--cc/resources/raster_worker_pool_unittest.cc59
-rw-r--r--cc/resources/tile_manager.cc35
-rw-r--r--cc/resources/tile_manager.h13
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);
};