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

cc/resources/raster_worker_pool.h

 // 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.
 
 #ifndef CC_RESOURCES_RASTER_WORKER_POOL_H_
 #define CC_RESOURCES_RASTER_WORKER_POOL_H_
 
-#include <string>
+#include <deque>
 
 #include "cc/base/worker_pool.h"
 
 namespace cc {
 class PicturePileImpl;
 
+namespace internal {
+
+class RasterWorkerPoolTask : public WorkerPoolTask {
+ public:
+  typedef base::Callback<void(bool)> Reply;
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void DispatchCompletionCallback() OVERRIDE;
+
+  void DidSchedule();
+
+ protected:
+  explicit RasterWorkerPoolTask(const Reply& reply);
+  virtual ~RasterWorkerPoolTask();
+
+  void WillRun();
+  void DidRun();
+
+  const Reply reply_;
+  bool did_schedule_;
+  bool did_run_;
+  bool did_complete_;
+};
+
+}  // namespace internal
+
 // A worker thread pool that runs raster tasks.
 class RasterWorkerPool : public WorkerPool {
  public:
-  typedef base::Callback<void(PicturePileImpl* picture_pile)> RasterCallback;
+  class Task {
+   public:
+    typedef base::Callback<void(bool)> Reply;
+
+    class Queue {
+     public:
+      Queue();
+      ~Queue();
+
+      void Append(const Task& task);
+
+      unsigned size() const { return tasks_.size(); }
+
+     private:
+      friend class RasterWorkerPool;
+
+      typedef std::deque<scoped_refptr<internal::RasterWorkerPoolTask> > Deque;
+      Deque tasks_;
+    };
+
+    Task();
+    Task(const base::Closure& callback, const Reply& reply);
+    ~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:
+    explicit Task(scoped_refptr<internal::RasterWorkerPoolTask> internal);
+
+    scoped_refptr<internal::RasterWorkerPoolTask> internal_;
+  };
+
+  class PictureTask : public Task {
+   public:
+    typedef base::Callback<void(PicturePileImpl*)> Callback;
+
+    PictureTask(PicturePileImpl* picture_pile,
+                const Callback& callback,
+                const Reply& reply);
+  };
 
   virtual ~RasterWorkerPool();
 
   static scoped_ptr<RasterWorkerPool> Create(
       WorkerPoolClient* client, size_t num_threads) {
     return make_scoped_ptr(new RasterWorkerPool(client, num_threads));
   }
 
-  void PostRasterTaskAndReply(PicturePileImpl* picture_pile,
-                              const RasterCallback& task,
-                              const base::Closure& reply);
+  // Schedule running of tasks in |queue|. All tasks previously scheduled
+  // but not present in |queue| will be canceled. Once scheduled,
+  // reply callbacks are guaranteed to run for all tasks even if they
+  // later get canceled by another call to ScheduleTasks(). This consumed
+  // all tasks and queue will be empty when function returns.
+  void ScheduleTasks(Task::Queue* queue);
 
  private:
   RasterWorkerPool(WorkerPoolClient* client, size_t num_threads);
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPool);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RASTER_WORKER_POOL_H_