cc: Generalize raster task notifications

cc/resources/pixel_buffer_raster_worker_pool.cc

Index: cc/resources/pixel_buffer_raster_worker_pool.cc
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index a5ee12f6dfce2a7073121901d9ca60f70150d7a9..2884c257ac88a0ac952ae5387f0426157b80b27a 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -9,6 +9,7 @@
 #include "base/containers/stack_container.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
+#include "base/strings/stringprintf.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ -25,6 +26,12 @@ typedef base::StackVector<RasterTask*, kMaxScheduledRasterTasks>
 
 }  // namespace
 
+PixelBufferRasterWorkerPool::RasterTaskState::RasterTaskState(
+    RasterTask* task,
+    const RasterTaskQueue::Item::TaskSetCollection& task_sets)
+    : type(UNSCHEDULED), task(task), task_sets(task_sets) {
+}
+
 // static
 scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
@@ -53,15 +60,11 @@ PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
       resource_provider_(resource_provider),
       shutdown_(false),
       scheduled_raster_task_count_(0u),
-      raster_tasks_required_for_activation_count_(0u),
       bytes_pending_upload_(0u),
       max_bytes_pending_upload_(max_transfer_buffer_usage_bytes),
       has_performed_uploads_since_last_flush_(false),
       should_notify_client_if_no_tasks_are_pending_(false),
-      should_notify_client_if_no_tasks_required_for_activation_are_pending_(
-          false),
       raster_finished_task_pending_(false),
-      raster_required_for_activation_finished_task_pending_(false),
       check_for_completed_raster_task_notifier_(
           task_runner,
           base::Bind(&PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks,
@@ -75,9 +78,10 @@ PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
 PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
   DCHECK_EQ(0u, raster_task_states_.size());
   DCHECK_EQ(0u, raster_tasks_with_pending_upload_.size());
+  DCHECK(raster_tasks_with_pending_upload_sizes_.ToTaskSetCollection().none());
   DCHECK_EQ(0u, completed_raster_tasks_.size());
   DCHECK_EQ(0u, completed_image_decode_tasks_.size());
-  DCHECK_EQ(0u, raster_tasks_required_for_activation_count_);
+  DCHECK(task_set_sizes_ == RasterTaskQueue::TaskSetSizes());
 }
 
 Rasterizer* PixelBufferRasterWorkerPool::AsRasterizer() { return this; }
@@ -117,19 +121,14 @@ void PixelBufferRasterWorkerPool::Shutdown() {
 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::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());
 
   if (!should_notify_client_if_no_tasks_are_pending_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
 
   should_notify_client_if_no_tasks_are_pending_ = true;
-  should_notify_client_if_no_tasks_required_for_activation_are_pending_ = true;
-
-  raster_tasks_required_for_activation_count_ = 0u;
+  should_notify_client_if_no_tasks_in_set_are_pending_.set();
+  task_set_sizes_ = RasterTaskQueue::TaskSetSizes();
 
   // Update raster task state and remove items from old queue.
   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
@@ -157,21 +156,19 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
     if (state_it != raster_task_states_.end()) {
       RasterTaskState& state = *state_it;
 
-      state.required_for_activation = item.required_for_activation;
+      state.task_sets = item.task_sets;
       // |raster_tasks_required_for_activation_count| accounts for all tasks
       // that need to complete before we can send a "ready to activate" signal.
       // Tasks that have already completed should not be part of this count.
-      if (state.type != RasterTaskState::COMPLETED) {
-        raster_tasks_required_for_activation_count_ +=
-            item.required_for_activation;
-      }
+      if (state.type != RasterTaskState::COMPLETED)
+        task_set_sizes_ += item.task_sets;
+
       continue;
     }
 
     DCHECK(!task->HasBeenScheduled());
-    raster_task_states_.push_back(
-        RasterTaskState(task, item.required_for_activation));
-    raster_tasks_required_for_activation_count_ += item.required_for_activation;
+    raster_task_states_.push_back(RasterTaskState(task, item.task_sets));
+    task_set_sizes_ += item.task_sets;
   }
 
   // Determine what tasks in old queue need to be canceled.
@@ -204,7 +201,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
     }
 
     // No longer required for activation.

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

this comment need to change.

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

Done.

-    state.required_for_activation = false;
+    state.task_sets.reset();
   }
 
   raster_tasks_.Swap(queue);
@@ -295,16 +292,17 @@ void PixelBufferRasterWorkerPool::OnRasterFinished() {
   CheckForCompletedRasterTasks();
 }
 
-void PixelBufferRasterWorkerPool::OnRasterRequiredForActivationFinished() {
-  TRACE_EVENT0(
-      "cc",
-      "PixelBufferRasterWorkerPool::OnRasterRequiredForActivationFinished");
+void PixelBufferRasterWorkerPool::OnRasterTaskSetFinished(TaskSet task_set) {
+  TRACE_EVENT1("cc",
+               "PixelBufferRasterWorkerPool::OnRasterTaskSetFinished",
+               "task_set",
+               task_set);
 
   // Analogous to OnRasterTasksFinished(), there's no need to call
   // CheckForCompletedRasterTasks() if the client has already been notified.
-  if (!should_notify_client_if_no_tasks_required_for_activation_are_pending_)
+  if (!should_notify_client_if_no_tasks_in_set_are_pending_[task_set])
     return;
-  raster_required_for_activation_finished_task_pending_ = false;
+  task_set_finished_tasks_pending_[task_set] = false;
 
   // This reduces latency between the time when all tasks required for
   // activation have finished running and the time when the client is
@@ -341,11 +339,24 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
 
     tasks_with_completed_uploads.push_back(task);
     raster_tasks_with_pending_upload_.pop_front();
+
+    RasterTaskState::Vector::const_iterator state_it =
+        std::find_if(raster_task_states_.begin(),
+                     raster_task_states_.end(),
+                     RasterTaskState::TaskComparator(task));
+    DCHECK(state_it != raster_task_states_.end());
+    const RasterTaskState& state = *state_it;
+    raster_tasks_with_pending_upload_sizes_ -= state.task_sets;
   }
 
   DCHECK(client_);
-  bool should_force_some_uploads_to_complete =
-      shutdown_ || client_->ShouldForceTasksRequiredForActivationToComplete();
+  bool should_force_some_uploads_to_complete = shutdown_;
+  RasterTaskQueue::Item::TaskSetCollection task_sets_forced_to_complete;
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    should_force_some_uploads_to_complete |=
+        client_->ShouldForceTaskSetToComplete(task_set);

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

How about we rename this client function to TasksThatShouldBeForcedToComplete
and have it return a TaskSetCollection? I think that will clean up this code a
bit.

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

Done.

+    task_sets_forced_to_complete[task_set] = true;
+  }
 
   if (should_force_some_uploads_to_complete) {
     RasterTask::Vector tasks_with_uploads_to_force;
@@ -361,10 +372,11 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
 
       // Force all uploads required for activation to complete.
       // During shutdown, force all pending uploads to complete.
-      if (shutdown_ || state.required_for_activation) {
+      if (shutdown_ || (state.task_sets & task_sets_forced_to_complete).any()) {
         tasks_with_uploads_to_force.push_back(task);
         tasks_with_completed_uploads.push_back(task);
         it = raster_tasks_with_pending_upload_.erase(it);
+        raster_tasks_with_pending_upload_sizes_ -= state.task_sets;
         continue;
       }
 
@@ -414,10 +426,9 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
                      task) == completed_raster_tasks_.end());
     completed_raster_tasks_.push_back(task);
     state.type = RasterTaskState::COMPLETED;
-    DCHECK_LE(static_cast<size_t>(state.required_for_activation),
-              raster_tasks_required_for_activation_count_);
-    raster_tasks_required_for_activation_count_ -=
-        state.required_for_activation;
+    // Triggers if the current task belongs to a set that should be empty.
+    DCHECK((~state.task_sets | task_set_sizes_.ToTaskSetCollection()).all());
+    task_set_sizes_ -= state.task_sets;
   }
 }
 
@@ -435,18 +446,18 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
   FlushUploads();
 
   // Determine what client notifications to generate.
-  bool will_notify_client_that_no_tasks_required_for_activation_are_pending =
-      (should_notify_client_if_no_tasks_required_for_activation_are_pending_ &&
-       !raster_required_for_activation_finished_task_pending_ &&
-       !HasPendingTasksRequiredForActivation());
+  RasterTaskQueue::Item::TaskSetCollection
+      will_notify_client_that_no_tasks_in_set_are_pending =
+          should_notify_client_if_no_tasks_in_set_are_pending_ &
+          ~task_set_finished_tasks_pending_ & ~HasPendingTasksInSets();
   bool will_notify_client_that_no_tasks_are_pending =
       (should_notify_client_if_no_tasks_are_pending_ &&
-       !raster_required_for_activation_finished_task_pending_ &&
+       !task_set_finished_tasks_pending_.any() &&
        !raster_finished_task_pending_ && !HasPendingTasks());
 
   // Adjust the need to generate notifications before scheduling more tasks.
-  should_notify_client_if_no_tasks_required_for_activation_are_pending_ &=
-      !will_notify_client_that_no_tasks_required_for_activation_are_pending;
+  should_notify_client_if_no_tasks_in_set_are_pending_ &=
+      ~will_notify_client_that_no_tasks_in_set_are_pending;
   should_notify_client_if_no_tasks_are_pending_ &=
       !will_notify_client_that_no_tasks_are_pending;
 
@@ -463,13 +474,15 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
     check_for_completed_raster_task_notifier_.Schedule();
 
   // Generate client notifications.
-  if (will_notify_client_that_no_tasks_required_for_activation_are_pending) {
-    DCHECK(!HasPendingTasksRequiredForActivation());
-    client_->DidFinishRunningTasksRequiredForActivation();
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    if (will_notify_client_that_no_tasks_in_set_are_pending[task_set]) {
+      DCHECK(!HasPendingTasksInSets()[task_set]);
+      client_->DidFinishRunningTaskSet(task_set);
+    }
   }
   if (will_notify_client_that_no_tasks_are_pending) {
     TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
-    DCHECK(!HasPendingTasksRequiredForActivation());
+    DCHECK(!HasPendingTasksInSets().any());
     client_->DidFinishRunningTasks();
   }
 }
@@ -478,7 +491,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
 
   RasterTaskVector tasks;
-  RasterTaskVector tasks_required_for_activation;
+  RasterTaskVector tasks_in_set[kMaxTaskSet];
 
   unsigned priority = kRasterTaskPriorityBase;
 
@@ -486,7 +499,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
 
   size_t bytes_pending_upload = bytes_pending_upload_;
   bool did_throttle_raster_tasks = false;
-  bool did_throttle_raster_tasks_required_for_activation = false;
+  RasterTaskQueue::Item::TaskSetCollection did_throttle_raster_tasks_in_set;
 
   for (RasterTaskQueue::Item::Vector::const_iterator it =
            raster_tasks_.items.begin();
@@ -522,8 +535,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
     if (new_bytes_pending_upload > max_bytes_pending_upload_ &&
         bytes_pending_upload) {
       did_throttle_raster_tasks = true;
-      if (item.required_for_activation)
-        did_throttle_raster_tasks_required_for_activation = true;
+      did_throttle_raster_tasks_in_set |= item.task_sets;
       continue;
     }
 
@@ -537,8 +549,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
     // Throttle raster tasks based on kMaxScheduledRasterTasks.
     if (tasks.container().size() >= kMaxScheduledRasterTasks) {
       did_throttle_raster_tasks = true;
-      if (item.required_for_activation)
-        did_throttle_raster_tasks_required_for_activation = true;
+      did_throttle_raster_tasks_in_set |= item.task_sets;
       continue;
     }
 
@@ -553,43 +564,49 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
 
     tasks.container().push_back(task);
-    if (item.required_for_activation)
-      tasks_required_for_activation.container().push_back(task);
+    for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+      if (item.task_sets[task_set])
+        tasks_in_set[task_set].container().push_back(task);
+    }
   }
 
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<RasterizerTask>
-      new_raster_required_for_activation_finished_task;
-
-  size_t scheduled_raster_task_required_for_activation_count =
-      tasks_required_for_activation.container().size();
-  DCHECK_LE(scheduled_raster_task_required_for_activation_count,
-            raster_tasks_required_for_activation_count_);
-  // Schedule OnRasterTasksRequiredForActivationFinished call only when
-  // notification is pending and throttling is not preventing all pending
-  // tasks required for activation from being scheduled.
-  if (!did_throttle_raster_tasks_required_for_activation &&
-      should_notify_client_if_no_tasks_required_for_activation_are_pending_) {
-    new_raster_required_for_activation_finished_task =
-        CreateRasterRequiredForActivationFinishedTask(
-            raster_tasks_.required_for_activation_count,
-            task_runner_.get(),
-            base::Bind(&PixelBufferRasterWorkerPool::
-                           OnRasterRequiredForActivationFinished,
-                       raster_finished_weak_ptr_factory_.GetWeakPtr()));
-    raster_required_for_activation_finished_task_pending_ = true;
-    InsertNodeForTask(&graph_,
-                      new_raster_required_for_activation_finished_task.get(),
-                      kRasterRequiredForActivationFinishedTaskPriority,
-                      scheduled_raster_task_required_for_activation_count);
-    for (RasterTaskVector::ContainerType::const_iterator it =
-             tasks_required_for_activation.container().begin();
-         it != tasks_required_for_activation.container().end();
-         ++it) {
-      graph_.edges.push_back(TaskGraph::Edge(
-          *it, new_raster_required_for_activation_finished_task.get()));
+  std::vector<scoped_refptr<RasterizerTask> > new_task_set_finished_tasks(
+      kMaxTaskSet);
+  RasterTaskQueue::TaskSetSizes scheduled_task_set_sizes;
+
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    scheduled_task_set_sizes[task_set] =
+        tasks_in_set[task_set].container().size();
+    DCHECK_LE(scheduled_task_set_sizes[task_set], task_set_sizes_[task_set]);
+    // Schedule OnRasterTasksRequiredForActivationFinished call only when
+    // notification is pending and throttling is not preventing all pending
+    // tasks required for activation from being scheduled.
+    if (!did_throttle_raster_tasks_in_set[task_set] &&
+        should_notify_client_if_no_tasks_in_set_are_pending_[task_set]) {
+      base::debug::TraceEventSyntheticDelay* synthetic_delay = NULL;
+      if (scheduled_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(&PixelBufferRasterWorkerPool::OnRasterTaskSetFinished,
+                     raster_finished_weak_ptr_factory_.GetWeakPtr(),
+                     task_set),
+          synthetic_delay);
+      task_set_finished_tasks_pending_[task_set] = true;
+      InsertNodeForTask(&graph_,
+                        new_task_set_finished_tasks[task_set].get(),
+                        kRasterTaskSetFinishedTaskPriority,
+                        scheduled_task_set_sizes[task_set]);
+      for (RasterTaskVector::ContainerType::const_iterator it =
+               tasks_in_set[task_set].container().begin();
+           it != tasks_in_set[task_set].container().end();
+           ++it) {
+        graph_.edges.push_back(
+            TaskGraph::Edge(*it, new_task_set_finished_tasks[task_set].get()));
+      }
     }
   }
 
@@ -604,7 +621,8 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
     new_raster_finished_task = CreateRasterFinishedTask(
         task_runner_.get(),
         base::Bind(&PixelBufferRasterWorkerPool::OnRasterFinished,
-                   raster_finished_weak_ptr_factory_.GetWeakPtr()));
+                   raster_finished_weak_ptr_factory_.GetWeakPtr()),
+        NULL);
     raster_finished_task_pending_ = true;
     InsertNodeForTask(&graph_,
                       new_raster_finished_task.get(),
@@ -625,8 +643,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   scheduled_raster_task_count_ = scheduled_raster_task_count;
 
   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;
 }
 
 unsigned PixelBufferRasterWorkerPool::PendingRasterTaskCount() const {
@@ -640,8 +657,12 @@ bool PixelBufferRasterWorkerPool::HasPendingTasks() const {
   return PendingRasterTaskCount() || !raster_tasks_with_pending_upload_.empty();
 }
 
-bool PixelBufferRasterWorkerPool::HasPendingTasksRequiredForActivation() const {
-  return !!raster_tasks_required_for_activation_count_;
+RasterTaskQueue::Item::TaskSetCollection
+PixelBufferRasterWorkerPool::HasPendingTasksInSets() const {
+  // TODO(ernstm): add

[ernstm, 2014/08/29 23:32:10]

With this addition, we would wait for pending uploads to complete for all task
sets. Currently we only do this for the notification for all task sets. I think
we should do this (crbug.com/389256) but in a separate patch.

+  // "| raster_tasks_with_pending_upload_sizes_.ToTaskSetCollection();" in
+  // separate patch.
+  return task_set_sizes_.ToTaskSetCollection();
 }
 
 const char* PixelBufferRasterWorkerPool::StateName() const {
@@ -707,10 +728,9 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterizerTasks() {
                        raster_task) == completed_raster_tasks_.end());
       completed_raster_tasks_.push_back(raster_task);
       state.type = RasterTaskState::COMPLETED;
-      DCHECK_LE(static_cast<size_t>(state.required_for_activation),
-                raster_tasks_required_for_activation_count_);
-      raster_tasks_required_for_activation_count_ -=
-          state.required_for_activation;
+      // Triggers if the current task belongs to a set that should be empty.
+      DCHECK((~state.task_sets | task_set_sizes_.ToTaskSetCollection()).all());
+      task_set_sizes_ -= state.task_sets;
       continue;
     }
 
@@ -719,6 +739,7 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterizerTasks() {
 
     bytes_pending_upload_ += raster_task->resource()->bytes();
     raster_tasks_with_pending_upload_.push_back(raster_task);
+    raster_tasks_with_pending_upload_sizes_ += state.task_sets;
     state.type = RasterTaskState::UPLOADING;
   }
   completed_tasks_.clear();
@@ -732,8 +753,12 @@ PixelBufferRasterWorkerPool::StateAsValue() const {
   state->SetInteger("pending_count", raster_task_states_.size());
   state->SetInteger("pending_upload_count",
                     raster_tasks_with_pending_upload_.size());
-  state->SetInteger("pending_required_for_activation_count",
-                    raster_tasks_required_for_activation_count_);
+  for (TaskSet task_set = 0; task_set < kMaxTaskSet; task_set++) {
+    state->SetInteger(
+        base::StringPrintf("pending_task_in_set_%u",
+                           static_cast<unsigned>(task_set)).c_str(),
+        task_set_sizes_[task_set]);
+  }
   state->BeginDictionary("throttle_state");
   ThrottleStateAsValueInto(state.get());
   state->EndDictionary();