Re-land: cc: Add raster finished signals to RasterWorkerPool.

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 <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 87 matching lines @@
     bool is_tile_in_pending_tree_now_bin;
     TileResolution tile_resolution;
     int layer_id;
     const void* tile_id;
     int source_frame_number;
 };
 
 class CC_EXPORT RasterWorkerPoolClient {
  public:
   virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0;
+  virtual void DidFinishedRunningTasks() = 0;
+  virtual void DidFinishedRunningTasksRequiredForActivation() = 0;
 
  protected:
   virtual ~RasterWorkerPoolClient() {}
 };
 
 // A worker thread pool that runs raster tasks.
 class CC_EXPORT RasterWorkerPool : public WorkerPool {
  public:
   class CC_EXPORT Task {
    public:
@@ skipping 105 matching lines @@
       const Task::Reply& reply);
 
  protected:
   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:
-    RasterTaskGraph();
-    ~RasterTaskGraph();
-
-    void InsertRasterTask(internal::WorkerPoolTask* raster_task,
-                          const TaskVector& decode_tasks);
-
-   private:
-    friend class RasterWorkerPool;
-
-    TaskGraph graph_;
-    scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
-    scoped_ptr<GraphNode> raster_finished_node_;
-    unsigned next_priority_;
-
-    DISALLOW_COPY_AND_ASSIGN(RasterTaskGraph);
-  };
-
   RasterWorkerPool(ResourceProvider* resource_provider, size_t num_threads);
 
-  virtual void OnRasterTasksFinished() {}
+  virtual void OnRasterTasksFinished() = 0;
+  virtual void OnRasterTasksRequiredForActivationFinished() = 0;
 
   void SetRasterTasks(RasterTask::Queue* queue);
-  void SetRasterTaskGraph(RasterTaskGraph* graph);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
 
   RasterWorkerPoolClient* client() const { return client_; }
   ResourceProvider* resource_provider() const { return resource_provider_; }
   const RasterTask::Queue::TaskVector& raster_tasks() const {
     return raster_tasks_;
   }
+  void set_raster_finished_task(
+      scoped_refptr<internal::WorkerPoolTask> raster_finished_task) {
+    raster_finished_task_ = raster_finished_task;
+  }
+  void set_raster_required_for_activation_finished_task(
+      scoped_refptr<internal::WorkerPoolTask>
+          raster_required_for_activation_finished_task) {
+    raster_required_for_activation_finished_task_ =
+        raster_required_for_activation_finished_task;
+  }
+
+  scoped_refptr<internal::WorkerPoolTask> CreateRasterFinishedTask();
+  scoped_refptr<internal::WorkerPoolTask>
+      CreateRasterRequiredForActivationFinishedTask();
+
+  scoped_ptr<base::Value> ScheduledStateAsValue() const;
+
+  static internal::GraphNode* CreateGraphNodeForTask(
+      internal::WorkerPoolTask* task,
+      unsigned priority,
+      TaskGraph* graph);
+
+  static internal::GraphNode* CreateGraphNodeForRasterTask(
+      internal::WorkerPoolTask* raster_task,
+      const TaskVector& decode_tasks,
+      unsigned priority,
+      TaskGraph* graph);
 
  private:
-  void OnRasterFinished(int64 schedule_raster_tasks_count);
+  void OnRasterFinished(const internal::WorkerPoolTask* source);
+  void OnRasterRequiredForActivationFinished(
+      const internal::WorkerPoolTask* source);
 
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
   RasterTask::Queue::TaskVector raster_tasks_;
   RasterTask::Queue::TaskSet raster_tasks_required_for_activation_;
 
   base::WeakPtrFactory<RasterWorkerPool> weak_ptr_factory_;
   scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
-  int64 schedule_raster_tasks_count_;
+  scoped_refptr<internal::WorkerPoolTask>
+      raster_required_for_activation_finished_task_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RASTER_WORKER_POOL_H_