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 84 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 113 matching lines @@
   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);
+                          const TaskVector& decode_tasks,
+                          bool required_for_activation);
 
    private:
     friend class RasterWorkerPool;
 
     TaskGraph graph_;
-    scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
     scoped_ptr<GraphNode> raster_finished_node_;
+    scoped_ptr<GraphNode> raster_required_for_activation_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_;
   }
 
  private:
   void OnRasterFinished(int64 schedule_raster_tasks_count);
+  void OnRasterRequiredForActivationFinished(
+      int64 schedule_raster_tasks_count);
 
   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_;
+  scoped_refptr<internal::WorkerPoolTask>
+      raster_required_for_activation_finished_task_;
   int64 schedule_raster_tasks_count_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RASTER_WORKER_POOL_H_