Re-land: cc: Cancel and re-prioritize worker pool tasks.

cc/resources/raster_worker_pool.cc

 // Copyright 2012 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.
 
 #include "cc/resources/raster_worker_pool.h"
 
 #include "cc/resources/picture_pile_impl.h"
 
 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() {}
+};
+
 class RasterWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
-  RasterWorkerPoolTaskImpl(PicturePileImpl* picture_pile,
-                           const RasterWorkerPool::RasterCallback& task,
-                           const base::Closure& reply)
-      : internal::WorkerPoolTask(reply),
+  RasterWorkerPoolTaskImpl(const base::Closure& callback,
+                           const RasterWorkerPool::Task::Reply& reply)
+      : callback_(callback),
+        reply_(reply) {
+  }
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void RunOnThread(unsigned thread_index) OVERRIDE {
+    callback_.Run();
+  }
+  virtual void DispatchCompletionCallback() OVERRIDE {
+    reply_.Run(!HasFinishedRunning());
+  }
+
+ private:
+  virtual ~RasterWorkerPoolTaskImpl() {}
+
+  const base::Closure callback_;
+  const RasterWorkerPool::Task::Reply reply_;
+};
+
+class RasterWorkerPoolPictureTaskImpl : public internal::WorkerPoolTask {
+ public:
+  RasterWorkerPoolPictureTaskImpl(
+      PicturePileImpl* picture_pile,
+      const RasterWorkerPool::PictureTask::Callback& callback,
+      const RasterWorkerPool::Task::Reply& reply,
+      internal::WorkerPoolTask::TaskVector* dependencies)
+      : internal::WorkerPoolTask(dependencies),
         picture_pile_(picture_pile),
-        task_(task) {
+        callback_(callback),
+        reply_(reply) {
     DCHECK(picture_pile_);
   }
 
+  // Overridden from internal::WorkerPoolTask:
   virtual void RunOnThread(unsigned thread_index) OVERRIDE {
-    task_.Run(picture_pile_->GetCloneForDrawingOnThread(thread_index));
+    callback_.Run(picture_pile_->GetCloneForDrawingOnThread(thread_index));
+  }
+  virtual void DispatchCompletionCallback() OVERRIDE {
+    reply_.Run(!HasFinishedRunning());
   }
 
  private:
+  virtual ~RasterWorkerPoolPictureTaskImpl() {}
+
   scoped_refptr<PicturePileImpl> picture_pile_;
-  RasterWorkerPool::RasterCallback task_;
+  const RasterWorkerPool::PictureTask::Callback callback_;
+  const RasterWorkerPool::Task::Reply reply_;
 };
 
 const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 const int kCheckForCompletedTasksDelayMs = 6;
 
 }  // namespace
 
-RasterWorkerPool::RasterWorkerPool(size_t num_threads)
-    : WorkerPool(
-          num_threads,
-          base::TimeDelta::FromMilliseconds(kCheckForCompletedTasksDelayMs),
-          kWorkerThreadNamePrefix) {
+RasterWorkerPool::Task::Queue::Queue() {
+}
+
+RasterWorkerPool::Task::Queue::~Queue() {
+}
+
+void RasterWorkerPool::Task::Queue::Append(const Task& task) {
+  DCHECK(!task.is_null());
+  tasks_.push_back(task.internal_);
+}
+
+RasterWorkerPool::Task::Task() {
+}
+
+RasterWorkerPool::Task::Task(const base::Closure& callback,
+                             const Reply& reply)
+    : internal_(new RasterWorkerPoolTaskImpl(callback, reply)) {
+}
+
+RasterWorkerPool::Task::Task(Queue* dependencies)
+    : internal_(new RasterWorkerPoolContainerTaskImpl(&dependencies->tasks_)) {
+}
+
+RasterWorkerPool::Task::Task(scoped_refptr<internal::WorkerPoolTask> internal)
+    : internal_(internal) {
+}
+
+RasterWorkerPool::Task::~Task() {
+}
+
+void RasterWorkerPool::Task::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::RasterWorkerPool(size_t num_threads) : WorkerPool(
+    num_threads,
+    base::TimeDelta::FromMilliseconds(kCheckForCompletedTasksDelayMs),
+    kWorkerThreadNamePrefix) {
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
 }
 
-void RasterWorkerPool::PostRasterTaskAndReply(PicturePileImpl* picture_pile,
-                                              const RasterCallback& task,
-                                              const base::Closure& reply) {
-  PostTask(make_scoped_ptr(new RasterWorkerPoolTaskImpl(
-                               picture_pile,
-                               task,
-                               reply)).PassAs<internal::WorkerPoolTask>());
+void RasterWorkerPool::Shutdown() {
+  // Cancel all previously scheduled tasks.
+  WorkerPool::ScheduleTasks(NULL);
+
+  WorkerPool::Shutdown();
+}
+
+void RasterWorkerPool::ScheduleTasks(Task* task) {
+  WorkerPool::ScheduleTasks(task ? task->internal_ : NULL);
 }
 
 }  // namespace cc