cc: Generalize raster task notifications

cc/resources/raster_worker_pool.cc

Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index d175141f3f6308c688637857702b0ab9d9e10275..f6e3072b9a1b59031f3128f515567e126a213525 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -18,9 +18,7 @@ namespace {
 class RasterTaskGraphRunner : public TaskGraphRunner,
                               public base::DelegateSimpleThread::Delegate {
  public:
-  RasterTaskGraphRunner()
-      : synthetic_delay_(base::debug::TraceEventSyntheticDelay::Lookup(
-            "cc.RasterRequiredForActivation")) {
+  RasterTaskGraphRunner() {
     size_t num_threads = RasterWorkerPool::GetNumRasterThreads();
     while (workers_.size() < num_threads) {
       scoped_ptr<base::DelegateSimpleThread> worker =
@@ -39,10 +37,6 @@ class RasterTaskGraphRunner : public TaskGraphRunner,
 
   virtual ~RasterTaskGraphRunner() { NOTREACHED(); }
 
-  base::debug::TraceEventSyntheticDelay* synthetic_delay() {
-    return synthetic_delay_;
-  }
-
  private:
   // Overridden from base::DelegateSimpleThread::Delegate:
   virtual void Run() OVERRIDE {
@@ -50,7 +44,6 @@ class RasterTaskGraphRunner : public TaskGraphRunner,
   }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
-  base::debug::TraceEventSyntheticDelay* synthetic_delay_;
 };
 
 base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
@@ -64,13 +57,21 @@ class RasterFinishedTaskImpl : public RasterizerTask {
  public:
   explicit RasterFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
-      const base::Closure& on_raster_finished_callback)
+      const base::Closure& on_raster_finished_callback,
+      base::debug::TraceEventSyntheticDelay* synthetic_delay)
       : task_runner_(task_runner),
-        on_raster_finished_callback_(on_raster_finished_callback) {}
+        on_raster_finished_callback_(on_raster_finished_callback),
+        synthetic_delay_(synthetic_delay) {
+    if (synthetic_delay_)
+      synthetic_delay_->BeginParallel(&activation_delay_end_time_);
+  }
 
   // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
+
+    if (synthetic_delay_)
+      synthetic_delay_->EndParallel(activation_delay_end_time_);
     RasterFinished();
   }
 
@@ -89,45 +90,10 @@ class RasterFinishedTaskImpl : public RasterizerTask {
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::Closure on_raster_finished_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
-};
-
-class RasterRequiredForActivationFinishedTaskImpl
-    : public RasterFinishedTaskImpl {
- public:
-  RasterRequiredForActivationFinishedTaskImpl(
-      base::SequencedTaskRunner* task_runner,
-      const base::Closure& on_raster_finished_callback,
-      size_t tasks_required_for_activation_count)
-      : RasterFinishedTaskImpl(task_runner, on_raster_finished_callback),
-        tasks_required_for_activation_count_(
-            tasks_required_for_activation_count) {
-    if (tasks_required_for_activation_count_) {
-      g_task_graph_runner.Get().synthetic_delay()->BeginParallel(
-          &activation_delay_end_time_);
-    }
-  }
-
-  // Overridden from Task:
-  virtual void RunOnWorkerThread() OVERRIDE {
-    TRACE_EVENT0(
-        "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnWorkerThread");
-
-    if (tasks_required_for_activation_count_) {
-      g_task_graph_runner.Get().synthetic_delay()->EndParallel(
-          activation_delay_end_time_);
-    }
-    RasterFinished();
-  }
-
- private:
-  virtual ~RasterRequiredForActivationFinishedTaskImpl() {}
-
+  base::debug::TraceEventSyntheticDelay* synthetic_delay_;
   base::TimeTicks activation_delay_end_time_;
-  const size_t tasks_required_for_activation_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(RasterRequiredForActivationFinishedTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
 };
 
 }  // namespace
@@ -140,10 +106,67 @@ unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
 unsigned RasterWorkerPool::kBenchmarkRasterTaskPriority = 0u;
 // Task priorities that make sure raster finished tasks run before any
 // remaining raster tasks.
-unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u;
-unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
-    1u;
-unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
+unsigned RasterWorkerPool::kRasterTaskSetFinishedTaskPriority = 1u;
+unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
+
+RasterWorkerPool::TaskSetSizes::TaskSetSizes() {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++)
+    sizes_[task_set] = 0;
+}
+
+RasterWorkerPool::TaskSetSizes::TaskSetSizes(const RasterTaskQueue* queue) {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++)
+    sizes_[task_set] = 0;
+
+  for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+       it != queue->items.end();
+       ++it) {
+    *this += it->task_sets;
+  }
+}
+
+TaskSetCollection RasterWorkerPool::TaskSetSizes::ToTaskSetCollection() const {
+  TaskSetCollection task_set_collection;
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (sizes_[task_set] > 0)
+      task_set_collection[task_set] = true;
+  }
+  return task_set_collection;
+}
+
+size_t& RasterWorkerPool::TaskSetSizes::operator[](TaskSet task_set) {
+  return sizes_[task_set];
+}
+
+const size_t& RasterWorkerPool::TaskSetSizes::operator[](
+    TaskSet task_set) const {
+  return sizes_[task_set];
+}
+
+bool RasterWorkerPool::TaskSetSizes::operator==(
+    const TaskSetSizes& other) const {
+  for (size_t i = 0; i < kNumberOfTaskSets; i++) {
+    if (sizes_[i] != other.sizes_[i])
+      return false;
+  }
+  return true;
+}
+
+void RasterWorkerPool::TaskSetSizes::operator+=(
+    const TaskSetCollection& task_set_collection) {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]++;
+  }
+}
+
+void RasterWorkerPool::TaskSetSizes::operator-=(
+    const TaskSetCollection& task_set_collection) {
+  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; task_set++) {
+    if (task_set_collection[task_set])
+      sizes_[task_set]--;
+  }
+}
 
 RasterWorkerPool::RasterWorkerPool() {}
 
@@ -173,21 +196,10 @@ TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
 // static
 scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
     base::SequencedTaskRunner* task_runner,
-    const base::Closure& on_raster_finished_callback) {
-  return make_scoped_refptr(
-      new RasterFinishedTaskImpl(task_runner, on_raster_finished_callback));
-}
-
-// static
-scoped_refptr<RasterizerTask>
-RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
-    size_t tasks_required_for_activation_count,
-    base::SequencedTaskRunner* task_runner,
-    const base::Closure& on_raster_finished_callback) {
-  return make_scoped_refptr(new RasterRequiredForActivationFinishedTaskImpl(
-      task_runner,
-      on_raster_finished_callback,
-      tasks_required_for_activation_count));
+    const base::Closure& on_raster_finished_callback,
+    base::debug::TraceEventSyntheticDelay* synthetic_delay) {
+  return make_scoped_refptr(new RasterFinishedTaskImpl(
+      task_runner, on_raster_finished_callback, synthetic_delay));
 }
 
 // static