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

cc/resources/raster_worker_pool.h

Index: cc/resources/raster_worker_pool.h
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 76d0497376ff893b50a991ca20cd1182d0d9ca2a..98032dd27db8c0c1eefb2017dedb1f21e33ea1be 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -5,8 +5,6 @@
 #ifndef CC_RESOURCES_RASTER_WORKER_POOL_H_
 #define CC_RESOURCES_RASTER_WORKER_POOL_H_
 
-#include <string>
-
 #include "cc/base/worker_pool.h"
 
 namespace cc {
@@ -15,7 +13,55 @@ class PicturePileImpl;
 // A worker thread pool that runs raster tasks.
 class CC_EXPORT RasterWorkerPool : public WorkerPool {
  public:
-  typedef base::Callback<void(PicturePileImpl* picture_pile)> RasterCallback;
+  class Task {

[reveman, 2013/05/23 22:21:32]

FYI, added this class instead of exposing the internal::WorkerPoolTask pointers
directly to the tile manager. It prevents non-thread safe usage of these objects
by the tile manager.

+   public:
+    typedef base::Callback<void(bool)> Reply;
+
+    // Highest priority task first. Order of execution is not guaranteed.
+    class Queue {
+     public:
+      Queue();
+      ~Queue();
+
+      bool empty() const { return tasks_.empty(); }
+
+      // Add task to the back of the queue.
+      void Append(const Task& task);
+
+     private:
+      friend class RasterWorkerPool;
+
+      internal::WorkerPoolTask::TaskVector tasks_;
+    };
+
+    Task();
+    Task(const base::Closure& callback, const Reply& reply);
+    explicit Task(Queue* dependencies);
+    ~Task();
+
+    // Returns true if Task is null (doesn't refer to anything).
+    bool is_null() const { return !internal_; }
+
+    // Returns the Task into an uninitialized state.
+    void Reset();
+
+   protected:
+    friend class RasterWorkerPool;
+
+    explicit Task(scoped_refptr<internal::WorkerPoolTask> internal);
+
+    scoped_refptr<internal::WorkerPoolTask> internal_;
+  };
+
+  class PictureTask : public Task {
+   public:
+    typedef base::Callback<void(PicturePileImpl*)> Callback;
+
+    PictureTask(PicturePileImpl* picture_pile,
+                const Callback& callback,
+                const Reply& reply,
+                Queue* dependencies);
+  };
 
   virtual ~RasterWorkerPool();
 
@@ -23,9 +69,16 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
     return make_scoped_ptr(new RasterWorkerPool(num_threads));
   }
 
-  void PostRasterTaskAndReply(PicturePileImpl* picture_pile,
-                              const RasterCallback& task,
-                              const base::Closure& reply);
+  // Tells the worker pool to shutdown after canceling all previously
+  // scheduled tasks. Reply callbacks are still guaranteed to run.
+  virtual void Shutdown() OVERRIDE;
+
+  // Schedule running of |root| task and all its dependencies. Tasks
+  // previously scheduled but no longer needed to run |root| 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().
+  void ScheduleTasks(Task* root);
 
  private:
   explicit RasterWorkerPool(size_t num_threads);