cc: Generalize raster task notifications

cc/resources/gpu_raster_worker_pool.cc

Index: cc/resources/gpu_raster_worker_pool.cc
diff --git a/cc/resources/gpu_raster_worker_pool.cc b/cc/resources/gpu_raster_worker_pool.cc
index 36d62aad8a195ecdb2cad7f75df0f25d6fd48ee0..8ec05c59ae952b290bb1aabf8f8f4300dfc04781 100644
--- a/cc/resources/gpu_raster_worker_pool.cc
+++ b/cc/resources/gpu_raster_worker_pool.cc
@@ -33,7 +33,6 @@ GpuRasterWorkerPool::GpuRasterWorkerPool(base::SequencedTaskRunner* task_runner,
       resource_provider_(resource_provider),
       run_tasks_on_origin_thread_pending_(false),
       raster_tasks_pending_(false),
-      raster_tasks_required_for_activation_pending_(false),
       raster_finished_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
   DCHECK(context_provider_);
@@ -62,14 +61,10 @@ void GpuRasterWorkerPool::Shutdown() {
 void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "GpuRasterWorkerPool::ScheduleTasks");
 
-  DCHECK_EQ(queue->required_for_activation_count,
-            static_cast<size_t>(
-                std::count_if(queue->items.begin(),
-                              queue->items.end(),
-                              RasterTaskQueue::Item::IsRequiredForActivation)));
+  DCHECK(queue->VerifyTaskSetSizes());
 
   raster_tasks_pending_ = true;
-  raster_tasks_required_for_activation_pending_ = true;
+  raster_task_sets_pending_.set();
 
   unsigned priority = kRasterTaskPriorityBase;
 
@@ -78,19 +73,28 @@ void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<RasterizerTask>
-      new_raster_required_for_activation_finished_task(
-          CreateRasterRequiredForActivationFinishedTask(
-              queue->required_for_activation_count,
-              task_runner_.get(),
-              base::Bind(
-                  &GpuRasterWorkerPool::OnRasterRequiredForActivationFinished,
-                  raster_finished_weak_ptr_factory_.GetWeakPtr())));
+  std::vector<scoped_refptr<RasterizerTask> > new_task_set_finished_tasks(

[reveman, 2014/09/05 08:38:59]

kMaxTaskSet or "kMaxTaskSet + 1"? you'll probably see a perftest regression here
unless you use an array as all this RasterWorkerPool code has been tuned to do
as few heap allocations as possible with each call to ScheduleTasks.

[ernstm, 2014/09/05 21:36:10]

Done.

+      kMaxTaskSet);
+
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; ++task_set) {
+    base::debug::TraceEventSyntheticDelay* synthetic_delay = NULL;
+    if (queue->task_set_sizes[task_set] > 0)
+      synthetic_delay = client_->SyntheticDelayForTaskSet(task_set);
+
+    new_task_set_finished_tasks[task_set] = CreateRasterFinishedTask(
+        task_runner_.get(),
+        base::Bind(&GpuRasterWorkerPool::OnRasterTaskSetFinished,
+                   raster_finished_weak_ptr_factory_.GetWeakPtr(),
+                   task_set),
+        synthetic_delay);
+  }
+
   scoped_refptr<RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&GpuRasterWorkerPool::OnRasterFinished,
-                     raster_finished_weak_ptr_factory_.GetWeakPtr())));
+                     raster_finished_weak_ptr_factory_.GetWeakPtr()),
+          NULL));
 
   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
        it != queue->items.end();
@@ -99,9 +103,12 @@ void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
     RasterTask* task = item.task;
     DCHECK(!task->HasCompleted());
 
-    if (item.required_for_activation) {
-      graph_.edges.push_back(TaskGraph::Edge(
-          task, new_raster_required_for_activation_finished_task.get()));
+    for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+      if (!it->task_sets[task_set])
+        continue;
+
+      graph_.edges.push_back(
+          TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get()));
     }
 
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
@@ -110,10 +117,13 @@ void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
         TaskGraph::Edge(task, new_raster_finished_task.get()));
   }
 
-  InsertNodeForTask(&graph_,
-                    new_raster_required_for_activation_finished_task.get(),
-                    kRasterRequiredForActivationFinishedTaskPriority,
-                    queue->required_for_activation_count);
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    InsertNodeForTask(&graph_,
+                      new_task_set_finished_tasks[task_set],
+                      kRasterTaskSetFinishedTaskPriority,
+                      queue->task_set_sizes[task_set]);
+  }
+
   InsertNodeForTask(&graph_,
                     new_raster_finished_task.get(),
                     kRasterFinishedTaskPriority,
@@ -125,8 +135,7 @@ void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   ScheduleRunTasksOnOriginThread();
 
   raster_finished_task_ = new_raster_finished_task;
-  raster_required_for_activation_finished_task_ =
-      new_raster_required_for_activation_finished_task;
+  task_set_finished_tasks_ = new_task_set_finished_tasks;
 }
 
 void GpuRasterWorkerPool::CheckForCompletedTasks() {
@@ -164,13 +173,15 @@ void GpuRasterWorkerPool::OnRasterFinished() {
   client_->DidFinishRunningTasks();
 }
 
-void GpuRasterWorkerPool::OnRasterRequiredForActivationFinished() {
-  TRACE_EVENT0("cc",
-               "GpuRasterWorkerPool::OnRasterRequiredForActivationFinished");
+void GpuRasterWorkerPool::OnRasterTaskSetFinished(TaskSet task_set) {
+  TRACE_EVENT1("cc",
+               "GpuRasterWorkerPool::OnRasterTaskSetFinished",
+               "task_set",
+               task_set);
 
-  DCHECK(raster_tasks_required_for_activation_pending_);
-  raster_tasks_required_for_activation_pending_ = false;
-  client_->DidFinishRunningTasksRequiredForActivation();
+  DCHECK(raster_task_sets_pending_[task_set]);
+  raster_task_sets_pending_[task_set] = false;
+  client_->DidFinishRunningTaskSet(task_set);
 }
 
 void GpuRasterWorkerPool::ScheduleRunTasksOnOriginThread() {