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

Unified Diff: cc/resources/raster_worker_pool.cc

Issue 16190002: cc: Add new RasterWorkerPool interface. (Closed) Base URL: http://git.chromium.org/chromium/src.git@master
Patch Set: rebase Created 7 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/resources/raster_worker_pool.h ('k') | cc/resources/raster_worker_pool_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index dcfb6471ba5d22c502fc9b58d428fb1ec447eb2f..97489582d5a30919cd8da6c13395852214e91ae0 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -1,4 +1,4 @@
-// Copyright 2012 The Chromium Authors. All rights reserved.
+// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
@@ -10,72 +10,70 @@ namespace cc {
namespace {
-class RasterWorkerPoolContainerTaskImpl : public internal::WorkerPoolTask {
- public:
- RasterWorkerPoolContainerTaskImpl(
- internal::WorkerPoolTask::TaskVector* dependencies)
- : internal::WorkerPoolTask(dependencies) {
- }
-
- // Overridden from internal::WorkerPoolTask:
- virtual void RunOnThread(unsigned thread_index) OVERRIDE {}
- virtual void DispatchCompletionCallback() OVERRIDE {}
-
- private:
- virtual ~RasterWorkerPoolContainerTaskImpl() {}
-};
+void Noop() {}
-class RasterWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+class WorkerPoolTaskImpl : public internal::WorkerPoolTask {
public:
- RasterWorkerPoolTaskImpl(const base::Closure& callback,
- const RasterWorkerPool::Task::Reply& reply)
+ WorkerPoolTaskImpl(const base::Closure& callback,
+ const base::Closure& reply)
: callback_(callback),
reply_(reply) {
}
+ explicit WorkerPoolTaskImpl(
+ internal::WorkerPoolTask::TaskVector* dependencies)
+ : internal::WorkerPoolTask(dependencies),
+ callback_(base::Bind(&Noop)),
+ reply_(base::Bind(&Noop)) {
+ }
// Overridden from internal::WorkerPoolTask:
virtual void RunOnThread(unsigned thread_index) OVERRIDE {
callback_.Run();
}
virtual void DispatchCompletionCallback() OVERRIDE {
- reply_.Run(!HasFinishedRunning());
+ reply_.Run();
}
private:
- virtual ~RasterWorkerPoolTaskImpl() {}
+ virtual ~WorkerPoolTaskImpl() {}
const base::Closure callback_;
- const RasterWorkerPool::Task::Reply reply_;
+ const base::Closure reply_;
+
+ DISALLOW_COPY_AND_ASSIGN(WorkerPoolTaskImpl);
};
-class RasterWorkerPoolPictureTaskImpl : public internal::WorkerPoolTask {
+class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
public:
- RasterWorkerPoolPictureTaskImpl(
+ RasterWorkerPoolTaskImpl(
PicturePileImpl* picture_pile,
- const RasterWorkerPool::PictureTask::Callback& callback,
- const RasterWorkerPool::Task::Reply& reply,
+ const Resource* resource,
+ const RasterWorkerPool::RasterTask::Callback& callback,
+ const RasterWorkerPool::RasterTask::Reply& reply,
internal::WorkerPoolTask::TaskVector* dependencies)
- : internal::WorkerPoolTask(dependencies),
+ : internal::RasterWorkerPoolTask(resource, dependencies),
picture_pile_(picture_pile),
callback_(callback),
reply_(reply) {
- DCHECK(picture_pile_.get());
}
- // Overridden from internal::WorkerPoolTask:
- virtual void RunOnThread(unsigned thread_index) OVERRIDE {
- callback_.Run(picture_pile_->GetCloneForDrawingOnThread(thread_index));
+ // Overridden from internal::RasterWorkerPoolTask:
+ virtual bool RunOnThread(SkDevice* device, unsigned thread_index) OVERRIDE {
+ return callback_.Run(
+ device, picture_pile_->GetCloneForDrawingOnThread(thread_index));
}
virtual void DispatchCompletionCallback() OVERRIDE {
reply_.Run(!HasFinishedRunning());
}
private:
- virtual ~RasterWorkerPoolPictureTaskImpl() {}
+ virtual ~RasterWorkerPoolTaskImpl() {}
scoped_refptr<PicturePileImpl> picture_pile_;
- const RasterWorkerPool::PictureTask::Callback callback_;
- const RasterWorkerPool::Task::Reply reply_;
+ const RasterWorkerPool::RasterTask::Callback callback_;
+ const RasterWorkerPool::RasterTask::Reply reply_;
+
+ DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
};
const char* kWorkerThreadNamePrefix = "CompositorRaster";
@@ -84,13 +82,47 @@ const int kCheckForCompletedTasksDelayMs = 6;
} // namespace
-RasterWorkerPool::Task::Queue::Queue() {
+namespace internal {
+
+RasterWorkerPoolTask::RasterWorkerPoolTask(
+ const Resource* resource,
+ WorkerPoolTask::TaskVector* dependencies)
+ : did_run_(false),
+ did_complete_(false),
+ resource_(resource) {
+ dependencies_.swap(*dependencies);
+}
+
+RasterWorkerPoolTask::~RasterWorkerPoolTask() {
+}
+
+void RasterWorkerPoolTask::DidRun() {
+ DCHECK(!did_run_);
+ did_run_ = true;
+}
+
+bool RasterWorkerPoolTask::HasFinishedRunning() const {
+ return did_run_;
+}
+
+void RasterWorkerPoolTask::DidComplete() {
+ DCHECK(!did_complete_);
+ did_complete_ = true;
}
-RasterWorkerPool::Task::Queue::~Queue() {
+bool RasterWorkerPoolTask::HasCompleted() const {
+ return did_complete_;
}
-void RasterWorkerPool::Task::Queue::Append(const Task& task) {
+} // 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_);
}
@@ -99,54 +131,84 @@ RasterWorkerPool::Task::Task() {
}
RasterWorkerPool::Task::Task(const base::Closure& callback,
- const Reply& reply)
- : internal_(new RasterWorkerPoolTaskImpl(callback, reply)) {
+ const base::Closure& reply)
+ : internal_(new WorkerPoolTaskImpl(callback, reply)) {
+}
+
+RasterWorkerPool::Task::~Task() {
}
-RasterWorkerPool::Task::Task(Queue* dependencies)
- : internal_(new RasterWorkerPoolContainerTaskImpl(&dependencies->tasks_)) {
+void RasterWorkerPool::Task::Reset() {
+ internal_ = NULL;
}
-RasterWorkerPool::Task::Task(scoped_refptr<internal::WorkerPoolTask> internal)
- : internal_(internal) {
+RasterWorkerPool::RasterTask::Queue::Queue() {
}
-RasterWorkerPool::Task::~Task() {
+RasterWorkerPool::RasterTask::Queue::~Queue() {
}
-void RasterWorkerPool::Task::Reset() {
+void RasterWorkerPool::RasterTask::Queue::Append(const RasterTask& task) {
+ DCHECK(!task.is_null());
+ tasks_.push_back(task.internal_);
+}
+
+RasterWorkerPool::RasterTask::RasterTask() {
+}
+
+RasterWorkerPool::RasterTask::RasterTask(PicturePileImpl* picture_pile,
+ const Resource* resource,
+ const Callback& callback,
+ const Reply& reply,
+ Task::Set* dependencies)
+ : internal_(new RasterWorkerPoolTaskImpl(picture_pile,
+ resource,
+ callback,
+ reply,
+ &dependencies->tasks_)) {
+}
+
+void RasterWorkerPool::RasterTask::Reset() {
internal_ = NULL;
}
-RasterWorkerPool::PictureTask::PictureTask(PicturePileImpl* picture_pile,
- const Callback& callback,
- const Reply& reply,
- Task::Queue* dependencies)
- : RasterWorkerPool::Task(
- new RasterWorkerPoolPictureTaskImpl(picture_pile,
- callback,
- reply,
- &dependencies->tasks_)) {
+RasterWorkerPool::RasterTask::~RasterTask() {
}
-RasterWorkerPool::RasterWorkerPool(size_t num_threads) : WorkerPool(
- num_threads,
- base::TimeDelta::FromMilliseconds(kCheckForCompletedTasksDelayMs),
- kWorkerThreadNamePrefix) {
+RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
+ size_t num_threads)
+ : WorkerPool(
+ num_threads,
+ base::TimeDelta::FromMilliseconds(kCheckForCompletedTasksDelayMs),
+ kWorkerThreadNamePrefix),
+ resource_provider_(resource_provider) {
}
RasterWorkerPool::~RasterWorkerPool() {
}
void RasterWorkerPool::Shutdown() {
- // Cancel all previously scheduled tasks.
- WorkerPool::ScheduleTasks(NULL);
-
+ raster_tasks_.clear();
WorkerPool::Shutdown();
}
-void RasterWorkerPool::ScheduleTasks(Task* task) {
- WorkerPool::ScheduleTasks(task ? task->internal_ : NULL);
+bool RasterWorkerPool::ForceUploadToComplete(const RasterTask& raster_task) {
+ return false;
+}
+
+void RasterWorkerPool::SetRasterTasks(RasterTask::Queue* queue) {
+ raster_tasks_.swap(queue->tasks_);
+}
+
+void RasterWorkerPool::ScheduleRasterTasks(
+ internal::WorkerPoolTask::TaskVector* raster_tasks) {
+ if (raster_tasks->empty()) {
+ WorkerPool::ScheduleTasks(NULL);
+ return;
+ }
+
+ scoped_refptr<WorkerPoolTaskImpl> root(new WorkerPoolTaskImpl(raster_tasks));
+ WorkerPool::ScheduleTasks(root);
}
} // namespace cc
« no previous file with comments | « cc/resources/raster_worker_pool.h ('k') | cc/resources/raster_worker_pool_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698