cc: Move task graph construction to RasterWorkerPool classes.

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 f168cbc8b7b68e0eff3b3de3dfca83c5ee378d1b..c868be757903354a754900206cfab8e503970dcf 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -30,7 +30,7 @@ namespace internal {
 class CC_EXPORT RasterWorkerPoolTask
     : public base::RefCounted<RasterWorkerPoolTask> {
  public:
-  typedef std::vector<scoped_refptr<RasterWorkerPoolTask> > TaskVector;
+  typedef std::vector<scoped_refptr<WorkerPoolTask> > TaskVector;
 
   // Returns true if |device| was written to. False indicate that
   // the content of |device| is undefined and the resource doesn't
@@ -45,15 +45,12 @@ class CC_EXPORT RasterWorkerPoolTask
   bool HasCompleted() const;
 
   const Resource* resource() const { return resource_; }
-  const WorkerPoolTask::TaskVector& dependencies() const {
-    return dependencies_;
-  }
+  const TaskVector& dependencies() const { return dependencies_; }
 
  protected:
   friend class base::RefCounted<RasterWorkerPoolTask>;
 
-  RasterWorkerPoolTask(const Resource* resource,
-                       WorkerPoolTask::TaskVector* dependencies);
+  RasterWorkerPoolTask(const Resource* resource, TaskVector* dependencies);
   virtual ~RasterWorkerPoolTask();
 
  private:
@@ -61,7 +58,7 @@ class CC_EXPORT RasterWorkerPoolTask
   bool did_complete_;
   bool was_canceled_;
   const Resource* resource_;
-  WorkerPoolTask::TaskVector dependencies_;
+  TaskVector dependencies_;
 };
 
 }  // namespace internal
@@ -128,7 +125,7 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
       friend class RasterWorkerPool;
       friend class RasterWorkerPoolTest;
 
-      typedef internal::WorkerPoolTask::TaskVector TaskVector;
+      typedef internal::RasterWorkerPoolTask::TaskVector TaskVector;
       TaskVector tasks_;
     };
 
@@ -157,8 +154,6 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
 
     class CC_EXPORT Queue {
      public:
-      typedef internal::RasterWorkerPoolTask::TaskVector TaskVector;
-
       Queue();
       ~Queue();
 
@@ -167,6 +162,8 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
      private:
       friend class RasterWorkerPool;
 
+      typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
+          TaskVector;
       TaskVector tasks_;
       typedef base::hash_set<internal::RasterWorkerPoolTask*> TaskSet;
       TaskSet tasks_required_for_activation_;
@@ -182,7 +179,6 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
     void Reset();
 
    protected:
-    friend class PixelBufferRasterWorkerPool;
     friend class RasterWorkerPool;
     friend class RasterWorkerPoolTest;
 
@@ -217,7 +213,7 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
       const RasterTaskMetadata& metadata,
       RenderingStatsInstrumentation* rendering_stats,
       const RasterTask::Reply& reply,
-      Task::Set& dependencies);
+      Task::Set* dependencies);
 
   static Task CreateImageDecodeTask(
       skia::LazyPixelRef* pixel_ref,
@@ -226,28 +222,38 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
       const Task::Reply& reply);
 
  protected:
-  class RootTask {
+  typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
+  typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
+      RasterTaskVector;
+  typedef internal::RasterWorkerPoolTask* TaskMapKey;
+  typedef base::hash_map<TaskMapKey,
+                         scoped_refptr<internal::WorkerPoolTask> > TaskMap;
+
+  class CC_EXPORT RasterTaskGraph {
    public:
-    RootTask();
-    explicit RootTask(internal::WorkerPoolTask::TaskVector* dependencies);
-    RootTask(const base::Closure& callback,
-             internal::WorkerPoolTask::TaskVector* dependencies);
-    ~RootTask();
+    RasterTaskGraph();
+    ~RasterTaskGraph();
 
-   protected:
+    void InsertRasterTask(internal::WorkerPoolTask* raster_task,
+                          const TaskVector& decode_tasks);
+
+   private:
     friend class RasterWorkerPool;
 
-    scoped_refptr<internal::WorkerPoolTask> internal_;
-  };
+    TaskGraph graph_;
+    scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
+    scoped_ptr<GraphNode> raster_finished_node_;
+    unsigned next_priority_;
 
-  typedef internal::RasterWorkerPoolTask* TaskMapKey;
-  typedef base::hash_map<TaskMapKey,
-                         scoped_refptr<internal::WorkerPoolTask> > TaskMap;
+    DISALLOW_COPY_AND_ASSIGN(RasterTaskGraph);
+  };
 
   RasterWorkerPool(ResourceProvider* resource_provider, size_t num_threads);
 
+  virtual void OnRasterTasksFinished() {}
+
   void SetRasterTasks(RasterTask::Queue* queue);
-  void ScheduleRasterTasks(const RootTask& root);
+  void SetRasterTaskGraph(RasterTaskGraph* graph);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
 
@@ -258,13 +264,16 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   }
 
  private:
+  void OnRasterFinished(int64 schedule_raster_tasks_count);
+
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
   RasterTask::Queue::TaskVector raster_tasks_;
   RasterTask::Queue::TaskSet raster_tasks_required_for_activation_;
 
-  // The root task that is a dependent of all other tasks.
-  scoped_refptr<internal::WorkerPoolTask> root_;
+  base::WeakPtrFactory<RasterWorkerPool> weak_ptr_factory_;
+  scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
+  int64 schedule_raster_tasks_count_;
 };
 
 }  // namespace cc